Case Study 1: The Floor ZNE Could Not Reach
The disappointment
Zero-noise extrapolation is the most intellectually satisfying technique in this chapter. Amplify the noise by known factors, watch the answer degrade, fit a curve, read off the intercept. It has the shape of a real measurement technique — closer to a Ramsey fringe than to a software patch.
So the first run was a letdown.
Four-qubit GHZ state, $\langle ZZZZ\rangle$, true value exactly $+1$:
scale ecr gates depth <ZZZZ>
1 3 13 +0.91772
3 7 25 +0.89392
5 11 37 +0.87012
7 15 49 +0.84668
The decay is beautiful. Nearly perfectly linear, monotonic, no scatter — textbook input for an extrapolation.
unmitigated (scale 1) +0.91772 error 0.08228
linear extrapolation +0.92950 error 0.07050
quadratic extrapolation +0.92975 error 0.07025
exponential extrapolation +0.93039 error 0.06961
A 15% error reduction, for twelve times the two-qubit gate count. Thirty-six ECR gates executed against three.
That is a bad trade, and the natural first response is that the technique underdelivers.
The clue in the agreement
All three extrapolators landed within 0.0009 of each other: 0.92950, 0.92975, 0.93039.
That is the wrong shape for "extrapolation is unreliable here." When extrapolation is being asked to do too much — too few points, too much curvature, too much noise — the methods diverge, and the spread between them is the standard warning. Here they agree to three decimal places.
The extrapolation is working correctly. It is converging to 0.930. Which means 0.930 is the honest answer to the question being asked, and the question is wrong.
The test
If extrapolating gate noise to zero gives 0.930 rather than 1.000, then something contributing 0.07 of error is not gate noise.
The cleanest possible probe: run a circuit with no gates at all. Four qubits sitting in $|0000\rangle$, where $\langle ZZZZ\rangle$ is exactly $+1$ by inspection — every qubit is $|0\rangle$, every $Z$ returns $+1$, the product is $+1$.
gate_free = QuantumCircuit(4) # no gates whatsoever
<ZZZZ> = +0.96228 error 0.03772
A circuit containing no operations is wrong by 0.038.
That is readout error, and it is close to half the total error budget of 0.082. It has nothing to do with gates, and — here is the point — folding cannot touch it.
Why folding cannot touch it
Global folding replaces $U$ with $U(U^\dagger U)^k$. That triples, quintuples, septuples the gate count. It leaves the number of measurements exactly unchanged: one per qubit, at the end, always.
So as the scale factor $\lambda$ runs 1, 3, 5, 7, the error decomposes as
$$\text{error}(\lambda) \;=\; \underbrace{\lambda \cdot \varepsilon_{\text{gate}}}_{\text{scales}} \;+\; \underbrace{\varepsilon_{\text{readout}}}_{\text{constant}}$$
Extrapolating $\lambda \to 0$ removes the first term and returns the second term untouched. The intercept of the fit is not the noiseless value; it is roughly the readout-error-only value.
Roughly, and the gap is worth naming. The measured intercept is 0.92950; the readout-only value — the same circuit with readout mitigation applied and no folding — is 0.96228. That leaves 0.033 unaccounted for, about 40% of the total error, which the two-term model above simply does not have a slot for. Some of it is that the folded circuits are not only $\lambda$ times noisier (§13.5's measured scale factors are not the ones you asked for), and some is coherent error that does not scale linearly in anything. The model is right about the mechanism and approximate about the magnitude, which is the honest description of every error model in this chapter.
Checking the arithmetic against the measurement:
total error 0.08228
readout floor 0.03772
gate-error part 0.04456
ZNE removed the gate part and left the readout part standing. Given the decomposition, 0.930 is exactly the right answer. The technique performed to specification. The specification was narrower than assumed.
The fix, and the number that justifies the chapter
If readout error is invariant under folding, remove it before folding — with the technique from §13.2 that removes readout error specifically — and hand ZNE a signal that is entirely scalable.
Same circuit, same scale factors, same shots, plus a $16\times16$ assignment matrix (condition number 1.061, 16 calibration circuits):
scale <ZZZZ> raw <ZZZZ> readout-mitigated
1 +0.91772 +0.97046
3 +0.89392 +0.94527
5 +0.87012 +0.92014
7 +0.84668 +0.89533
unmitigated + ZNE (linear)
raw +0.91772 (0.08228) +0.92950 (0.07050) -14.3%
readout-mitigated +0.97046 (0.02954) +0.98291 (0.01709) -42.1%
ZNE improves the raw value by 14% and the readout-mitigated value by 42%.
Nothing about ZNE changed. Same folding, same scale factors, same extrapolator, same shot count. It is three times more effective because it ran second, and it is three times more effective for a reason that was fully predictable from the decomposition above.
Combined: 0.08228 → 0.01709. A 79% error reduction.
What this cost, and what it bought
Cost: one extra run of a circuit with no gates in it.
Bought: the ordering rule for the entire mitigation stack, and an explanation of a result that otherwise reads as "ZNE is not worth it."
The lessons
Each mitigation technique removes one kind of noise, and only that kind. This is the chapter's organizing fact, and it appears three times: readout mitigation made a gate-error-dominated result worse (§13.3), ZNE cannot touch readout error (here), and DD addresses correlated noise that a Markovian simulator does not contain (Case Study 2). Match the technique to the channel, which means diagnosing the channel first — Chapter 11 §11.7, Chapter 12 §12.7.
Remove the noise a technique cannot scale, before applying a technique that works by scaling noise. That is the general form of the ordering rule, and it generalizes past this pair.
Agreement among extrapolators was the diagnostic that redirected the investigation. Had the three methods disagreed, the correct conclusion would have been "extrapolation is unreliable on this data" and the readout floor would never have been found. Tight agreement on a wrong answer means the answer is right for a question you did not mean to ask — and that is a far more useful signal than it first appears.
The gate-free circuit is the most underrated diagnostic in this book. It appeared in Chapter 11 §11.7 to separate depolarizing from readout error, in Chapter 12's error budget, and here to expose a floor that four folded circuits could not see. It costs one run, contains nothing, and isolates exactly one error channel.
And the recurring one: check what your instrument is actually sensitive to. ZNE measures the noise-scaling direction. Anything orthogonal to that direction is invisible to it, no matter how carefully you extrapolate — which is Chapter 11's phase-damping lesson and Chapter 12's averaged- statistic lesson wearing a third disguise.
Reproduce it: code/example-03-zne.py for the floor, code/example-05-ordering.py for the fix.