Quantum error mitigation helps developers extract more reliable results from noisy quantum circuits without waiting for full fault-tolerant quantum computing. This guide explains how to choose a mitigation technique, estimate its sampling and runtime cost, compare outcomes against a baseline, and build a repeatable workflow across simulators and hardware backends.
Overview
Quantum hardware can introduce errors through imperfect gates, measurement noise, decoherence, crosstalk, calibration drift, and limited connectivity. A circuit that is correct in an ideal simulator may produce biased or unstable results on a real device. Error mitigation does not remove those physical errors. Instead, it uses additional measurements, calibration data, circuit transformations, or statistical post-processing to estimate what the result might have been under lower noise.
This makes mitigation different from quantum error correction. Error correction aims to encode logical information across physical qubits and actively detect and correct errors. Error mitigation generally works with the existing noisy circuit and attempts to reduce the effect of errors on an observable, expectation value, probability distribution, or decision metric. It can be useful for near-term experiments, but its results should be treated as estimates with uncertainty rather than guaranteed corrections.
The right approach depends on the error you are investigating. Measurement-error mitigation is a natural first choice when readout confusion dominates. Zero-noise extrapolation can help when you can run related versions of a circuit at several effective noise levels. Probabilistic error cancellation can be powerful for carefully characterized circuits, but it may require a large increase in sampling. In every case, mitigation should be evaluated against an unmitigated baseline and, where possible, an ideal or high-quality simulated reference.
How to estimate
Start by defining the quantity you want to improve. It might be the expectation value of a Hamiltonian, the probability of a target bit string, the success rate of an algorithm, or the objective value used by a classical optimizer. Avoid saying that a circuit is “more accurate” without specifying this measurement.
Use the following workflow:
- Run an ideal reference. Use a noiseless simulator for small circuits or a trusted approximation for larger ones. Record the target observable and any relevant distribution metrics.
- Run a noisy baseline. Execute the unmitigated circuit with a fixed shot count, backend, compilation configuration, and randomization policy. Save raw counts, metadata, and timestamps.
- Characterize the likely error. Compare simulator and hardware results, inspect calibration information when available, and test whether changing measurement settings or circuit depth changes the discrepancy.
- Select the least expensive suitable method. Correct readout problems before applying a method intended to address gate noise. Do not combine techniques automatically; measure the incremental benefit of each one.
- Estimate total execution cost. Count every circuit submitted, including calibration circuits, noise-scaled variants, randomized versions, and repetitions. A simple estimate is
total shots = number of circuits × shots per circuit. - Validate the result. Compare the mitigated value with the baseline, reference, and repeated runs. Report uncertainty and note whether mitigation increased variance or changed the qualitative conclusion.
For a numerical comparison, track absolute error as |mitigated result − reference result|. If no reliable reference exists, track stability across repeated runs and compare the result with physically or mathematically known bounds. A mitigation method that produces a visually plausible value but violates a known bound requires investigation, not acceptance.
Inputs and assumptions
A useful estimate should make its inputs explicit. Record the following before comparing techniques:
- Circuit workload: number of qubits, depth, two-qubit gate count, measurement groups, and the number of parameter settings.
- Shot budget: shots for the baseline, each mitigation circuit, and any calibration experiment.
- Noise model: ideal simulation, simulated noise, hardware execution, or a mixture. Results from these environments should not be treated as interchangeable.
- Target metric: expectation value, probability, distribution distance, optimizer objective, or classification outcome.
- Variance tolerance: how much uncertainty the application can accept. Some methods reduce bias while increasing statistical variance.
- Execution constraints: queue time, device availability, maximum circuit size, transpilation behavior, and whether the SDK or provider exposes the required mitigation primitive.
- Reproducibility settings: backend identifier, compilation options, seeds where supported, circuit versions, and calibration timestamps.
SDK support changes over time and may differ between local simulators, managed services, and hardware providers. Treat framework documentation as an implementation detail to verify for the selected environment. Keep the experiment design independent from a single API where practical: store circuits, raw counts, mitigation settings, and post-processing parameters so the analysis can be rerun if an interface changes.
| Technique | Best suited to | Typical tradeoff | What to estimate |
|---|---|---|---|
| Measurement-error mitigation | Readout bias and confusion | Calibration circuits and post-processing overhead | Calibration size, matrix stability, and corrected-count uncertainty |
| Zero-noise extrapolation | Estimating an observable at lower effective noise | Multiple circuit variants and an extrapolation model | Noise scale factors, fit sensitivity, and total shots |
| Probabilistic error cancellation | Circuits with a usable noise characterization | Potentially high sampling overhead and variance | Quasiparticle weights, repetitions, and variance growth |
| Symmetry or physics-based checks | Problems with known conserved quantities or constraints | Requires a valid problem-specific assumption | Violation rate before and after post-processing |
Worked examples
Example 1: Readout correction
Suppose a two-qubit circuit uses 1,000 shots for its production run. You add a calibration set containing one circuit for each computational-basis preparation. If the calibration uses 250 shots per preparation and there are four preparations, the measurement experiment uses 1,000 calibration shots plus the original 1,000 production shots, for 2,000 shots before any repeats. The decision is worthwhile only if the readout-corrected observable is more stable or closer to the reference than the unmitigated result. If calibration is repeated at several time points, include every repeat in the budget.
Example 2: Zero-noise extrapolation
Assume you execute three noise-scaled versions of a circuit, each with 2,000 shots, and repeat the set for five parameter values in a variational workflow. The basic execution total is 3 × 2,000 × 5 = 30,000 shots, before retries or calibration runs. Compare at least two extrapolation models or sensitivity checks if the circuit is small enough. If the extrapolated value changes substantially when one scale factor is removed, the estimate is model-sensitive and should be reported as such.
Example 3: Choosing between methods
Imagine that measurement correction lowers a known readout bias with a modest calibration budget, while zero-noise extrapolation requires three times as many circuit variants and produces a wider confidence interval. Start with measurement correction, then test zero-noise extrapolation only if the remaining error affects the application’s decision. This is not a claim that one method is universally better; it is a workflow for spending sampling capacity where it addresses the observed error.
When to recalculate
Recalculate the mitigation estimate whenever the inputs that determine error or sampling overhead change. This includes moving to a different backend, changing qubit allocation, recompiling the circuit, increasing depth, altering the shot count, updating the SDK, or changing the observable. Revisit it after a calibration period changes as well, because a mitigation model built from old calibration data may no longer describe the execution environment.
Use this practical checklist before each meaningful benchmark:
- Run the same unmitigated baseline with a fixed shot budget.
- Record backend, circuit hash, compilation settings, calibration context, and SDK version.
- Measure the number of circuits and shots added by mitigation.
- Compare bias, variance, runtime, and stability—not only the central estimate.
- Check physical bounds, symmetries, and known constraints.
- Repeat enough runs to distinguish a real improvement from sampling fluctuation.
- Keep the raw results so another method can be tested later.
Finally, treat mitigation as part of quantum circuit debugging rather than as a final polish step. First verify that the circuit expresses the intended algorithm, then isolate simulator, compilation, gate, and measurement effects. Guides on quantum circuit debugging and running circuits on real hardware provide useful context for that workflow. When comparing SDK implementations, document the exact execution path; framework differences can affect compilation and measurement behavior. Recalculate the budget and validation metrics whenever that path changes.