How Quantum Error Correction Works

Here is the problem in one sentence. To protect a piece of quantum information you would like to make a backup copy, and to check whether it has been corrupted you would like to look at it. Quantum mechanics forbids both. You cannot copy an unknown quantum state, and looking at one destroys it. For decades this made reliable quantum computing sound not merely hard but impossible in principle. The way out was worked out in the 1990s and finally demonstrated on real hardware in the last two years. It is one of the most ingenious ideas in modern physics: never look at the data at all, and ask the qubits only whether they still agree with each other.

Classical error correction does not transfer

A classical computer corrects errors by copying. Store a bit three times, read all three, take the majority. Three quantum obstacles block that approach outright.

The first is the no-cloning theorem, which Wootters and Zurek proved in 1982. No operation can copy an unknown quantum state. Triple redundancy fails at the first step.

The second is measurement. Reading a qubit to check on it collapses the superposition and destroys the computation you were trying to protect.

The third is that quantum errors are continuous. A classical bit either flips or it does not. A qubit can rotate by any small angle, in any direction. There is an infinite space of possible errors, and a finite code has to handle all of them.

Measure the relationship, never the value

The solution is to ask a question whose answer reveals an error without revealing the data. Take two qubits and ask only whether they agree. That parity is a single classical bit. It says nothing about the underlying state of either qubit, and nothing about the amplitudes.

In hardware, an extra qubit called an ancilla performs the check. The ancilla couples to the data qubits, absorbs the parity information, and then goes to measurement. The data qubits keep their superposition throughout.

Run many such checks across the code and the pattern of results forms a syndrome, a classical fingerprint pointing at where an error struck. The operators these checks evaluate are the code’s stabilisers. Gottesman, Calderbank, Shor and Steane built the whole framework on them in the mid-1990s.

Measuring the syndrome makes continuous errors discrete

This step makes the whole enterprise possible, and it is the part most summaries skip. Any error acting on a single qubit, however small the rotation, decomposes mathematically into four basic operations: doing nothing, a bit flip, a phase flip, and both at once.

Measuring the syndrome projects the system onto one of those four cases. A tiny fraction-of-a-degree over-rotation does not remain a tiny over-rotation. The measurement forces it to become either no error at all or a full bit flip, with probabilities set by the size of the original rotation.

A continuum of errors therefore collapses into a finite set. Correct the finite set and you have corrected everything. This result, error discretisation, is the reason analogue noise does not defeat quantum error correction.

The surface code and the price of distance

The surface code dominates the field because it asks so little of the hardware. Qubits sit on a two-dimensional grid. Data qubits hold the encoded information. Measure qubits sit between them and run parity checks on their four nearest neighbours only. It needs no long-range wiring at all.

Half the checks catch bit flips and half catch phase flips. The code distance is the length of the shortest error chain that can corrupt the logical state without tripping a single check. A code of distance d corrects errors up to roughly half that distance, and costs on the order of two times d squared physical qubits.

That scaling is the problem. Distance 3 costs 17 qubits, distance 7 costs 97, distance 25 costs over 1,200. Useful algorithms want logical error rates near one in ten billion from hardware sitting near one in a thousand, which needs distances in the twenties or thirties. Per logical qubit.

The threshold theorem sets the entry price

Error correction only helps if the hardware is already good enough. That is the threshold theorem, proved in the late 1990s by Aharonov and Ben-Or, by Kitaev, and by Knill, Laflamme and Zurek.

Below a critical physical error rate, raising the code distance suppresses logical error exponentially. Above it, the extra qubits and extra gates inject more errors than the code removes, so larger codes perform worse. Under realistic circuit-level noise, the surface code threshold sits near 1 percent.

The experimental figure of merit is called lambda, the factor by which logical error drops when code distance increases by two. A lambda above 1 means below threshold. Its size tells you how many doublings separate today’s hardware from a target error rate.

Willow crossed the threshold

Google’s Willow processor produced the first clean demonstration. Reporting in Nature, the team ran surface code memories on 72-qubit and 105-qubit superconducting chips. Logical error fell by a factor of 2.14 for each two-step increase in distance, reaching 0.143 percent per correction cycle on a 101-qubit distance-7 code. It was one of several results we track in the latest in quantum computing.

The memory also passed break-even, outliving its best individual physical qubit by a factor of 2.4. Real-time decoding held up as well: 63 microseconds of average decoder latency at distance 5, against a 1.1 microsecond cycle time, sustained across a million cycles.

One result in that paper deserves more attention than it received. Running repetition codes out to distance 29, the team found performance limited by rare correlated error events, roughly once an hour, or once every three billion cycles. The leading suspect is cosmic rays: a stray particle from space striking the chip and dumping energy across many qubits at once, an error no local code was built to survive.

Decoding is a real-time classical problem

Every correction cycle emits a syndrome, and classical software has to interpret it quickly. The standard algorithm, minimum-weight perfect matching, treats the syndrome as a graph problem and finds the most likely error consistent with the observations.

Speed is not optional here. If the decoder runs slower than syndromes arrive, the backlog grows without bound and the computation stalls. Surface code cycles take around one microsecond on superconducting hardware, which imposes a hard latency budget on the classical side.

This is why decoder engineering now sits alongside qubit engineering in every serious programme, and why quantum hardware companies have started partnering with GPU vendors.

Protecting a memory is not the same as computing

Everything above protects stored information. Running an algorithm means applying gates to logical qubits, and that is a harder problem.

Some gates come cheap. Transversal gates act on each physical qubit independently, so an error on one qubit cannot spread to its neighbours inside the same block. Many codes offer the everyday, easy-to-simulate gates this way.

Those easy gates alone are not enough. The Gottesman-Knill theorem shows that a classical computer can efficiently simulate any circuit built only from them. Universal computation needs at least one harder gate, usually called the T gate.

The Eastin-Knill theorem then closes the obvious door: no quantum code has a transversal gate set that is universal. Something more expensive is always necessary.

Magic states are where the cost concentrates

The standard workaround prepares a special resource state offline, then consumes it to execute the T gate. These are magic states, and in most resource estimates they dominate the qubit budget of a fault-tolerant machine.

Preparing them cleanly is the hard part. Magic state distillation takes several noisy copies and yields one better copy, discarding the rest. In 2025 a QuEra, Harvard and MIT team ran the first distillation performed entirely on logical qubits, using a five-to-one protocol on small colour codes in a neutral-atom system. That result is peer-reviewed and published in Nature.

A cheaper route exists in theory: magic state cultivation, proposed by Gidney, Shutty and Jones in 2024, grows the state directly inside a small code and skips distillation entirely. That original proposal remains a preprint. Then in December 2025 a large Google Quantum AI collaboration moved it from theory to hardware. They ran cultivation on a superconducting processor and grafted the result into a distance-5 surface code through code-switching. The measured state fidelity reached 99.99 percent, a 40-fold reduction in error compared with simple state injection, while keeping about 8 percent of attempts through post-selection. That hardware result is also still a preprint.

qLDPC codes broke the overhead scaling

The surface code’s overhead is not a design flaw. A 2010 bound proved by Bravyi, Poulin and Terhal shows that any code restricted to two-dimensional nearest-neighbour connectivity must pay roughly this price. Escaping it requires escaping the flat grid.

Quantum low-density parity-check codes do exactly that, permitting a few long-range connections. IBM’s gross code, published in Nature in 2024, encodes 12 logical qubits into 288 physical qubits total, with a threshold around 0.7 percent. Matching that protection with separate surface code patches would take close to 3,000 physical qubits.

The trade is connectivity. The gross code needs a richly connected wiring graph across two layers. That is harder to fabricate than a flat grid, though not out of reach for superconducting chips.

Where the overhead actually stands

Reported ratios have fallen fast, and they need careful reading. Quantinuum’s Helios system, launched in November 2025, produced 48 error-corrected logical qubits from 98 physical qubits, a ratio near two to one. That came from a technique called code concatenation. QuEra reported a comparable ratio on neutral atoms using high-rate qLDPC codes. Why those counts resist head-to-head comparison is the subject of our logical qubits explainer.

What is still unresolved

Three problems stand between below-threshold memories and a working fault-tolerant computer.

Correlated errors come first. As the Willow repetition-code data showed, cosmic rays and similar events knock out large regions of a chip at once, roughly once an hour, and no local code handles that.

Decoder scaling comes second. Real-time matching works at distance 7 on about 100 qubits. Nobody has demonstrated it across thousands of logical qubits running a real algorithm.

Logical gate speed comes third. Error-corrected operations run orders of magnitude slower than physical ones, and every magic state consumed adds latency. A machine that corrects errors perfectly but computes slowly may still miss its target applications.