Quantum error mitigation can make noisy-circuit results more useful, but it cannot turn imperfect hardware into a fault-tolerant quantum computer. This guide compares zero-noise extrapolation (ZNE), readout-error correction, probabilistic error cancellation (PEC) and symmetry verification, then provides a repeatable workflow for choosing a method, estimating its cost, configuring an experiment in Qiskit or PennyLane, and reporting whether an apparent improvement is statistically credible.
Overview
Near-term quantum processors produce results affected by several error sources. Gates may introduce noise, qubits can lose coherence during a circuit, measurements can be misclassified, and the device’s behaviour can vary over time. Error mitigation uses additional measurements, calibration data or physical assumptions to reduce the effect of these errors after—or alongside—the circuit execution. It does not encode information redundantly or correct errors during computation in the same way as quantum error correction.
The right technique depends on the experiment. A circuit with a simple measurement problem may benefit from readout correction. An expectation-value calculation whose gate noise can be scaled may suit ZNE. PEC can target a broader noise model, but its sampling overhead can become severe. Symmetry verification is attractive when the problem has a known conserved quantity or validity condition.
| Method | Main target | Circuit or execution overhead | Hardware assumptions | Noise-model requirements | Statistical cost | Suitable experiments |
|---|---|---|---|---|---|---|
| Zero-noise extrapolation | Bias from gate and circuit noise | Several noise-scaled executions of the same circuit | The device must support a reasonably controlled way to increase noise, such as folding or a calibrated scaling procedure | Assumes the observable changes smoothly enough with noise for extrapolation to be meaningful | Higher variance because multiple estimates are combined | Expectation values, variational algorithms and benchmark circuits |
| Readout-error correction | Measurement misclassification | Calibration circuits plus post-processing; sometimes a larger calibration matrix | Readout behaviour should be measured near the experiment and remain sufficiently stable | Requires a model of assignment errors, often based on calibration data | Can increase variance, especially for large or ill-conditioned calibration matrices | Computational-basis counts, bitstring probabilities and final measurements |
| Probabilistic error cancellation | Gate-noise bias represented by an error model | Many sampled circuits or circuit decompositions | Requires carefully characterised operations and enough execution capacity | Needs a useful noise model and a decomposition of noisy operations into implementable terms | Potentially very high; sampling overhead can grow rapidly with circuit depth | Small circuits and controlled experiments where model quality can be tested |
| Symmetry verification | Results that violate a known physical or mathematical constraint | Additional measurements or post-selection, depending on the implementation | The circuit must have a reliable, known symmetry or validity rule | Does not require a complete noise model, but relies on the symmetry being correctly specified | Discarding invalid samples reduces the effective sample size | Hamiltonian simulation, quantum chemistry, encoded subspaces and constrained algorithms |
These methods can also be combined. For example, a workflow may calibrate readout errors first, then apply ZNE to an expectation value. Combining methods should be treated as a new experiment: each additional processing step changes the uncertainty and can introduce assumptions that need testing.
How to estimate
Before choosing a mitigation method, define the quantity you are trying to estimate. Let the unmitigated estimate be y_raw, the mitigated estimate be y_mit, and a trusted reference or simulator estimate be y_ref, where such a reference is available. A simple absolute-error comparison is:
error_raw = |y_raw - y_ref|error_mit = |y_mit - y_ref|
The apparent improvement is:
improvement = error_raw - error_mit
For a relative comparison, use (error_raw - error_mit) / error_raw only when the raw error is not close to zero. This calculation is useful for a controlled benchmark, but it is not proof that mitigation will improve an unknown real-world result. If no trusted reference exists, compare against an exact classical calculation for a smaller instance, a noiseless simulator, a known limiting case, a conservation law, or a second hardware configuration.
Estimate execution cost separately from result quality. If a circuit requires S shots and ZNE uses K noise-scaling factors, a first-order shot budget is approximately K × S, before accounting for calibration circuits, repeats, queue constraints or failed jobs. Readout correction adds calibration circuits, often proportional to the number of qubits and the chosen calibration model. PEC may require substantially more samples than the original circuit because the estimator’s variance can grow with the strength and depth of the noise model.
For each method, record at least four values:
- Bias change: whether the estimate moved closer to a trusted reference or satisfied a known constraint.
- Variance change: whether repeated executions became less or more spread out.
- Execution multiplier: total circuit executions divided by the unmitigated baseline.
- Assumption risk: how dependent the result is on calibration stability, noise scaling, a fitted model or post-selection.
Do not report only a single mitigated number. Report the raw estimate, the mitigated estimate, the number of shots, the method settings and an uncertainty interval or repeated-run spread. For measurement uncertainty, the workflow in Quantum Measurement and Shot Allocation provides useful context on allocating shots and interpreting expectation values.
Inputs and assumptions
A practical mitigation experiment starts with a short noise characterisation plan. Run the target circuit without mitigation, then collect data that can distinguish the likely dominant error.
- Measure the baseline. Save the circuit depth, two-qubit-gate count, basis rotations, shots, transpilation settings, backend identifier and execution time. These details matter when comparing runs.
- Check readout behaviour. Prepare known computational-basis states and measure them. If the resulting assignment errors are material, readout correction may be a sensible first intervention.
- Test depth sensitivity. Run shallow and deeper versions of the circuit, or a representative benchmark with similar gate structure. A strong depth-dependent change suggests that gate and decoherence effects may dominate.
- Identify a reference. Use an exact simulator for a small circuit, a high-shot simulation, a classically tractable instance or a known invariant. Avoid calling a simulator with the same assumed noise model an independent validation.
- Choose the least demanding method that addresses the error. If readout dominates, begin with readout correction. If a known symmetry exists, test symmetry verification. Use ZNE when controlled noise scaling is available. Reserve PEC for experiments where its model and sampling requirements can be justified.
In Qiskit, the exact mitigation interface depends on the installed IBM Quantum and Qiskit packages, so check the documentation for the versions used by the project rather than copying an old import statement. The same applies to PennyLane transforms and device plugins. A version-safe implementation should record package versions, backend configuration, transpiler or compilation options, observable definitions, calibration data and random seeds where supported.
Keep the circuit preparation and observable definition identical across raw and mitigated runs. Changing the transpilation strategy, qubit mapping or measurement grouping at the same time as mitigation makes attribution difficult. For a broader SDK comparison, see the Quantum SDK Compatibility Matrix.
Worked examples
Example 1: correcting final measurement errors
Suppose a four-qubit circuit produces a distribution over bitstrings, and calibration circuits show that some prepared states are frequently assigned to neighbouring states. Run the same target circuit with the calibration data collected as close as practical to the experiment. Apply the correction using the SDK’s supported measurement-mitigation workflow, then compare the corrected and uncorrected distributions.
Check whether correction improves a known distribution or a small exact reference. Also inspect whether any probabilities become unstable or unusually sensitive to the calibration data. A correction that changes the answer substantially but has a wide uncertainty interval should not be presented as a definitive improvement.
Example 2: using ZNE for an expectation value
Assume the target is an expectation value of a Pauli observable from a variational circuit. First run the original circuit at a fixed shot count. Then create two or more noise-scaled versions, using a supported folding or scaling procedure, and measure the same observable for each. Fit a deliberately simple extrapolation model to the estimates and evaluate it at the nominal zero-noise point.
For illustration, if the raw estimate is 0.62 and the extrapolated estimate is 0.71, that movement alone does not establish success. Compare both values with a trusted small-instance reference, repeat the experiment, and calculate uncertainty. If the extrapolation is strongly affected by adding or removing one scaling point, report that sensitivity rather than selecting the most favourable fit.
Example 3: symmetry verification in a VQE-style experiment
Suppose a Hamiltonian problem has a known parity or particle-number sector. Measure the information needed to identify whether each sample belongs to the intended sector, then retain or reweight valid samples according to the chosen method. Compare the energy estimate, valid-sample fraction and uncertainty with the unverified result.
Post-selection may reduce bias while increasing variance because some data is discarded. The result should therefore include the acceptance rate and effective shot count. For background on validating variational chemistry experiments, see Quantum Chemistry With VQE.
Across all three examples, use a control circuit or a classically solvable instance. Run the experiment more than once when the decision matters, preferably with separately collected calibration data. A method is useful when its improvement is repeatable and its additional cost is understood—not merely when one mitigated estimate looks closer to expectation.
When to recalculate
Revisit the mitigation choice whenever the inputs that support it change. At minimum, recalculate after a backend change, qubit remapping, major calibration change, substantial circuit-depth increase, SDK or plugin migration, altered transpilation settings, or a new observable. Readout calibration should not be assumed to remain valid indefinitely, and a noise model fitted on one device configuration may not describe another.
For an ongoing programme, schedule a review at least every six months and after major framework releases. Re-run the baseline and validation circuit before trusting historical mitigation settings. Keep a small results record containing:
- raw and mitigated estimates with uncertainty;
- shot counts, calibration size and total execution count;
- noise-scaling factors, folding settings or symmetry rules;
- backend, qubit mapping, circuit depth and software versions;
- reference result or validation criterion;
- the reason the method was selected and whether the improvement replicated.
The practical decision rule is straightforward: start with the simplest method that targets the observed error, quantify its execution and statistical cost, compare it with an unmitigated control, and stop if the apparent gain is not robust. Treat mitigation as an experimental estimation technique, not error correction. That distinction keeps results comparable as hardware, SDKs and benchmarks change.