Below Threshold: The Theorem That Makes Quantum Computers Possible

Add more qubits and you add more errors. That’s the basic physics of quantum hardware. Every gate you run on a quantum processor has a small probability of introducing a mistake. Chain a thousand gates together and the mistakes accumulate. Scale to millions of gates — the depth a useful algorithm requires — and the qubit’s state has long since dissolved into noise before the computation finishes.

This is the central problem of quantum computing. And for three decades after Feynman first imagined a quantum machine, the problem seemed insurmountable. Noise accumulates. Qubits decohere. The longer you compute, the worse it gets.

Then Peter Shor, in 1995, proved something that shouldn’t have been possible: quantum information can be protected against noise using other qubits — in much the same way classical bits can be protected by redundancy. And within three years, a theorem emerged that is the real foundation of everything that follows. It says: if the physical error rate stays below a critical threshold, then adding more qubits to a carefully designed error-correcting code drives the logical error rate down exponentially. The relationship flips. More hardware — all other things equal — makes the system more reliable, not less.

In December 2024, Google’s Willow processor became the first quantum chip to demonstrate this behavior convincingly, at scale, with a real-time decoder operating within the 1.1-microsecond cycle time of the hardware. The paper, published in Nature in February 2025, measured an error suppression factor ofΛ = 2.14 ± 0.02Lambda (Λ) is the factor by which the logical error rate falls each time code distance increases by 2. Λ > 1 is the mathematical signature of below-threshold operation. Source: Google Quantum AI (2025), arXiv:2408.13687, Nature 638, 920–926. — each step up in code size cuts the logical error rate in half. A 101-qubit distance-7 code achieved a logical error rate of 0.143% per cycle, and the logical qubit outlived its best physical constituent by a factor of 2.4.

This piece explains what the threshold theorem actually says, how surface codes enforce it stabilizer by stabilizer, why below-threshold operation is a phase transition rather than an incremental improvement, and what is honestly still needed before a logical qubit can run a useful computation.

1%1%1%SURFACE CODE THRESHOLDphysical error rate the code tolerates (~1%, circuit-level noise)

2.14×2.14×2.14×LAMBDA (Willow d=5→7)logical error suppression factor per code-distance step

101 qubits101 qubits101 qubitsPHYSICAL QUBITSin the distance-7 surface code (49 data + 48 measure + 4 leakage)

0.143%/cycle0.143%/cycle0.143%/cycleLOGICAL ERROR RATEdistance-7 Willow result, at 1.1 µs per error-correction cycle

---

The noise problem: why quantum errors are uniquely hard

Classical error correction is straightforward. If you want a bit to survive a noisy channel, copy it three times: 000 encodes a logical 0, 111 encodes a logical 1. If noise flips one bit and you receive 010, majority vote corrects it back to 000. You read the bits, check them, fix them.

Three properties of quantum mechanics break every part of this approach.

No-cloning. Theno-cloning theoremA fundamental theorem in quantum mechanics proved independently by W.K. Wootters and W.H. Zurek (Nature 299, 802, 1982) and by D. Dieks (Physics Letters A 92, 271, 1982): it is impossible to create a perfect copy of an arbitrary unknown quantum state. Unlike a classical bit, a qubit in superposition cannot be duplicated without destroying the original. Source: en.wikipedia.org/wiki/No-cloning_theorem. states that you cannot copy an unknown quantum state. The classical trick of storing three copies is literally forbidden by physics.

Measurement collapses the state. To check whether a classical bit has flipped, you read it. In quantum mechanics, measuring a qubit destroys its superposition. You cannot check “is this qubit still in the right state?” without forcing it to commit to a definite answer — which erases the quantum information you were trying to protect.

Continuous errors. Classical bits are discrete: a bit is either 0 or 1. A qubit can suffer from a continuum of errors: a tiny rotation away from the correct state, a partial phase shift, a combination of both. Correcting a continuous space of possible errors seems to require an infinite family of correction procedures.

Shor’s 1995 breakthrough — hisnine-qubit codeShor's [[9,1,3]] code encodes 1 logical qubit in 9 physical qubits. It is the first quantum error-correcting code, combining a 3-qubit phase-flip repetition code with a 3-qubit bit-flip repetition code. Source: Shor (1995), Physical Review A 52, R2493. — resolved all three problems simultaneously. The trick is indirect measurement. Instead of measuring the qubits themselves, you measure relationships between them — parity checks that reveal whether an error occurred without revealing the encoded information. The no-cloning theorem is circumvented by entangling the logical state across many qubits rather than copying it. And the continuous-error problem is sidestepped by the stabilizer formalism: any single-qubit error necessarily has some component along the X or Z axis, and measuring those components projects the continuous error onto a discrete set of correctable cases.

The principle works. What it doesn’t immediately provide is a path to scaling: how do you make a quantum computer that runs circuits deep enough to be useful, when every physical gate adds errors faster than you can correct them?

---

The threshold theorem: what it actually says

Here is the key insight, stated precisely. If the physical error rate per gate is p, and the surface code’s threshold is p_th, then the logical error rate for a distance-d code is approximately:

$$\varepsilon_L(d) \approx \frac{C}{\Lambda^{(d+1)/2}}$$

$$\Lambda \approx \frac{p_{th}}{p}$$whysuppression factor: ratio of threshold to physical error rate

$$\varepsilon_L(d+2) = \frac{\varepsilon_L(d)}{\Lambda}$$whyeach increase in d by 2 divides the logical error rate by Λ

$$\Lambda > 1 \iff p < p_{th}$$whythe condition for below-threshold operation: the exponential drives toward zero

The exponent is (d+1)/2. For d=3, that’s 2. For d=7, it’s 4. For d=25, it’s 13. Every two units of code distance add one more power of suppression. If Λ = 2, the logical error rate halves each step. If Λ = 10, it drops tenfold. If Λ = 2.14 — the Willow result — it falls by a factor of 2.14 per distance step.

This only works when p < p_th. If the physical error rate exceeds the threshold, Λ < 1, the exponent drives the logical error rate toward infinity instead of zero — and adding more qubits makes the computation less reliable, not more.

The threshold theorem — proved rigorously by Aharonov & Ben-Or, byKnill, Laflamme & Zurek in 1998Knill, Laflamme & Zurek proved that arbitrarily accurate quantum computation is possible provided that the error per operation is below a threshold value. Their 1998 Science paper established this as a formal theorem. Source: Science 279, 342–345 (1998)., and by Kitaev — says that if p < p_th, then arbitrarily long quantum computations are possible with only polynomial overhead. You can make the logical error rate as small as you like by increasing d, and the number of physical qubits required grows only as d².

The surface code’s threshold under realistic circuit-level noise isapproximately 1%Fowler et al. (2012) give a threshold of ~0.57% under circuit-level noise with minimum-weight perfect matching (MWPM) decoding, and ~0.9% under symmetric depolarizing noise. QuantumZeitgeist and other references cite the threshold as 'in the neighbourhood of one percent.' Source: Fowler et al. Physical Review A 86, 032324 (2012); quantumzeitgeist.com. — roughly ten times higher than any practical code had achieved before the surface code was invented. That relative generosity is why the surface code became the leading candidate for fault-tolerant quantum computing.

---

The surface code: a grid of interlocking parity checks

The surface code is a two-dimensional square lattice of qubits. In itsrotated surface codeThe rotated surface code (as used by Fowler et al. 2012 and by Google's Willow experiments) encodes 1 logical qubit using d² data qubits and d²−1 measure (ancilla) qubits, for a total of 2d²−1 physical qubits at code distance d. Source: Fowler et al. PRA 86 (2012); QuantumZeitgeist surface code explainer. variant, a distance-d code uses:

• d² data qubits — these hold the quantum information
• d² − 1 measure (ancilla) qubits — these perform the parity checks
• Total: 2d² − 1 physical qubits per encoded logical qubit

At distance 7 — what the Willow experiment demonstrated — that’s 49 data qubits, 48 measure qubits, plus 4 extra leakage-removal qubits, for 101 physical qubits encoding one logical qubit.

The data and measure qubits are interlaced in a checkerboard pattern. Each measure qubit sits in the center of a group of four data qubits and performs one of two kinds of parity check:

• Z-type stabilizers (on face/plaquette centers): measure the product of the Z operator on four neighboring data qubits. A value of −1 signals that an X error (bit flip) has occurred on an odd number of those qubits.
• X-type stabilizers (on vertex centers): measure the product of the X operator on four neighboring data qubits. A value of −1 signals that a Z error (phase flip) has occurred on an odd number of those qubits.

Crucially, the data qubits are never measured directly. Only the ancilla qubits are measured, and their outcome tells you that an error occurred and approximately where — without revealing or disturbing the encoded logical state.

Nodes

• Data qubits (49 in d=7 code)
• Physical error occurs (X or Z)
• Ancilla qubits (48 in d=7 code)
• CNOT gates entangle data with ancillas
• Measure ancillas → syndrome bits (never data!)
• Classical decoder (min-weight matching) maps syndrome→error
• Apply correction (or track in software) logical state intact

Connections

• Physical error occurs (X or Z) → Data qubits (49 in d=7 code) (corrupts)
• Data qubits (49 in d=7 code) → CNOT gates entangle data with ancillas (entangled with)
• Ancilla qubits (48 in d=7 code) → CNOT gates entangle data with ancillas (into)
• CNOT gates entangle data with ancillas → Measure ancillas → syndrome bits (never data!) (syndrome extraction)
• Measure ancillas → syndrome bits (never data!) → Classical decoder (min-weight matching) maps syndrome→error (syndrome bits)
• Classical decoder (min-weight matching) maps syndrome→error → Apply correction (or track in software) logical state intact (Pauli frame update)

The outcome of each ancilla measurement is a single bit: +1 (no error detected in that check) or −1 (error detected). Taken together across all ancilla qubits in one cycle, these bits form thesyndromeThe pattern of −1 outcomes across all stabilizer measurements in one error-correction cycle. The syndrome does not identify the encoded state — it only identifies where errors occurred. A decoder maps syndrome patterns to the most likely error and proposes a correction.. A syndrome of all-+1 means either no errors occurred, or errors occurred that exactly cancel out — which is very unlikely with real noise. A syndrome with some −1 values points to one or more error locations.

Thecode distanceThe minimum number of physical qubit errors required to produce an undetected logical error — that is, a chain of errors that spans the lattice from one boundary to the opposite boundary without triggering any stabilizer. A distance-d code can correct up to ⌊(d−1)/2⌋ simultaneous errors. is what gives the surface code its power. A distance-7 code can correct any combination of up to 3 simultaneous single-qubit errors. A distance-11 code can correct up to 5. At some code distance, the probability of getting enough simultaneous errors to overwhelm the code becomes negligible.

Here is the full syndrome extraction cycle, step by step:

1. 01

   1. Run the quantum gate (and get an error)

   The processor executes one layer of quantum gates on the data qubits. With probability p per gate, a Pauli error (X, Y, or Z) is introduced — a single-qubit rotation the processor didn't intend. No alarm sounds; nothing special happens. The data qubits continue in their corrupted state.

2. 02

   2. Entangle data qubits with ancilla qubits

   Each ancilla qubit is coupled to its four neighboring data qubits through a sequence of controlled-NOT (CNOT) gates. For a Z-type stabilizer: the ancilla accumulates the parity of the X errors on its four neighbors. For an X-type stabilizer: the ancilla accumulates the parity of the Z errors. These entangling operations take place over the 1.1-microsecond error-correction cycle time of the Willow hardware.

3. 03

   3. Measure the ancilla qubits

   Each ancilla qubit is measured in the computational basis, yielding +1 or −1. This destroys the ancilla's entanglement but leaves the data qubits completely undisturbed. The data qubits are never measured — their quantum state survives intact. The measurement results form the syndrome: a binary pattern of 0s (for +1 outcomes) and 1s (for −1 outcomes) across all d²−1 ancilla positions.

4. 04

   4. Run the classical decoder

   The syndrome is passed to a classical decoder — a software algorithm running on conventional hardware. The standard choice is minimum-weight perfect matching (MWPM): it finds the smallest set of errors consistent with the observed syndrome pattern. Google's Willow experiment used both a neural-network decoder (achieving Λ = 2.14 ± 0.02) and a real-time MWPM-based decoder that operates within the 1.1 µs cycle time constraint. The decoder produces a Pauli correction operator.

5. 05

   5. Apply the correction (or track it)

   The correction is either physically applied (X and Z gates on specific data qubits) or tracked in software as a 'Pauli frame' — a running record of all corrections so far. Physical application and software tracking are equivalent, but the latter is more efficient because classical bit strings can be XORed. The logical qubit continues in its corrected state, ready for the next round.

6. 06

   6. Repeat — 900,000 times per second

   The entire cycle takes 1.1 microseconds on Willow. That means roughly 900,000 error-correction cycles per second — each one detecting and correcting whatever errors accumulated during the previous gate layer. At a logical error rate of 0.143% per cycle, the distance-7 logical qubit remains valid for approximately 700 cycles on average before an uncorrected error chain reaches the opposite boundary. That's still not enough for useful computation — but it's the first demonstration that more qubits always helps.

The repetition of syndrome extraction is what buys reliability. A single error in isolation is caught on the cycle when it occurs. Errors that span multiple cycles — a qubit that stays wrong for several rounds — leave a temporal trail of syndrome changes that the decoder can follow and correct. This is why the decoder is fundamentally a problem about spacetime, not just space: error chains extend in both spatial dimensions (across the lattice) and in time (across multiple cycles).

---

Below threshold as a phase transition

Here is the deepest result in the theory. In 2002, Dennis, Kitaev, Landahl, and Preskill published “Topological quantum memory,” which proved that the error correction threshold is not merely a practical boundary — it is an order-disorderphase transitionDennis, Kitaev, Landahl & Preskill (2002) showed that the threshold of the toric code maps exactly onto an order-disorder phase transition in a 3D Z₂ lattice gauge theory with quenched disorder. Below threshold = ordered phase (information protected). Above threshold = disordered phase (error chains percolate, information lost). Source: Journal of Mathematical Physics 43, 4452 (2002), arXiv:quant-ph/0110143. in the mathematical sense of statistical mechanics. The surface code’s threshold maps exactly onto the critical point of a 3D Z₂ lattice gauge theory with quenched disorder.

What this means physically: in the ordered phase (below threshold), error chains are short and isolated. A random error here or there creates a small syndrome patch; the decoder corrects it; the code survives. In the disordered phase (above threshold), error chains percolate across the lattice — they grow, connect, and eventually span the code from one boundary to the other, creating an undetectable logical error. The transition between these regimes is not continuous: below threshold, the logical information is thermodynamically stable; above threshold, it is thermodynamically unstable.

This is not an analogy. The mathematics is exact. The threshold of the toric code under independent depolarizing errors equals the critical temperature of a specific random-bond Ising model. Crossing the threshold is the same mathematical event as a ferromagnet melting into a paramagnet.

An order-disorder phase transition occurs in this system at a nonzero critical value of the error rate; if the error rate is below the critical value (the accuracy threshold), encoded information can be protected arbitrarily well in the limit of a large code block.

This framing changes how you think about the engineering challenge. Building a fault-tolerant quantum computer is not about reducing the error rate to zero — an impossible ask. It is about reducing it below a critical value and then staying there while you scale. Once you are in the ordered phase, adding more hardware is thermodynamically favorable. The code is in a different regime. The question is no longer “can we make errors small enough?” but “can we manufacture enough below-threshold qubits?”

The practical threshold under realistic circuit-level noise — where every gate, preparation, and measurement is itself noisy — lies somewhere between 0.57% (with MWPM decoding) and roughly 1% (with optimal decoding and symmetric error models). Willow’s physical two-qubit gate error rate of approximately0.12% (two-qubit gate fidelity 99.88%)Google's hardware blog reports 99.97% for single-qubit gates and 99.88% for entangling (two-qubit) gates across Willow's full 105-qubit array. Source: blog.google/technology/research/quantum-hardware-verifiable-advantage/. Note: Aaronson (2024) separately reports 99.7% for CZ gates and 99.85% for iSWAP gates, which are distinct gate types with different native fidelity; the 99.88% figure refers to the iSWAP-like entangling gate. is well below the 0.57% circuit-level threshold — which is precisely why Willow can operate below threshold at all.

---

The Lambda suppression factor: running the numbers yourself

The exponential suppression formula can be explored directly. Below, each step up in code distance divides the logical error rate by Lambda. Slide into the above-threshold regime (Lambda < 1) and watch the errors grow instead of shrink:

runnable · js▸ run

output

Run the code to see its output here.

The d=7 row in the below-threshold calculation lands on exactly 0.143% — the Willow measurement from the Nature paper. Below threshold, each two-step increase in code distance divides the logical error rate by another factor of 2.14. Above threshold, the same steps multiply it.

Now adjust Lambda continuously. When Lambda crosses 1 from above, you cross the threshold — and the entire qualitative behavior of the system switches:

error at d=7 (%)0.143error at d=11 (%)0.031error at d=19 (%)0.001

error at d=7 (%): 0.143, error at d=11 (%): 0.031, error at d=19 (%): 0.001.

Suppression factor Λ2.14

Baseline error at d=3 (%)0.66

The inflection point at Lambda = 1 is the threshold. Below it, the curve falls. Above it, it rises. There is no smooth interpolation between the two regimes — the mathematics of the ordered and disordered phases differs by the sign of the exponent.

Go deeper: why Λ = 2.14 is lower than the theoretical p_th/p maximum

The formula Λ ≈ p_th/p is a leading-order approximation. With Willow’s two-qubit gate error rate of ~0.12% and a surface-code circuit-level threshold of ~0.57%, the naive theoretical maximum is Λ_max ≈ 0.57/0.12 ≈ 4.75. The measured Λ = 2.14 is considerably lower — and that gap is honest physics. Real processors have correlated errors (crosstalk between neighboring qubits), leakage (population into non-computational states), time-correlated noise (low-frequency drift), and coherent errors that the simple depolarizing model misses. Each of these degrades Λ below the theoretical limit. A Λ of 2.14 is enough to demonstrate below-threshold operation — the logical error rate unambiguously falls with distance — but higher Λ will be needed to reach the code distances required for practical algorithms. The path to larger Λ runs through better physical qubits (lower and less correlated error rates) and more sophisticated decoders that handle realistic noise models.

---

The Willow result: what was actually measured

Google’s Willow chip is a105-qubit superconducting transmon processorWillow consists of 105 superconducting transmon qubits arranged in a 2D square grid, with average connectivity of ~3.47. Single-qubit gate fidelity 99.97%; two-qubit gate fidelity ~99.88%. T1 coherence time: mean 68 µs, approaching 100 µs; T2,CPMG = 89 µs — a ~5× improvement over the previous Sycamore generation (~20 µs T1). Source: Wikipedia/Willow_processor; PMC/11864966 (direct from Nature paper). operating at near absolute zero in a dilution refrigerator. The relevant physical parameters for the threshold calculation are:

• Single-qubit gate error: 0.03% (fidelity 99.97%)
• Two-qubit gate error: ~0.12% (fidelity 99.88%)
• Mean qubit T₁: 68 µs (time until qubit spontaneously decays)
• Mean qubit T₂,CPMG: 89 µs (phase coherence time)
• Error correction cycle time: 1.1 µs

The ratio of T₁ to cycle time — 68 µs / 1.1 µs ≈ 62 — sets an upper bound on how many correction cycles the qubit can run before decoherence dominates. The distance-7 code extends this to approximately 700 cycles before a logical error occurs (derived from the 0.143%/cycle logical error rate).

The experiment ran surface code memories at distance-3, distance-5, and distance-7, using subgrids of two Willow processors (a 105-qubit chip for the distance-7 result; a 72-qubit chip for the real-time distance-5 demonstration). For each pair of adjacent code distances, the team measured Lambda — the ratio of logical error rates — using both a neural-network decoder and a real-time minimum-weight matching decoder. The results:

chart: bar of Lambda by configuration — 4 points

Every measurement exceeds 1 — and not by a whisker. The minimum measured value is 2.0, achieved by the real-time decoder operating under the strict 1.1-µs cycle constraint. The neural-network decoder, which has more compute budget, reaches 2.14 for the largest code. The consistency across decoder types and code distances confirms this is a genuine physical effect, not an artifact of a particular decoding strategy.

I think it’s amazing. I didn’t actually expect that they would fly through the threshold like this.

The other key result: the distance-7 logical qubit outlives its best physical constituent qubit by a factor of 2.4 ± 0.3. This is the “break-even” milestone inverted — the logical qubit is not just as good as the physical qubit, it is better. Error correction is providing net benefit for the first time in a surface code memory at this scale.

Go deeper: the 2022 precursor and why Willow is different

Google’s 2023 Nature paper (“Suppressing quantum errors by scaling a surface code logical qubit,” arXiv:2207.06431) was a milestone on the way to Willow. It demonstrated that a distance-5 logical qubit slightly outperformed an ensemble of distance-3 logical qubits: logical error rates of 2.914% ± 0.016% vs. 3.028% ± 0.023%. The improvement was tiny — less than 4% — and the system was operating very close to or at the threshold, not clearly below it. The key difference in the 2024 Willow result is threefold: (1) Willow’s T₁ coherence time improved roughly 5× over the Sycamore-generation hardware used in 2022, (2) the full distance-7 code is run (not just d=3 vs. d=5), and (3) a real-time classical decoder is integrated within the 1.1-µs cycle time. The combination of better hardware and a working decoder is what put Willow unambiguously below threshold with Λ = 2.14 rather than marginally above or at it.

---

The honest gap: d=7 to fault-tolerant computation

Demonstrating Λ = 2.14 in a surface code memory is a genuine physical milestone. It is not a fault-tolerant quantum computer.

Here is the distance:

filter6 rows

The gap between the Willow demonstration and what fault-tolerant computation requires. Code distance target computed from Willow's measured Λ = 2.14 and the 10⁻¹⁰%/cycle error rate needed for an algorithm running 10⁷ cycles on 10³ logical qubits (see arithmetic below). Sources: arXiv:2408.13687; Fowler et al. (2012) arXiv:1208.0928.

Metric↕	Willow 2024↕	Fault-Tolerant Target↕
Code distance	d = 7	d ≈ 63 (at Λ = 2.14) †
Physical qubits per logical qubit	101	~7,900
Logical qubits demonstrated	1 (memory only)	~1,000–4,000
Logical error rate / cycle	0.143%	< 10⁻¹⁰%
Logical gate fidelity	not demonstrated	< 10⁻⁶ per gate
Total physical qubits (RSA-2048)	105	~tens of millions

Three specific capabilities are missing entirely from the Willow result:

Logical gates. The Willow experiment demonstrates a memory — a logical qubit that sits still and survives error correction for hundreds of cycles. Running a computation requires logical gates — operations on the encoded state that are themselves fault-tolerant. The dominant approach for the surface code is magic state distillation: a noisy ancilla state is purified through a distillation circuit until it reaches the precision needed to implement a non-Clifford gate (the T gate, specifically). This requires additional physical qubits — a significant overhead on top of the code distance overhead. The path from Λ = 2.14 to running a logical T gate is not trivial.

Multiple logical qubits with entanglement. Algorithms require interaction between logical qubits. Entangling two distant logical qubits in a surface code requires a special operation (lattice surgery) that effectively creates and destroys boundaries between patches — demanding careful spatial planning and additional ancilla resources.

Code distance d ≈ 63 (at current Λ = 2.14). At d = 7 and Λ = 2.14, the logical error rate is 0.143% per cycle. An algorithm running 10 million cycles on 1,000 logical qubits accumulates 10¹⁰ total qubit-cycle operations; to keep the total failure probability below ~1%, each qubit-cycle needs an error rate below roughly 10⁻¹⁰%. That is a factor of 1.43 × 10⁹ below today’s 0.143%. Each two-unit step up in code distance multiplies the suppression by Λ = 2.14, so the number of steps required is n = ln(1.43 × 10⁹) / ln(2.14) ≈ 27.7, which rounds up to 28 steps. The arithmetic:

$$n = \frac{\ln(0.143\% \,/\, 10^{-10}\%)}{\ln \Lambda} = \frac{\ln(1.43 \times 10^{9})}{\ln 2.14} \approx \frac{21.08}{0.761} \approx 27.7 \to 28 \text{ steps}$$

$$d_{\text{target}} = 7 + 2 \times 28 = 63$$why28 two-unit distance steps from d = 7

$$2(63)^2 - 1 = 7{,}937 \approx 7{,}900 \text{ physical qubits per logical qubit}$$whyrotated surface code qubit count formula (Fowler et al. 2012)

$$\varepsilon_L(d=63) = 0.143\% \,/\, 2.14^{28} \approx 8 \times 10^{-11}\% \approx 10^{-10}\%$$whyconfirmed: 28 suppression steps reaches the target

At d = 63, each logical qubit requires approximately 7,900 physical qubits — roughly 78× more than the 101 qubits in Willow’s d = 7 demonstration. For 1,000 logical qubits, that is approximately 8 million physical qubits; for the 4,000 logical qubits Shor’s algorithm requires for RSA-2048, tens of millions.

The physical qubit count needed for RSA-breaking is therefore at minimum in the tens of millions — and that estimate assumes Λ remains near 2 at larger code distances, which is not guaranteed as the system scales and new correlated noise sources emerge.

Go deeper: quantum LDPC codes and why they might help

Surface codes are not the only path to fault tolerance. Quantum low-density parity-check (qLDPC) codes can encode multiple logical qubits per physical qubit and achieve lower overhead than surface codes — potentially reducing the physical qubit requirement by an order of magnitude. Bravyi et al. demonstrated bivariate bicycle codes (IBM, Nature 627, 778–782, 2024; arXiv:2308.07915) that store 12 logical qubits in 288 physical qubits with a threshold of ~0.8%, matching the surface code threshold — versus ~3,000 physical qubits needed with surface codes for equivalent error suppression. The catch is connectivity: qLDPC codes require interactions between distant qubits that are difficult to implement in a planar superconducting layout. Microsoft has taken a different approach entirely — topological qubits based on Majorana zero modes, which aim to have intrinsically lower physical error rates so the code distance requirement is smaller. Microsoft’s Majorana 1 chip (Nature 638, 651–655, February 2025; en.wikipedia.org/wiki/Majorana_1) demonstrated relevant hardware milestones, though the paper itself notes the measurements “do not, by themselves, determine whether the low-energy states detected are topological” — the approach remains under active investigation. None of these alternatives is close to displacing surface codes for near-term experiments, but they may alter the architecture as systems scale.

The gap is large. The physics works. Whether the engineering will close the gap in five years or twenty-five is an open question — and anyone who tells you a precise timeline is confusing a roadmap with a guarantee.

---

Check your understanding

1. Q1If a surface code's Lambda (Λ) is measured to be 0.7, what does that tell you about the system's operating regime?

   • The system is below the error threshold — Λ < 1 means very aggressive error suppression.
   • The system is above the error threshold — Λ < 1 means errors grow exponentially with code distance.
   • The system is exactly at the threshold — Λ values near 1 are the target.
   • The system has not yet been calibrated — Λ < 1 is a sign of a faulty decoder.

2. Q2Why can't quantum error correction work by simply copying the qubit three times and taking a majority vote — the classical repetition strategy?

   • Three qubits aren't enough; quantum errors require at least nine copies.
   • The no-cloning theorem forbids copying an unknown quantum state; and measuring the copies to check them would collapse the superposition.
   • Majority vote doesn't work for quantum systems because quantum errors are continuous, not discrete.
   • Copying is allowed, but majority vote fails because quantum states interfere with each other during measurement.

3. Q3The Willow distance-7 logical qubit achieved 0.143% logical error per cycle and outlived its best physical qubit by 2.4×. What is still missing before this can run a useful algorithm?

   • Nothing — the distance-7 result is sufficient for fault-tolerant quantum computation.
   • A larger qubit count; the 105-qubit Willow chip needs to scale to ~500 qubits for useful computation.
   • Fault-tolerant logical gates (especially the T gate), multiple interacting logical qubits, and code distances of d≈63 (at current Λ=2.14) to achieve per-cycle error rates below ~10⁻¹⁰%.
   • A better decoder; the minimum-weight matching decoder used in Willow is too slow for real algorithms.

---

Thirty years from theorem to hardware

Event 1 of 7: 1 Jan 1994, Shor's factoring algorithm

011994opening

1 Jan 1994

Shor's factoring algorithm

Peter Shor proves that a quantum computer can factor large integers in polynomial time — exposing the existential need for fault tolerance. Without it, the algorithm cannot run on any real hardware.

021995+12 mo

1 Jan 1995

Shor's nine-qubit code

Shor publishes the first quantum error-correcting code: a [[9,1,3]] code that encodes one logical qubit in nine physical qubits and corrects any single-qubit error. Physical Review A 52, R2493. The no-cloning theorem is bypassed by encoding rather than copying.

031998+3 yr

16 Jan 1998

Threshold theorem (KLZ)

Knill, Laflamme & Zurek prove in Science 279, 342 that if the error per operation is below a threshold value, then arbitrarily accurate quantum computation is possible with only polynomial overhead. The threshold exists; the question is how high it is.

042002+4 yr

1 Jan 2002

Topological quantum memory

Dennis, Kitaev, Landahl & Preskill prove that the error correction threshold is an order-disorder phase transition in a 3D Z₂ gauge theory with quenched disorder. The surface code's threshold is not an engineering parameter — it is a thermodynamic phase boundary. Journal of Mathematical Physics 43, 4452.

052012+11 yr

26 Sep 2012

Fowler et al. surface code review

The comprehensive analysis of surface codes by Fowler, Mariantoni, Martinis & Cleland (Physical Review A 86, 032324) establishes the surface code as the leading practical candidate: threshold ~0.57–1% under circuit-level noise, planar nearest-neighbor architecture, single logical qubit from 2d²−1 physical qubits.

062023+10 yr

1 Feb 2023

Google: d=5 outperforms d=3 (barely)

Nature 614, 676–681. Google's first surface code scaling milestone: the distance-5 logical qubit marginally outperforms the distance-3 logical qubit (2.914% vs. 3.028% error per cycle). The system is near but not clearly below threshold. The result proves scaling is possible; it does not demonstrate it unambiguously.

072025+2 yr

27 Feb 2025

Willow: first below-threshold surface code

Nature 638, 920–926. Google's Willow chip (105 superconducting transmon qubits) demonstrates Λ = 2.14 ± 0.02 across three code distances. The distance-7 logical qubit reaches 0.143% error per cycle and outlives its best physical qubit by 2.4×. Barbara Terhal: 'I didn't actually expect that they would fly through the threshold like this.'

---

The mental model to take away

The threshold theorem says three things in one:

The phase transition. There exists a critical physical error rate below which more qubits always helps, and above which more qubits always hurts. Below threshold is not slightly better than above threshold — it is a thermodynamically different regime. Dennis, Kitaev, Landahl & Preskill proved this is literally an ordered phase of matter, with all the stability that implies.

The exponential. Below threshold, the logical error rate falls exponentially with code distance. The exponent is (d+1)/2. At Λ = 2.14 and d = 19, the logical error rate falls to approximately 10⁻³% — eight distance steps from the d=3 baseline (0.655% / 2.14⁸ ≈ 0.0015%), each step multiplying suppression by another factor of 2.14. The same physical qubits, the same error rates, arranged in a larger lattice.

The gap. Willow proved the physics works at d=7. The engineering challenge between d=7 and a fault-tolerant logical qubit running a useful algorithm is roughly 28 more code-distance steps — from d=7 to d≈63 at current Λ=2.14 — adding ~7,800 physical qubits per logical qubit, plus the entirely separate problem of fault-tolerant logical gates. Improving Λ beyond 2.14 (by lowering physical error rates) compresses that distance requirement: at Λ=10, d≈27 suffices. The physics is solved. The engineering is not.

Shor’s nine-qubit code in 1995 showed it was possible to protect quantum information. The threshold theorem in 1998 showed that protection can scale. Willow in 2024 showed — for the first time with a real processor, a real decoder, and a real-time cycle constraint — that we are on the right side of the phase transition.

The dragon exists. We just crossed the boundary into the territory where fighting it is thermodynamically favorable.

Sources:

• Google Quantum AI (2025). “Quantum error correction below the surface code threshold.” Nature 638, 920–926.
• PMC full text of the Willow Nature paper
• Shor, P.W. (1995). PRA 52, R2493
• Knill, Laflamme & Zurek (1998). Science 279, 342
• Fowler et al. (2012). PRA 86, 032324
• Dennis, Kitaev, Landahl & Preskill (2002). J. Math. Phys. 43, 4452
• Google QAI (2023). “Suppressing quantum errors by scaling.” Nature 614.
• Quanta Magazine (2024). Quantum Computers Cross Critical Error Threshold.
• Willow processor — Wikipedia
• Threshold theorem — Wikipedia
• Surface Code Explained — QuantumZeitgeist
• Scott Aaronson: The Google Willow thing
• Google Blog: Meet Willow
• Google Research: Making quantum error correction work
• EntangledFuture: Fault-Tolerant Roadmap
• Bravyi et al. (2024). High-threshold fault-tolerant quantum memory. Nature 627.
• No-cloning theorem — Wikipedia
• Majorana 1 — Wikipedia
• Google Blog: Quantum hardware powering breakthroughs (Willow fidelity specs)