Fixing Broken Qubits: How the Surface Code Makes Fault-Tolerant Quantum Computing Possible

The most counterintuitive result in quantum computing theory is not about algorithms. It is about errors. The threshold theorem, proved in the late 1990s, established that a quantum computer with physical error rates below a certain threshold can perform arbitrarily long computations with arbitrarily low error — by adding more imperfect qubits. Not better qubits. More of them. Redundancy, implemented in a specific way, can suppress errors exponentially even when every component in the system is noisy.

This is quantum error correction, and it is not an optional enhancement to quantum computing. It is the prerequisite. Every credible estimate of what a quantum computer would need to break RSA-2048, simulate a useful molecule, or solve a practically relevant optimisation problem assumes fault-tolerant operation. Every demonstration of quantum advantage on today’s NISQ devices is bounded in scale precisely by the absence of it. Understanding quantum computing at depth means understanding why error correction is necessary, how the surface code implements it, and what the cost actually is.

Why Classical Error Correction Fails

Classical computers correct errors with redundancy: store three copies of every bit, take a majority vote. If one copy flips from 0 to 1, the other two outvote it. This works because classical bits can be copied freely and read without disturbing them.

Quantum states have neither property. The no-cloning theorem proves that an unknown quantum state cannot be copied — there is no quantum equivalent of the copy operation for an arbitrary superposition α|0⟩ + β|1⟩. Any attempt to duplicate it either fails to produce a faithful copy or disturbs the original. And measuring a quantum state collapses it: if you measure the qubit to find out whether it has flipped, you destroy the superposition you were trying to protect.

These constraints seem to make quantum error correction impossible. The field existed for thirty years under the implicit assumption that quantum computation would be hopeless at scale because of this. Peter Shor’s 1995 paper demolished that assumption.

The Key Insight: Measuring Without Looking

Shor’s insight — and independently Steane’s, and then a cascade of subsequent work — was that you do not need to measure the logical qubit to detect errors. You can measure correlations between qubits in a way that reveals what errors occurred without revealing what logical state the qubits are in.

Consider encoding a single logical qubit across three physical qubits. Rather than copying the logical state (forbidden), you create an entangled state: $|\bar{0}\rangle = |000\rangle$ and $|\bar{1}\rangle = |111\rangle$. Now instead of measuring individual qubits — which would collapse the state — you measure parity operators: the product of pairs of qubits. The operator $Z_1 Z_2$ has eigenvalue $+1$ if qubits 1 and 2 are the same, and $-1$ if they differ. Measuring $Z_1 Z_2$ tells you whether an error has introduced a discrepancy between qubits 1 and 2, without telling you whether the logical state is $|\bar{0}\rangle$ or $|\bar{1}\rangle$ (which would be revealed by the individual $Z$ values). The measurement outcome — $+1$ or $-1$ — is the syndrome bit, and the collection of all syndrome bits is the error syndrome.

This is not a toy example. Every quantum error correcting code works this way: the codespace is the +1 eigenspace of a set of multi-qubit Pauli operators called stabilisers, and the syndromes of those stabilisers pinpoint which physical qubits experienced errors without ever touching the logical quantum information stored in the code.

The Surface Code

The surface code is the quantum error correcting code that has dominated hardware development since the mid-2010s. It was proposed by Alexei Kitaev in 1997 as the “toric code” and adapted to a planar geometry — the “surface code” — by Fowler, Martinis, and collaborators. Its dominance comes from two properties that nothing else matches simultaneously: a high error threshold (~1% physical error rate), and a geometry that requires only nearest-neighbour two-qubit gates between adjacent qubits on a 2D grid.

A distance-$d$ surface code is a square lattice of $d^2$ data qubits, with ancilla qubits sitting between them. The ancillas come in two types, alternating in a checkerboard pattern:

X-type stabilisers measure the product XXXX of the four data qubits surrounding each blue plaquette. If no errors have occurred, this measurement always returns +1. If a Z error (phase flip) has occurred on any one of those four data qubits, the measurement returns −1, signalling that something went wrong nearby.

Z-type stabilisers measure ZZZZ on the four data qubits surrounding each red plaquette. They return −1 when an X error (bit flip) has occurred.

The two types are complementary: X errors are detected by Z stabilisers, and Z errors are detected by X stabilisers. This is a direct consequence of the anticommutation relation $\{X, Z\} = 0$: an $X$ error anticommutes with every $Z$ operator it encounters, flipping the sign of any $Z$ stabiliser that shares a data qubit with it.

Syndrome Extraction: Finding the Error

Every ancilla qubit is measured in every error correction cycle — typically taking a few microseconds on superconducting hardware. The collection of measurement outcomes is the syndrome: a pattern of +1 and −1 values across all ancilla positions. In the absence of errors, all ancillas return +1. An error on a data qubit causes a specific pattern of −1 outcomes among its neighbouring ancillas.

A single bit-flip error on one data qubit causes exactly two adjacent Z-type ancillas to return −1 — the two plaquettes that share that data qubit. The pattern of highlighted ancillas tells a classical decoder where the error most likely occurred. The decoder — software running in real time, typically on FPGAs — matches the highlighted ancilla pairs and infers the most likely error pattern. Applying the correction restores the logical state.

The critical point: at no step does the procedure measure the logical qubit itself. The logical state α|0̄⟩ + β|1̄⟩ is preserved throughout. The syndrome reveals error locations while being completely blind to the logical information encoded in α and β.

This works because stabiliser measurements commute with the logical operators. The stabilisers and the logical operators live in orthogonal subspaces of the operator algebra: you can measure all stabilisers and learn nothing about the logical state, just as you can measure $Z_1 Z_2$ and learn the parity of two bits without learning either bit individually.

The Threshold Theorem

The surface code has an error threshold of approximately 1% per physical gate. If the physical error rate is below this value, then increasing the code distance d exponentially suppresses the logical error rate. If the physical error rate is above the threshold, adding more qubits makes things worse, not better — the correction process itself introduces more errors than it removes.

Below threshold, the suppression is doubly exponential in d: each additional layer of code distance buys exponentially more error suppression, and the rate of improvement itself grows. A rough rule of thumb: with physical error rates of 0.1% (ten times below threshold), a distance-7 surface code achieves a logical error rate around 10⁻⁸ per cycle — eight orders of magnitude better than the physical qubit it protects.

The threshold is not a sharp number — it depends on the noise model, the decoder, the specific gate set, and whether errors in the error correction process itself are accounted for. The operational “fault-tolerant threshold” for the surface code, including the overhead of stabiliser measurement circuits that can themselves introduce errors, is approximately 0.5–1%.

The Physical Qubit Overhead

The overhead is sobering. A modern superconducting processor with 1,000 qubits and physical error rates around 0.3% could theoretically implement roughly two distance-7 logical qubits — enough for a proof-of-concept experiment, not a useful computation. The machines required for commercially valuable fault-tolerant algorithms are not currently close to existing. This is not a crisis; it is an engineering roadmap.

The T Gate Problem: Magic State Distillation

Quantum error correction does not protect all gates equally. The Clifford gates — H, S, CNOT, and their combinations — are the set of operations that map Pauli operators to Pauli operators. These gates can be implemented transversally in the surface code: by applying the gate to every physical qubit in the code block simultaneously, without spreading errors between qubits. Clifford gates are “free” in the fault-tolerant sense.

The problem is that Clifford gates alone cannot implement universal quantum computation. The T gate (a π/8 rotation about the Z axis) is needed to complete the universal gate set, and it cannot be implemented transversally in the surface code without spreading errors in a way that breaks fault tolerance.

The solution is magic state distillation: prepare many noisy copies of a specific resource state called a “magic state” (T|+⟩, the output of the T gate on |+⟩), distil them into fewer but higher-fidelity copies using only Clifford operations, and consume one high-fidelity magic state to implement each T gate via gate teleportation.

The overhead of magic state distillation dominates the total qubit count of a fault-tolerant computation. Estimates for factoring RSA-2048 suggest that roughly 90% of all physical qubits are consumed by the T factories — the circuits that distil magic states — rather than by the logical computation itself. More efficient distillation protocols and the development of codes with transversal T gates (like the color code or certain quantum LDPC codes) are active research priorities.

Google’s 2023 Below-Threshold Demonstration

In December 2023, Google’s Quantum AI team published a landmark result in Nature: using a 72-qubit Sycamore processor, they demonstrated that the logical error rate of a surface code decreases when the code distance increases from d=5 to d=7. This is not merely a quantitative milestone — it is the qualitative threshold crossing predicted by the threshold theorem.

The physical qubit error rates on Sycamore (around 0.2–0.5% for two-qubit gates) were below the effective fault-tolerant threshold for their implementation. The logical error rate dropped by a factor of approximately 2.9× as the code distance increased. The error suppression factor Λ — the ratio of logical to physical error rates per unit of code distance — was measured at 2.14, consistent with theoretical predictions for their noise model.

What this demonstration does not show is fault-tolerant computation — performing a useful algorithm at below-threshold error rates with error correction active throughout. The 2023 experiment demonstrated error suppression in the memory of an idle logical qubit, not under active logical gate operation. The next milestone, demonstrating logical gates with below-threshold performance, is the target of the current generation of experiments across Google, IBM, and Microsoft.

Beyond the Surface Code

The surface code’s dominance reflects practicality, not optimality. Several newer approaches offer significantly better encoding rates — more logical qubits per physical qubit — at the cost of more complex decoders and longer-range interactions.

Quantum low-density parity check (LDPC) codes are the most exciting recent development. Classical LDPC codes achieve the Shannon capacity — the information-theoretic optimum — for classical communication channels. Their quantum analogues can encode k logical qubits using n physical qubits with distance d scaling as √n, where n, k, d all grow together. The best quantum LDPC codes (including “good” LDPC codes proved to exist in 2022) can achieve constant encoding rate: k/n → constant, meaning you need far fewer physical qubits per logical qubit than the surface code. IBM’s “gross code” ([[144,12,12]]) — encoding 12 logical qubits in 144 physical qubits with distance 12 — is a bivariate bicycle LDPC code demonstrated at circuit-level noise in 2024.

Color codes are a topological code that has a transversal implementation of the full Clifford group, eliminating the need for magic state distillation for Clifford gates (though T gates still require injection). Their encoding density is similar to the surface code, but their logical gate set is richer.

Floquet codes (the honeycomb code) implement quantum error correction through repeated two-qubit measurements rather than four-body stabiliser measurements, potentially simplifying the measurement circuit and reducing error propagation.

What Fault Tolerance Actually Requires

The path from today’s NISQ processors to fault-tolerant quantum computers has three distinct prerequisites, none of which is yet fully demonstrated.

Physical error rates below threshold. Leading superconducting platforms achieve two-qubit gate fidelities of 99.5–99.8%, placing physical error rates at 0.2–0.5%. This is already below the ~1% threshold for the surface code under idealised noise models. The practical fault-tolerant threshold, accounting for real noise including crosstalk, leakage, and measurement errors, is closer to 0.3–0.5% — meaning current best hardware is at or near the boundary, not comfortably below it.

Qubit count at scale with connectivity preserved. A million-qubit surface-code processor must maintain nearest-neighbour two-qubit gate fidelity across the entire chip. Today’s best processors achieve high fidelity at 50–1,000 qubits; scaling to millions while preserving fidelity and connectivity is an unsolved systems engineering problem.

Fast, accurate classical decoding. The syndrome must be decoded and a correction applied within the coherence time of the logical qubit — typically one code cycle, ~1 µs for superconducting hardware. At d=17 with ~600 physical qubits per logical qubit and 1000 logical qubits, the decoder must process ~600,000 syndrome bits per microsecond and return corrections in real time. This is a significant classical compute challenge that has driven a subfield of research in fast approximate decoders.

The pieces are not all in place. What the threshold theorem guarantees is that they do not need to be perfect — only good enough. That is a more tractable target than perfection, and the rate of progress across all three dimensions has been faster than most researchers expected a decade ago.

The question is no longer whether fault-tolerant quantum computing is physically possible. It is whether the engineering overhead — millions of qubits, petabytes of classical control, factories of magic states — can be built at any practical scale before a competitive technology renders the effort obsolete. The answer will emerge over the next ten years, and it is genuinely uncertain.

Sources & Further Reading

1. Peter W. Shor. Scheme for Reducing Decoherence in Quantum Computer Memory. Physical Review A 52, R2493 (1995)
2. Austin G. Fowler, Matteo Mariantoni, John M. Martinis, Andrew N. Cleland. Surface Codes: Towards Practical Large-Scale Quantum Computation. Physical Review A 86, 032324; arXiv:1208.0928 (2012)
3. Google Quantum AI. Quantum Error Correction Below the Surface Code Threshold. Nature 638, 920; arXiv:2408.13687 (2024)
4. Sergey Bravyi, Andrew W. Cross, et al. (IBM). High-Threshold and Low-Overhead Fault-Tolerant Quantum Memory (bivariate bicycle / “gross” codes). Nature 627, 778; arXiv:2308.07915 (2024)

Discussion

← All articles