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. Typical two-qubit operations fail somewhere between once in a hundred and once in a thousand tries; the very best trapped-ion results have reached about once in ten thousand. An algorithm like Shor's needs billions of operations — without correction, those tiny errors pile up and swamp the answer. (Two-qubit gate error ~0.1–1% on most hardware; 99.99% fidelity reported by IonQ/Oxford Ionics in 2025; useful algorithms need logical error rates of ~10⁻⁹–10⁻¹².)
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 99.5–99.9% two-qubit gate accuracy, with a few trapped-ion results near 99.99% — and since late 2024, hardware has been on the good side of that line (see below). (Surface-code threshold ≈ 1% per gate; in practice error rates ~10× below threshold are needed for efficient scaling.)
The catch — overhead: With the surface code, protecting one logical qubit well enough for long algorithms takes on the order of 1,000 physical qubits. Newer codes need far fewer, at the price of more complex wiring. That is why estimates for breaking RSA-2048 have fallen from about 20 million physical qubits (2019) to under a million (2025) and, in 2026 proposals, to roughly 100,000 or even fewer. Today's largest machines are still much smaller: about 1,000 qubits on the biggest superconducting chips and about 6,100 trapped atoms in the largest neutral-atom array — which does not yet compute with all of them. (Gidney 2025: ~1,400 logical qubits, <1M physical, surface code; Pinnacle 2026: <100,000 physical, qLDPC codes; both assume 0.1% physical error and 1 µs cycles. Caltech 6,100-atom tweezer array, Nature 2025.)
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 2026 has been about making many of them work together, and running real operations on them — across every major hardware type, not just Google's superconducting chips. The way the field measures progress has shifted too: rather than counting logical qubits or chasing headline "quantum advantage" demos, researchers increasingly track how many reliable operations a complete system can perform. ("QuOps" — reliable quantum operations — as the emerging metric; Sandia National Laboratories introduced a QuOps benchmark in 2026.)
One caution when reading headlines: many "logical qubit" records use codes that can only detect errors, not fix them, and simply throw away runs where an error is flagged. That is a useful step, but a fault-tolerant machine must correct errors as they happen, without discarding work. (Error detection with post-selection vs. real-time decoding and feed-forward; acceptance rates fall exponentially with circuit size.)
Many Logical Qubits
Trapped-ion and neutral-atom machines now run tens of logical qubits at once — 48 error-corrected and 94 error-detected on Quantinuum's 98-qubit Helios, and up to 96 reported by QuEra. In a June 2026 Nature paper, Microsoft and Quantinuum showed protected qubits making 11 to 800 times fewer errors than unprotected ones. (Helios used concatenated "iceberg" codes, e.g. [[80,48,4]]; the larger gains relied partly on post-selection.)
Error Correction That Tunes Itself
Hardware slowly drifts out of calibration, which normally means stopping to recalibrate. In July 2026 Google showed an AI agent that learns from the error signals the code already produces and keeps adjusting thousands of control settings while the computation runs — cutting logical errors by a further 20% beyond expert tuning. (Reinforcement-learning control on Willow; 3.5× better stability under injected drift; surface code below 10⁻³ logical error per cycle.)
Magic States
Error-corrected qubits can easily do some operations but need a special ingredient — a "magic state" — for the rest, and making those cleanly is one of the biggest costs in a future quantum computer. In October 2026 Google produced them on Willow with about 40 times fewer errors than before, reaching 99.99% accuracy. (Magic state cultivation: logical T-states prepared in a distance-3 colour code and grafted into a distance-5 surface code; needed for non-Clifford gates.)
Systems, Not Demos
Correcting errors in real time needs fast classical "decoders" that diagnose problems within microseconds, and these are now arriving as standard hardware. In September 2026 the US Department of Energy launched a competition of up to $215 million for the first fault-tolerant machines with at least 100 logical qubits. (Quantum Genesis Q: hundreds of millions of fault-tolerant operations required. FPGA/ASIC decoders from Riverlane and IBM; IonQ reported a CPU decoder benchmarked on simulated circuits with up to 408 logical qubits.)