Quantum error mitigation can make noisy hardware results more useful, but no single method is best for every circuit. This guide compares zero-noise extrapolation, readout-error mitigation, probabilistic error cancellation, and symmetry verification, then provides a repeatable workflow for choosing a method, estimating its cost, and checking whether an apparent improvement is real.
Overview
Current quantum hardware produces results affected by several error sources, including imperfect gates, unwanted interactions, decoherence, measurement errors, and compilation overhead. Error mitigation does not generally correct errors during execution in the same way as fault-tolerant error correction. Instead, it uses additional circuit executions, calibration data, mathematical transformations, or problem-specific checks to reduce the effect of noise in the final estimate.
The right technique depends on what you measure and what resources you can spend. Readout-error mitigation is often a sensible first test when measurement assignment errors are a visible part of the problem. Zero-noise extrapolation can be useful when you can execute related versions of a circuit at several effective noise levels. Probabilistic error cancellation can be more ambitious, but it may require detailed noise information and a large shot budget. Symmetry verification is attractive when the algorithm has a known conserved quantity or valid subspace that noisy results can violate.
Use the following high-level comparison as a starting point:
| Method | Best fit | Main input | Primary cost or risk |
|---|---|---|---|
| Readout-error mitigation | Measurement-dominated errors | Calibration or confusion data | Calibration overhead and imperfect model assumptions |
| Zero-noise extrapolation | Expectation values from repeatable circuits | Several controlled noise levels | Extra executions and unstable extrapolation |
| Probabilistic error cancellation | Detailed, characterizable noise | A noise model or quasi-probability representation | Sampling overhead and possible variance amplification |
| Symmetry verification | Algorithms with known constraints | Symmetry checks or auxiliary measurements | Discarded shots and possible estimator bias |
These methods can be combined, but combining them should be treated as an experiment rather than an automatic improvement. For example, correcting readout effects before applying another method changes the data pipeline and may alter uncertainty. Record each stage separately so that you can identify which step helped.
How to estimate
Start by defining the quantity you want to estimate. It may be an expectation value, a probability, an energy, a classification score, or an objective function used by a hybrid quantum-classical optimizer. Error mitigation should be evaluated against that quantity, not against a visually improved histogram.
A practical estimate has four parts:
- Baseline: Run the original circuit on the selected backend with a fixed shot count. Keep the transpiled circuit, seed or compilation settings where available, backend configuration, and raw counts.
- Reference: Run an ideal or carefully selected noisy simulation with the same logical circuit and measurement definition. An ideal simulation is useful for orientation, but it is not always a complete model of hardware behavior.
- Mitigated estimate: Apply one method using a documented calibration set, noise scale, symmetry rule, or learned representation.
- Uncertainty and cost: Report the number of circuit executions, total shots, calibration executions, post-processing time, and an uncertainty estimate for every result.
For an expectation value, compare the unmitigated and mitigated estimates with the reference using an absolute error such as:
absolute error = |mitigated estimate - reference estimate|
Also calculate the change relative to the hardware baseline:
improvement = baseline error - mitigated error
A positive improvement is useful only if it is larger than the combined statistical uncertainty and remains visible under repeated runs. For more background on counts, probabilities, and expectation values, see Quantum Measurement Results in Python.
Choosing a method by circuit and backend
Use readout-error mitigation first when the circuit is relatively short but measured probabilities are distorted. It is especially easy to test on small qubit subsets, where calibration circuits are manageable. It is less informative when gate errors dominate or when the circuit prepares a highly mixed state.
Consider zero-noise extrapolation when the circuit can be executed at multiple effective noise levels without changing its intended computation. Noise scaling can be created through controlled gate stretching, repetition, or another SDK-supported technique. Fit a simple model to the measured values and extrapolate toward the nominal zero-noise point. Use as few model assumptions as possible: a more flexible fit can follow statistical fluctuations rather than the underlying trend.
Use probabilistic error cancellation only when the noise characterization and sampling budget justify it. The method represents an ideal operation as a weighted combination of noisy operations and estimates the result by sampling that combination. In practice, the variance can grow quickly as the circuit becomes deeper or the noise representation becomes less favorable, so a lower apparent bias may come with a much higher shot requirement.
Choose symmetry verification when you know a reliable constraint. Examples include a conserved parity, particle number, or another property that the ideal state must satisfy. Measure or infer the relevant symmetry, reject invalid outcomes, or use the symmetry information to construct an estimator. Track the fraction of discarded shots: a result based on very few retained samples may look cleaner while becoming less statistically reliable.
Inputs and assumptions
Before running an experiment, create an input sheet. At minimum, record:
- Circuit structure: qubit count, logical depth, two-qubit gate count, measurement locations, and parameter values.
- Compiled structure: physical-qubit mapping, transpiled depth, native gate counts, inserted routing operations, and any dynamic operations.
- Shot budget: shots for the baseline, each noise scale, calibration circuits, symmetry checks, and repeats.
- Noise assumptions: whether errors are treated as stationary, gate-local, Markovian, independent, or correlated. These are modeling assumptions, not guaranteed hardware properties.
- Estimator definition: how counts become probabilities or expectation values, including post-selection and any normalization.
- Reference method: ideal simulation, a noise-model simulation, a smaller exact calculation, or another clearly labeled benchmark.
- Success criterion: lower error, stable confidence interval, improved application objective, or a specified trade-off between accuracy and execution cost.
Do not compare methods using different transpilation settings or unrelated circuit versions. Compilation can change depth and two-qubit operations enough to confound the result. Review Quantum Circuit Transpilation Explained and Quantum Circuit Resource Estimation before assigning a shot budget.
Noise-model simulations are useful for screening methods, but they should not be treated as proof of hardware performance. A simulator may omit drift, crosstalk, scheduling effects, or measurement behavior. Use it to identify plausible settings, then validate the selected workflow on the target backend. The companion guide to Quantum Noise Models in Practice can help separate gate, readout, and decoherence assumptions.
Worked examples
Example 1: A short circuit with distorted measurements
Suppose a small circuit has modest depth, but its measured distribution differs noticeably from an ideal simulation. Run the original circuit with a fixed number of shots, collect calibration data for the measured qubits, and apply readout-error mitigation. Repeat the same experiment without mitigation and compare both estimates with the reference.
The decision is not simply whether the corrected histogram is closer by eye. Check the absolute error for each reported probability, the confidence interval, and the calibration overhead. If the corrected result changes substantially between calibration runs, treat the method as sensitive to backend conditions and repeat the calibration closer to the production run.
Example 2: An expectation value from a deeper circuit
For a deeper variational circuit, create three or more controlled noise levels and measure the same expectation value at each level. Plot the values with uncertainty bars, fit a preselected extrapolation model, and evaluate the estimate at the zero-noise point. Compare it with the unmitigated value and a simulation reference.
Before accepting the extrapolated value, run a holdout test using another parameter setting or circuit instance. If the fitted curve changes direction, has large uncertainty, or produces an estimate outside a physically valid range, report the instability rather than selecting the most favorable result.
Example 3: A circuit with a conserved quantity
Assume the ideal algorithm preserves a known parity. Add the required measurements, classify shots according to the parity condition, and calculate the target estimator using valid shots. Report the total shots, retained shots, retention rate, unmitigated result, and verified result. If the retention rate is low, increase the shot budget or reconsider whether post-selection provides enough value for the application.
For all three examples, keep raw counts and metadata. A compact result table should include: backend identifier, execution time window, circuit hash, transpiled depth, shot count, mitigation method and settings, calibration cost, estimate, uncertainty, reference value, and pass/fail status against the predefined criterion.
When to recalculate
Recalculate the comparison whenever a meaningful input changes. This includes switching backends or physical-qubit mappings, changing circuit depth or ansatz parameters, altering transpilation settings, reducing the shot budget, or changing the observable. Re-run calibration when the workflow assumes that readout behavior or another noise characteristic is stable only for a limited period.
Review the experiment after SDK, compiler, runtime, or cloud-platform updates. API behavior, supported mitigation primitives, transpilation defaults, and execution workflows can change, so pin the software environment and record versions in your results. Do not assume that an example written for one release produces identical circuits or metadata in another.
A practical refresh routine is:
- Re-run the unmitigated baseline and reference simulation.
- Recompute circuit resources after compilation.
- Repeat the selected mitigation with the same acceptance criteria.
- Compare accuracy, uncertainty, shot cost, calibration cost, and post-processing time.
- Keep the method only if its benefit survives repeated trials and remains relevant to the application objective.
For team workflows, place these checks in automated tests or scheduled benchmark jobs where practical. The guidance in CI/CD and Automated Tests for Hybrid Quantum-Classical Applications can help organize regression checks. Revisit the full decision matrix at least when your backend, circuit family, shot budget, or software stack changes—not merely when a mitigated result looks better. That discipline is the difference between a reproducible quantum error mitigation experiment and an isolated favorable run.