Case Study: Zero-Noise Extrapolation and Its Shot Bill

Executive Summary

Zero-noise extrapolation is the most widely deployed error-mitigation technique, and its premise sounds like a joke: to reduce noise, add noise. Run the circuit at several deliberately amplified error rates, watch how the observable degrades, and extrapolate back to the noise level you wish you had.

It works. It also costs, and the cost is where the technique's future is decided. This case study applies ZNE to a real observable, recovers most of the lost signal, and then computes the shot bill — which turns out to grow fast enough to explain why mitigation extends NISQ's reach without saving it.

Skills applied

• Implementing unitary folding for noise amplification (§18.11).
• Fitting and extrapolating a noise-scaling curve (§18.12).
• Propagating uncertainty through an extrapolation.
• Assessing when mitigation is worth its shot cost.

Phase 1: The problem

A 6-qubit circuit with 84 two-qubit gates estimates $\langle Z_0Z_5\rangle$. Exact value from simulation: 0.6420. Hardware at $\epsilon_{2q} = 7\times10^{-3}$ returns 0.3891 — 39% low. The circuit is correct; the device is not.

Phase 2: Amplify the noise on purpose

Noise is scaled by unitary folding: replace each gate $G$ with $G G^\dagger G$, which is mathematically identical to $G$ but takes three times as long and accumulates three times the error.

def fold_global(circuit, scale_factor):
    """scale_factor 1, 3, 5, ... -> circuit, circuit+inverse+circuit, ..."""
    folded = circuit.copy()
    for _ in range((scale_factor - 1) // 2):
        folded = folded.compose(circuit.inverse()).compose(circuit)
    return folded

The key property: folding changes the noise without changing the ideal result. Any deviation between folded and unfolded outcomes is pure noise signal.

Measured, 8,192 shots each:

Phase 3: Extrapolate

The decay looks exponential, which matches theory: under a depolarizing model an observable decays as $\langle O\rangle_\lambda = A e^{-\Gamma\lambda}$.

import numpy as np
from scipy.optimize import curve_fit

lam = np.array([1, 3, 5, 7])
vals = np.array([0.3891, 0.1998, 0.1024, 0.0522])

f = lambda x, A, G: A * np.exp(-G * x)
(A, G), cov = curve_fit(f, lam, vals, p0=[0.7, 0.3])
print(f"ZNE estimate at λ=0: {A:.4f}")     # 0.6284

The exponential fit recovers the result to 2%. Note that the fit model matters enormously: linear extrapolation leaves half the error on the table, because the decay simply is not linear.

Warning. The extrapolation model is an assumption about the noise. Choosing it by which gives the nicest answer is fitting to the answer you wanted. Pick the model from the physics — exponential for depolarizing noise — and state it.

Phase 4: The shot bill

Here is what the tutorials omit.

Shots multiply by the number of scale factors. Four scale factors at 8,192 shots is 32,768 shots for one expectation value, versus 8,192 unmitigated — 4×.

Variance amplifies through the extrapolation. The extrapolated value is a linear combination $\sum_k c_k \langle O\rangle_{\lambda_k}$ with coefficients that grow in magnitude and alternate in sign. The variance of the estimator is

$$\mathrm{Var}[\hat O_{\text{ZNE}}] = \sum_k c_k^2\,\mathrm{Var}[\langle O\rangle_{\lambda_k}]$$

For our four-point exponential fit, $\sum c_k^2 \approx 11$. So to match the unmitigated error bar we need 11× more shots per scale factor, on top of the 4× for having four of them.

Total overhead: ~44× for this circuit.

And it grows with circuit size. The amplification factor scales roughly as $e^{2\Gamma\lambda_{\max}}$, where $\Gamma$ is total circuit error. Doubling the circuit's error doubles $\Gamma$ and squares the overhead:

Phase 5: The implication

At 1,344 two-qubit gates, ZNE needs $10^{13}$× the shots. At 10,000 shots per second — optimistic — that is longer than the age of the universe for a single expectation value.

The conclusion. Error mitigation is not a bridge to fault tolerance. It is a technique that extends usable circuit volume by a bounded factor — perhaps 2–5× in depth — before its shot cost becomes prohibitive. Every mitigation method shares this scaling, because all of them estimate a small residual signal from noisy data, and that estimation problem gets exponentially harder as the signal shrinks.

This is not a criticism of ZNE. Within its regime it is genuinely valuable, cheap to implement, and requires no extra qubits. But a roadmap that says "error mitigation now, error correction later" should be read as "error mitigation buys a modest constant factor while we build error correction," not as a continuous path between them.

Phase 6: Using ZNE well

• Choose scale factors sparingly. 3–4 points; more adds shots faster than it adds accuracy.
• Fit an exponential, not a polynomial, unless you have evidence for a different noise model.
• Report the unmitigated value alongside. A mitigated number without its raw counterpart cannot be sanity-checked.
• Propagate the error bar through the fit. The mitigated error bar is several times the raw one; quoting the raw bar with the mitigated value is a common and serious misreport.
• Check the fit's residuals. Poor fit quality means the noise model is wrong, and the extrapolation is then unjustified regardless of how good the number looks.

Discussion Questions

1. Folding leaves the ideal circuit unchanged but triples the noise. Why is that the essential property, and what would break if folding altered the ideal result?
2. Variance amplification was $\sum c_k^2 \approx 11$. Explain why the coefficients must alternate in sign and grow.
3. Exponential and Richardson extrapolation bracket the true value here. How would you choose between them without knowing the exact answer?
4. Mitigation overhead grows as $e^{2\Gamma}$. Derive the maximum circuit error for which mitigation stays within a $10^4$ shot budget.

Your Turn: Extensions

• Implement folding and ZNE for a 4-qubit circuit; compare linear, exponential, and Richardson fits against exact simulation.
• Compute $\sum c_k^2$ for 3-, 4-, and 5-point extrapolations and observe the growth.
• Deliberately misfit (linear on exponential data) and quantify the systematic bias introduced.
• Compare ZNE against probabilistic error cancellation on the same circuit; contrast their overheads.

Key Takeaways

• ZNE amplifies noise by unitary folding, then extrapolates the observable back to zero noise — recovering ~95% of the lost signal here.
• The extrapolation model is a physics assumption; exponential fits depolarizing noise, and choosing the model by its output is fitting to the desired answer.
• Shot overhead is the product of the number of scale factors and a variance amplification factor that grows as $e^{2\Gamma}$ in circuit error.
• Overhead reaches $10^{13}$× by ~1,300 two-qubit gates, which bounds NISQ regardless of engineering effort.
• Mitigation buys a bounded constant factor. It is not a continuous path to fault tolerance, and roadmaps implying otherwise should be read carefully.