Case Study: Reading a Below-Threshold Experiment

Executive Summary

In 2024 Google reported that a distance-5 surface code outperformed a distance-3 one on the Willow processor — the first clear demonstration that increasing code distance actually reduces logical error on real hardware. The result was widely covered, and widely misdescribed as "error-free quantum computing."

This case study reads the result properly: what "below threshold" means precisely, what the reported $\Lambda \approx 2.14$ signifies, what remains between that milestone and a useful fault-tolerant machine, and how to evaluate the next such announcement.

Skills applied

• Interpreting the error-suppression factor $\Lambda$ (§25.9).
• Relating physical error rate, threshold, and distance to logical error.
• Extrapolating from a demonstration to algorithmic requirements.
• Distinguishing a scaling demonstration from a working logical qubit.

Phase 1: What was actually measured

Two surface-code patches on the same processor:

The ratio is the error-suppression factor:

$$\Lambda = \frac{\varepsilon_L(d)}{\varepsilon_L(d+2)} = \frac{3.0\times10^{-3}}{1.4\times10^{-3}} \approx 2.14$$

$\Lambda > 1$ is the entire result. It means adding distance helps — that the code is operating below threshold, where error correction wins rather than adds noise.

This is not obvious and had not previously been demonstrated convincingly. Above threshold, a larger code has more components to fail and performs worse; the crossover is exactly what "threshold" names.

Phase 2: Why $\Lambda = 2.14$ and not larger

Theory says

$$\varepsilon_L \propto \left(\frac{p}{p_{\text{th}}}\right)^{(d+1)/2} \implies \Lambda \approx \frac{p_{\text{th}}}{p}$$

So $\Lambda \approx 2.14$ implies the device operates at roughly half the threshold error rate — genuinely below it, but only just.

For comparison:

$\Lambda$ is the lever that determines everything downstream, because it sets how much distance you need for a target logical error rate:

$$d \approx 2\,\frac{\log(1/\varepsilon_{\text{target}})}{\log\Lambda} - 1$$

Phase 3: Extrapolate to an algorithm

Shor on RSA-2048 needs roughly $3\times10^{9}$ Toffoli gates, so a logical error rate below ~$10^{-10}$ per operation.

At the demonstrated $\Lambda = 2.14$, a logical qubit costs ~7,000 physical qubits, and 6,000 logical qubits for RSA-2048 means ~42 million physical qubits — roughly double the commonly quoted 20 million, which assumes better physical error rates than Willow demonstrated.

The lever worth watching. Going from $\Lambda = 2.14$ to $\Lambda = 10$ — a 5× improvement in physical error rate — cuts qubits per logical by nearly 10×. Physical fidelity remains the highest-leverage parameter, exactly as the Chapter 15 resource analysis concluded.

Phase 4: What the result is not

Not "error-free." Logical error per round is $1.4\times10^{-3}$. A circuit of a thousand logical operations would fail.

Not a usable logical qubit. The experiment demonstrated a logical memory — storing a state and correcting it — not logical gates. Lattice surgery, magic-state injection, and distillation are all further steps, each with their own error budgets.

Not scalable as demonstrated. 49 physical qubits for one distance-5 patch. Willow has 105. A second logical qubit, let alone the thousands an algorithm needs, requires a much larger device with the same error rates — and error rates typically degrade as devices grow.

Not a complete decoder story. The reported result used offline decoding for some analyses. Real-time decoding at scale, keeping pace with microsecond-scale syndrome extraction, is a distinct and unsolved engineering problem.

Phase 5: Evaluating the next announcement

A checklist for the next below-threshold claim:

1. What is $\Lambda$? Anything at or below 1 is not below threshold. Between 1 and 2 is marginal.
2. How many distances were compared? Two points establish a ratio; three or more establish a trend and are far more convincing.
3. Logical memory or logical gates? Memory is easier and came first; logical two-qubit gates between patches are the harder milestone.
4. Was decoding real-time? Offline decoding is a valid physics result and does not demonstrate operational viability.
5. How many logical qubits? One is a physics demonstration; the algorithmic requirement is thousands.
6. What is the logical error rate per gate, not per round? Rounds and gates differ by roughly a factor of $d$.

Phase 6: The honest summary

Google's Willow result is a genuine milestone: it showed that the surface code's exponential suppression works on real hardware, which was previously theory supported only by simulation. That deserves the attention it received.

It also showed the device sits at roughly half the threshold — the beginning of the usable regime, not the middle of it. The remaining path is: raise $\Lambda$ substantially, demonstrate logical two-qubit gates, demonstrate real-time decoding at scale, add magic-state distillation, and multiply the whole thing by thousands of logical qubits.

Each step is a research program. Collectively they are why credible timelines for cryptographically relevant machines remain measured in decades rather than years.

Discussion Questions

1. $\Lambda \approx p_{th}/p$. Derive this from the logical error scaling and explain why $\Lambda$ is a more useful figure than logical error rate alone.
2. Two distance points establish a ratio. Why is a third point disproportionately more convincing?
3. Logical memory was demonstrated, not logical gates. Why are gates substantially harder?
4. Real-time decoding is unsolved at scale. What happens if the decoder falls behind syndrome extraction?

Your Turn: Extensions

• Compute the required distance for logical error $10^{-12}$ at $\Lambda = 2.14, 5, 10$.
• Plot physical qubits per logical against $\Lambda$ and identify the region of steepest return.
• Read the Willow paper and locate its statements about decoder latency.
• Estimate the total physical qubits for 1,000 logical qubits at the demonstrated $\Lambda$.

Key Takeaways

• "Below threshold" means $\Lambda > 1$: increasing code distance reduces logical error rather than increasing it.
• The demonstrated $\Lambda \approx 2.14$ implies operation at about half the threshold — inside the usable regime, but barely.
• $\Lambda$ sets the required code distance and therefore the entire qubit overhead; raising it is the highest-leverage improvement available.
• The result demonstrated logical memory, not logical gates, real-time decoding, or multiple logical qubits.
• Evaluate such claims on $\Lambda$, number of distance points, memory versus gates, decoder latency, and logical qubit count.