Quantum error mitigation can make near-term hardware results more useful without requiring a fully fault-tolerant quantum computer. This guide explains when to use readout mitigation, zero-noise extrapolation, probabilistic error cancellation, and symmetry verification, then provides a repeatable experiment checklist for comparing raw and mitigated results.
Overview
Quantum error mitigation is a family of techniques that reduces the effect of errors in measured results rather than correcting every error during computation. That distinction matters. Error mitigation usually adds experimental overhead and statistical uncertainty, but it can be practical for short- to medium-depth circuits when full quantum error correction is not available.
A useful workflow separates three questions:
- Where does the dominant error enter? It may arise during measurement, from gates and idle periods, or from a mixture of hardware and compilation effects.
- What does the algorithm measure? An expectation value, a probability distribution, a bitstring, or a quantity with a known symmetry may call for different methods.
- Can the added sampling and calibration cost be justified? A mitigated estimate is not automatically better if its variance becomes too large or its assumptions do not match the device.
Before choosing a technique, establish a trusted baseline. Run the circuit on an ideal simulator when feasible, and use a noise-aware simulator only as a model rather than as proof of hardware behavior. For hardware preparation, review circuit depth, gate counts, connectivity, and shot requirements using a quantum circuit resource estimation checklist. Then inspect device-level metrics and recent calibration information before selecting qubits.
The main techniques at a glance
| Technique | Best fit | What it requires | Main caveat |
|---|---|---|---|
| Readout error mitigation | Measured probabilities and expectation values affected by assignment errors | Calibration circuits or an equivalent readout model | Can amplify statistical noise, especially with many qubits |
| Zero-noise extrapolation (ZNE) | Expectation values from circuits where noise can be scaled in a controlled way | Several noise-scaled circuit executions and an extrapolation model | Extrapolation can be unstable and is not guaranteed to reflect zero-noise behavior |
| Probabilistic error cancellation (PEC) | Experiments with a calibrated noise model and a high value per estimate | Detailed operation-level noise characterization and substantial sampling | Sampling overhead can grow quickly |
| Symmetry verification | Algorithms with a known conserved quantity or valid subspace | A measurable symmetry and a rule for rejecting or reweighting invalid outcomes | Discarding shots reduces effective sample size and may hide modeling problems |
These methods can be combined, but combinations should be treated as new experiments. For example, applying readout mitigation before symmetry verification may produce a different result from verifying raw outcomes first. Record the order explicitly.
Checklist by scenario
Scenario 1: Readout errors dominate
Choose readout error mitigation when the circuit is short enough that the state preparation and computation are credible, but measurement assignment errors noticeably distort the output. This is often the most accessible starting point because it does not require deliberately making the circuit noisier.
- Measure calibration circuits that prepare the basis states relevant to your experiment.
- Estimate the assignment matrix or another readout model using the same qubits and measurement settings.
- Check whether the model assumes independent readout errors. If so, treat correlated errors as a possible limitation.
- Apply the correction to probabilities or expectation values, and retain uncertainty estimates.
- Compare corrected results with calibration data and with an ideal or noise-aware simulation.
Readout mitigation is especially useful for simple demonstrations, small variational circuits, and experiments where the main output is a distribution. It is less attractive when deep circuit errors dominate or when calibration overhead exceeds the value of the correction.
Scenario 2: You need an expectation value from a noisy circuit
Use zero-noise extrapolation when the target is an expectation value and you can create several versions of the same logical circuit with different effective noise levels. Noise scaling may involve gate folding or another framework-supported transformation. The exact implementation depends on the SDK and backend, so verify that the transformation preserves the intended logical computation.
- Run the unscaled circuit and record its expectation value.
- Create two or more noise-scaled versions using a documented method.
- Keep shots, measurement grouping, transpilation settings, qubit mapping, and observable definitions as consistent as possible.
- Fit a simple extrapolation model to the measured values.
- Report both the raw value and the extrapolated value, including the scaling factors and fit choice.
Start with a low-complexity fit. A higher-order model can follow statistical fluctuations rather than the underlying trend. If the noise-scaled values are not ordered or show large uncertainty, treat the extrapolated result as inconclusive rather than forcing a favorable interpretation.
Scenario 3: A known symmetry identifies valid results
Symmetry verification is a good match for problems with a conserved particle number, parity, or another operator whose value is known for the prepared state and intended dynamics. Measure the relevant symmetry when possible, then retain, reject, or separately analyze outcomes according to that condition.
- Write down the symmetry before running the experiment.
- Confirm that state preparation, gates, and measurements support the assumed symmetry.
- Track the fraction of shots that pass verification.
- Compare the verified result with the unfiltered result.
- Investigate a large rejection rate before interpreting the filtered estimate.
A low acceptance rate may indicate useful error detection, but it can also signal that the circuit, transpilation, or symmetry definition is mismatched. Verification should expose that issue, not conceal it.
Scenario 4: You have a detailed noise model and a large sampling budget
Probabilistic error cancellation can be considered when the experiment justifies extensive calibration and sampling. The method represents noisy operations using combinations of operations whose weighted average approximates an ideal operation. In practice, the quality of the noise model and the sampling overhead determine whether the estimate is useful.
Use PEC selectively for a small benchmark or a high-value observable rather than applying it indiscriminately to every circuit. Validate the model on circuits with known answers, and compare the mitigated estimate against simpler baselines such as raw measurement and readout-corrected results.
A practical combination
For many experiments, a sensible sequence is: establish a raw baseline, calibrate readout errors, add symmetry verification if the problem supports it, and test ZNE only on observables where a noise-scaling trend can be defended. This staged approach makes it easier to identify which method changed the result. It also avoids treating a stack of corrections as a single unexplained improvement.
What to double-check
Reliable quantum error mitigation depends as much on experimental controls as on the mitigation formula.
- Backend and calibration: Confirm the selected device, qubit mapping, gate set, coupling constraints, and calibration window. Hardware behavior can change, so do not assume that a previous mitigation result transfers unchanged.
- Transpilation: Compare logical circuits, not only source code. Different optimization levels can change depth, inserted gates, routing, and the error profile. Review the guidance on transpiling and optimizing circuits for real hardware.
- Observable definition: Ensure that raw counts, corrected probabilities, basis rotations, and expectation-value conventions are identical across runs.
- Shot allocation: Mitigation often requires more executions. Record shots per circuit, number of noise scales, calibration shots, and discarded shots.
- Uncertainty: Use repeated runs, resampling, or another appropriate method to estimate uncertainty. A shifted central value without an uncertainty estimate is incomplete.
- Reference results: Keep an ideal simulator result for small circuits and a noise-aware simulation when its assumptions are documented. A simulator is a comparison point, not a substitute for hardware validation.
- SDK behavior: Check the current implementation, supported backend features, transpiler behavior, and result-format conventions in the framework you use. A Qiskit, Cirq, PennyLane, or cloud-platform workflow may expose different controls. The circuit portability checklist can help identify framework-specific differences.
Common mistakes
Calling every improvement mitigation
A result that moves closer to an expected answer in one run is not sufficient evidence. Compare raw and mitigated values over repeated executions, and report cases where mitigation worsens the estimate.
Ignoring variance amplification
Readout inversion, extrapolation, and probabilistic methods can increase uncertainty. Always inspect confidence intervals or error bars, not just the central estimate.
Changing too many variables at once
If you change qubit mapping, optimization level, shot count, measurement grouping, and mitigation method simultaneously, you cannot tell what caused the result. Use controlled comparisons.
Overfitting ZNE
More noise scales and a more flexible fit do not automatically produce a better zero-noise estimate. Use the simplest model consistent with the data and test sensitivity to the selected scales.
Applying symmetry verification without validating the symmetry
Filtering outcomes based on an incorrect or broken symmetry can remove legitimate results. Confirm the expected eigenvalue and account for any symmetry-breaking terms in the problem.
Using a noise model as ground truth
A modeled backend can help design an experiment, but real devices may include drift, crosstalk, correlated errors, and compilation effects that the model omits. Treat model agreement as evidence about the model, not definitive proof about the hardware.
For a broader reliability process, pair mitigation with circuit tests and debugging practices from this quantum program testing workflow.
When to revisit
Revisit your quantum error mitigation plan before each meaningful hardware campaign, after changing the backend, and whenever the circuit or SDK workflow changes. A new qubit mapping, transpiler release, gate decomposition, measurement grouping strategy, or shot budget can change the dominant error and invalidate an earlier comparison.
Use this action checklist before your next run:
- Define the observable, expected symmetry, and acceptable uncertainty.
- Run a small raw baseline and record the complete execution settings.
- Choose the least complex mitigation method that matches the suspected error.
- Prepare an ideal reference and, where useful, a documented noise-aware simulation.
- Reserve shots for calibration, repeated trials, and uncertainty estimation.
- Compare raw, mitigated, and reference results in the same report.
- Record mitigation order, SDK version, backend details, scaling factors, fit model, and rejected-shot counts.
- Decide in advance what would make the mitigation inconclusive or unsuccessful.
Keep the record as a reusable benchmark rather than a one-off result. When hardware capabilities, framework implementations, or circuit requirements change, rerun the same compact benchmark first. That practice makes it easier to determine whether an apparent improvement comes from error mitigation, a better device, a changed compiler workflow, or ordinary sampling variation.