Fault Tolerance
Quantum Error
Correction
Quantum computers are built on the most fragile objects in physics — the slightest disturbance corrupts a calculation. The trick that makes them viable is error correction: spotting and fixing mistakes without ever looking directly at the data, because looking would destroy it.
Why Quantum Computers Need Error Correction
The Fragility Problem
A regular computer bit is sturdy — it's firmly 0 or 1, and it takes a real jolt to flip it by accident. A qubit is the opposite: it holds a delicate blend of possibilities that the faintest nudge from the outside world can ruin. Physicists call that ruin decoherence. (A qubit's superposition is disrupted by any environmental interaction.)
Decoherence creeps in two ways: a qubit can lose its energy and slump back to 0, or it can drift out of sync so the delicate timing of its superposition is scrambled. On today's leading hardware a qubit only stays coherent for millionths to thousandths of a second — far too short for serious algorithms. (T1 = energy relaxation, |1⟩ → |0⟩; T2 = dephasing, loss of phase coherence; both on the order of µs–ms for superconducting qubits.)
Worse, every operation adds its own slip. Even the best two-qubit gates miss roughly once every 100 to 1,000 tries. An algorithm like Shor's needs millions of operations — without correction, those tiny errors pile up and swamp the answer. (Two-qubit gate error rates ~0.1–1% per operation.)
Why Classical Error Correction Fails
You Can't Copy a Qubit
Ordinary computers fix errors by making copies — store 0 as 000, and if one bit flips, majority vote wins. Quantum mechanics flatly forbids copying an unknown quantum state, so that simple trick is off the table. (The No-Cloning Theorem.)
Looking Destroys It
You can't just inspect a qubit to see if it's broken — measuring it collapses the superposition you were trying to protect. The workaround uses helper qubits to learn what kind of error occurred without learning the data itself. (Ancilla qubits measure error syndromes, not the logical state.)
Errors Are Continuous
A classical bit either flips or it doesn't. A qubit can be knocked by any tiny amount in any direction — infinitely many possible errors. The saving insight: every possible error breaks down into a few standard types, so fixing those few covers them all. (Any error is a linear combination of Pauli operators {I, X, Y, Z}.)
Two Kinds of Mistake
Quantum errors come in two basic flavours: a bit flip (swapping the qubit's 0 and 1) and a phase flip (scrambling the relationship between them). A complete code has to catch both at once. (X: |0⟩↔|1⟩; Z: |+⟩→|−⟩.)
Shor's 9-Qubit Code
How You Spot an Error Without Looking
The heart of the trick is to ask the right kind of question. Instead of asking "what is this qubit?" (which would destroy it), the code asks "do these qubits still agree with each other?" — a yes/no comparison that reveals an error without revealing the protected data. The pattern of yes/no answers is called the error syndrome, and it points to exactly which qubit slipped and how. (Stabilisers — multi-qubit Pauli operators that commute with the code space but anticommute with errors — are measured; the outcomes form the syndrome without collapsing the logical state.)
Take the simplest example: store the logical 0 as three identical qubits and the logical 1 likewise. Checking whether neighbouring qubits match tells you if one flipped — and which one — without ever telling you whether you're holding a 0 or a 1. Apply the matching fix and the data is restored. (Three-qubit bit-flip code: |0⟩→|000⟩, |1⟩→|111⟩; parity checks on qubits 1&2 and 2&3 locate the flip.)
Notable QEC Codes
The Surface Code
The Fault-Tolerance Threshold Theorem
A Critical Milestone
There's a tipping point. If your hardware's error rate is below a certain threshold, then piling on more physical qubits per logical qubit drives the error rate down toward zero — redundancy wins. But if you're above the threshold, adding qubits only adds more chances for failure and makes things worse. Everything depends on which side of that line you're on. (The threshold theorem: below a code-specific physical error rate, logical error is suppressed exponentially in the number of qubits.)
Where the line sits: For the leading surface code the threshold is roughly 1% error per gate. The best processors now reach about 99.5–99.9% two-qubit gate accuracy — and as of late 2024, hardware has crossed to the good side of that line for the first time (see below). (Surface-code threshold ≈ 1% per gate.)
The catch — overhead: Protecting a single logical qubit still takes on the order of 1,000 physical qubits. Breaking RSA-2048 with Shor's algorithm needs thousands of logical qubits — translating to millions of physical ones. Today's largest processors have only about 1,000–2,000 qubits total, so the gap to a cryptographically useful machine remains enormous. (~1,000 physical per logical; ~4,000 logical → ~4 million physical for RSA-2048.)
Since Willow — Scaling to Many Logical Qubits
From One Protected Qubit to Many
Willow proved a single logical qubit could be made reliable. The race through 2025 and into 2026 has been about making many of them at once — and it has played out across every major hardware type, not just Google's superconducting chips. Error correction has gone from a theory people trusted to something running on real machines everywhere. A shift in how the field measures progress came with it: rather than counting logical qubits or chasing headline "quantum advantage" demos, researchers increasingly track reliable quantum operations in complete fault-tolerant systems — the practical yardstick for a machine that actually works. ("QuOps" as the emerging success metric.)
Many Logical Qubits
Trapped-ion and neutral-atom machines reached tens of logical qubits at once: 96 on QuEra, 48 on Quantinuum's Helios, 24 on Atom Computing (with Microsoft), 12 on Infleqtion.
Dynamic Surface Codes
Google moved beyond Willow's fixed pattern to flexible codes that reshape how errors are caught each cycle — hexagonal, walking, and iSWAP circuits — cutting hardware cost and error sources.
Systems, Not Demos
The first small fault-tolerant systems appeared — integrating many imperfect qubits into a whole that computes reliably. Success is now measured in reliable operations, not qubit counts.