Quantum error mitigation can improve estimates from noisy quantum circuits, but every technique trades additional circuit executions, assumptions, or variance for that improvement. This guide compares zero-noise extrapolation, readout-error mitigation, probabilistic error cancellation, symmetry verification, and Clifford data regression, then shows how to estimate overhead and validate whether mitigation helped rather than merely changed the answer.
Overview
Quantum error mitigation is a collection of software and experimental techniques for reducing the effect of errors in near-term quantum computations. It does not replace fault-tolerant error correction: the circuit still runs on noisy hardware, and the mitigated result remains an estimate. The practical question is therefore not “Which method is best?” but “Which method matches this circuit, observable, noise profile, shot budget, and validation target?”
For a developer, the decision usually starts with the quantity being estimated. A measured probability, expectation value, energy, or objective function can respond differently to the same noise. Readout correction is aimed primarily at measurement assignment errors. Zero-noise extrapolation (ZNE) uses results from deliberately noisier circuits to estimate a lower-noise value. Probabilistic error cancellation (PEC) combines noisy operations with signed or weighted contributions to reconstruct an ideal operation, often at substantial sampling cost. Symmetry verification discards or reweights results that violate a known property of the problem. Clifford data regression (CDR) learns a correction from circuits that are related to the target but classically tractable or otherwise easier to characterize.
Mitigation is most useful when the unmitigated circuit contains meaningful signal but hardware noise introduces a bias that can be modeled, calibrated, filtered, or extrapolated. If the circuit output is already dominated by statistical uncertainty or the noise changes the computation qualitatively, mitigation may add cost without producing a trustworthy result.
Technique comparison
| Method | Additional runs | Main assumptions | Runtime and shot overhead | Good fit |
|---|---|---|---|---|
| Readout-error mitigation | Calibration circuits plus the target circuit | Measurement errors can be characterized and the calibration remains relevant | Calibration cost and classical correction; statistical noise can increase after inversion | Shallow or deep circuits whose main visible problem is incorrect final-state measurement |
| Zero-noise extrapolation | Several noise-scaled versions of each target circuit | The observable changes smoothly enough with the chosen noise scale to extrapolate toward lower noise | Multiple circuit executions; extrapolation can amplify variance | Expectation values and variational workloads with controllable noise scaling |
| Probabilistic error cancellation | Many sampled circuit variants, based on a noise model | The error channel and its decomposition are sufficiently well characterized | Potentially very high sampling overhead and weighted-estimator variance | Small, well-characterized circuits where accuracy justifies substantial execution cost |
| Symmetry verification | Usually the target circuit, with post-processing; sometimes extra measurement bases | The ideal state or observable obeys a known symmetry and violations identify errors | Discarding shots reduces effective sample size; extra measurements may be required | Algorithms with conserved parity, particle number, or another reliable constraint |
| Clifford data regression | Target circuit plus related training circuits | Training circuits expose a correction that transfers to the target workload | Training-set execution and classical model fitting | Structured circuits where suitable near-Clifford or classically simulable variants can be generated |
The table is a planning aid, not a guarantee. Two methods can be combined, but their costs and statistical effects should be measured together. For example, correcting readout errors before or after another mitigation step can produce different results depending on the estimator and implementation.
How to estimate
Estimate mitigation as an experiment budget, not just a circuit count. Start with the baseline number of circuits and shots:
Baseline executions = number of circuits × shots per circuit.
Then model each mitigation method separately. If ZNE uses k noise scales for one circuit, its first-order execution estimate is approximately:
ZNE executions = number of target circuits × k × shots per scale.
This excludes calibration and transpilation overhead. If different scales receive different shot allocations, sum those allocations rather than multiplying by a single average.
For readout-error mitigation, add calibration executions. A simple calibration may require circuits designed to prepare known computational-basis states. The exact number depends on the number of measured qubits, whether correlations are modeled, and the chosen calibration strategy. Treat the calibration as a separate workload and record its timestamp, backend, qubit mapping, and measurement settings.
For symmetry verification, estimate the retained-shot fraction:
Effective shots = total shots × fraction of shots that pass the symmetry check.
A lower retained fraction means the mitigated estimator may have higher statistical uncertainty even if its bias is reduced. For PEC, do not estimate only the number of circuit variants. Track the sampling overhead of the decomposition and the variance of the weighted estimator. For CDR, count both the training circuits and the target circuits, then reserve enough shots to determine whether the fitted correction transfers beyond the training set.
A useful comparison metric is the cost per validated estimate:
Cost per validated estimate = total executions and classical processing ÷ number of estimates that pass predefined validation checks.
This avoids treating a numerically different answer as an improvement. Define success before running the experiment: lower error against an ideal simulator for a small circuit, closer agreement with a known conservation law, lower deviation from a trusted reference, or improved stability across independent runs.
Inputs and assumptions
Record the following inputs in experiment metadata so that another run can be compared fairly:
- Circuit definition: qubit count, depth, two-qubit gate count, parameter values, measurements, and transpilation settings.
- Observable: bitstring probability, Pauli expectation, energy estimate, optimization objective, or another clearly defined quantity.
- Shot budget: shots per circuit, allocation across noise scales, and whether shots are split between calibration and production data.
- Noise conditions: backend, qubit layout, gate set, circuit duration where available, calibration context, and any inserted noise-scaling operations.
- Reference: an ideal simulator for small circuits, a high-shot simulator, an analytically known result, or a trusted experimental baseline.
- Mitigation settings: calibration circuits, correction model, extrapolation function, noise scales, symmetry rule, regression features, and random seeds.
Do not assume that an ideal simulator is always a sufficient reference. It tests implementation and small-circuit behavior, but it may not represent hardware noise. Conversely, comparing only with hardware data cannot establish that mitigation reduced error unless the comparison has a defined target.
Separate bias from variance. Bias is a systematic displacement from the reference. Variance is run-to-run fluctuation caused by finite shots and stochastic execution. A mitigation method can reduce bias while increasing variance. Report both when possible, using repeated batches or bootstrap intervals rather than one unusually favorable result.
Framework APIs and provider-supported primitives change over time. Keep the mitigation configuration in version-controlled code, and verify whether the selected backend supports the required noise scaling, calibration, observable format, or execution mode before treating a local test as portable.
Worked examples
Example 1: Choosing between raw execution, readout correction, and ZNE
Assume a developer measures one expectation value from 20 target circuits and plans 2,000 shots per circuit. The raw baseline is 40,000 circuit shots. A readout-mitigation plan adds a calibration workload and keeps the 40,000 target shots. Its target execution count is therefore unchanged, but its total budget includes calibration shots and classical correction.
Now assume a ZNE plan uses three noise scales with 2,000 shots at each scale. The target portion becomes 20 × 3 × 2,000, or 120,000 circuit shots before any calibration. ZNE is a reasonable candidate if the observable changes smoothly across those scales and the extrapolated result is stable when one scale or fit model is removed. It is a weaker candidate if the scaled circuits cross a qualitative behavior change or the extrapolation is dominated by one noisy point.
Example 2: Symmetry verification in a variational workflow
Suppose a variational circuit produces 10,000 measured shots, but only 7,500 satisfy a known parity constraint. The verified estimate uses 7,500 shots, not 10,000. If the unverified estimate is biased by symmetry-breaking errors, the filtered result may be closer to the target. If the retained sample is small or the discarded shots were not strong indicators of error, the uncertainty can increase without a meaningful accuracy gain. Compare both estimates against a reference and report the retained-shot fraction alongside the result.
Example 3: A validation table
For each observable, maintain a table with three primary columns: ideal reference, raw noisy result, and mitigated result. Add absolute error for the raw and mitigated values, confidence intervals or repeated-run spread, total shots, and calibration metadata. A method has evidence of helping when the mitigated error decreases under the same evaluation procedure, remains reasonably stable across independent batches, and does not rely on a post-selection rule that was chosen after seeing the result.
For a variational algorithm such as VQE or QAOA, repeat this comparison at several parameter settings rather than checking only the final optimum. A mitigation method that improves one point but distorts the objective landscape can make optimization less reliable. The practical output is not merely a lower energy or higher objective value; it is a better-supported estimate with known uncertainty and reproducible settings.
When to recalculate
Recalculate the mitigation budget and repeat validation whenever the underlying inputs change. The most important triggers are a new backend or qubit layout, a fresh calibration period, a different transpilation result, a changed circuit depth, a new shot budget, a different observable, or a revised noise model. Revisit the comparison after upgrading the quantum SDK or provider integration as well, because supported primitives, execution behavior, and configuration names may change.
Use this practical checklist before accepting an apparent improvement:
- Was the ideal, raw-noisy, and mitigated result generated from the same logical circuit and observable?
- Was the reference appropriate for the circuit size and use case?
- Did the mitigated estimate improve absolute error, not just move in a preferred direction?
- Were shot counts, seeds, layouts, and calibration conditions recorded?
- Did uncertainty or run-to-run spread increase enough to change the conclusion?
- Was the validation set independent of any circuits used to fit a regression or select parameters?
- Did post-selection discard an unexpectedly large fraction of data?
- Does the improvement persist across observables, parameter settings, or repeated batches?
For implementation details, pair this workflow with guidance on building and validating quantum noise models, measurement and result post-processing, and reproducible quantum experiments. For a broader developer workflow, see the guide to quantum error mitigation techniques and practical workflows.
The safest default is to begin with the least expensive method that matches the observed error, establish a raw baseline, and increase complexity only when the added cost produces a repeatable, independently checked improvement.