Quantum error correction

How can you protect a fragile quantum state from noise when looking at it destroys it?

Protecting classical information is almost embarrassingly easy: write it down three times and take the majority. The whole apparatus of error correction is built on that one move — keep copies, compare them, let the disagreement point at the damage.

A quantum state permits neither half of that recipe. You cannot copy an unknown state, and you cannot compare copies you do not have, because comparing means looking, and looking collapses the very superposition you were trying to preserve. For a while this looked less like a hard engineering problem than a proof that quantum computing was impossible. So what changed?

Take the two obstacles seriously first, because the answer is shaped by both.

The first is the no-cloning theorem: no operation takes an unknown state and produces two of it. That is not a limit of technology; it follows from the linearity of quantum mechanics. Redundancy by duplication is off the table.

The second is worse than it sounds. A measurement that would tell you the value of your qubit projects it, throwing away exactly the superposition you were storing. And a third difficulty has no classical counterpart: quantum errors are continuous. A passing field can rotate a qubit by any small angle, so there is no discrete list of failures to check against.

Now ask a sharper question. Redundancy, in the classical case, delivers two separate things: copies, and correlations between copies that damage would break. Which of those is doing the real work? It is the correlations. Majority voting does not need to read the message; it needs to know whether the three records still agree.

That reframing is the whole idea. If information can be stored in the correlations among many physical qubits, rather than in any one of them, then nothing needs copying and nothing about the encoded value lives anywhere a local disturbance can reach. Encode one logical qubit into an entangled state of several physical ones — Shor's original 1995 code used nine — chosen so that examining any single physical qubit reveals literally nothing about the logical value.

But if no individual qubit tells you anything, how do you find the error? Ask what a measurement is allowed to return. A measurement extracts whatever it asks about; the trick is to ask a question whose answer is independent of the stored value. So instead of measuring qubits, measure relations between qubits — joint parity checks, called stabilizers, of the form "do these four qubits still agree in this particular way?" These operators are deliberately built to commute with the logical information, so their outcomes carry no trace of it. Each check is performed by entangling the group with a spare ancilla qubit and measuring the ancilla, which is destroyed and reset while the data qubits are left in their superposition. The result is a syndrome: a pattern of broken checks that fingerprints the disturbance without ever naming the state.

Now the continuity problem, which resolves itself in a way worth pausing on. Suppose noise has rotated a qubit by some small arbitrary angle. That rotation can be written as a combination of "nothing happened" and definite bit-flip and phase-flip errors. Measuring the syndrome projects the qubit onto one of those alternatives. The continuum collapses into a discrete answer — either no error, or a specific flip — so only a finite set of corrections is ever needed. Measurement, the original enemy, has turned into the thing that makes the problem finite.

What remains is inference. A syndrome does not name the error uniquely; several error patterns produce the same broken checks, so a decoder must infer the most likely one from the syndrome history and apply the matching correction. Get it wrong badly enough and the correction itself creates a logical error.

Which sets up the last question: does this help, given that all those extra qubits are themselves noisy? The threshold theorem says yes, conditionally. If the physical error rate is below a threshold — of order one per cent for the surface code under simple noise models — then increasing the code distance suppresses the logical error rate exponentially. Above the threshold, more qubits make things worse. Crossing it experimentally was the milestone: Google reported in 2023 that a distance-5 surface code slightly beat a distance-3 one, and in the Willow result of 2024 that the logical error rate roughly halved at each step up in distance — below threshold, but far from the qubit counts a useful algorithm needs.

Three refinements.

First, the logical qubit is not hidden somewhere among the physical ones, waiting to be found. It is a subspace: the encoded state is a specific entangled pattern, and there is no location where the answer sits. That is what makes local noise survivable, and it is also why the encoded information cannot be read out by any local means, including by the correction machinery.

Second, correction is continuous work, not a repair after a failure. Stabilizers are measured round after round, forever, and the decoder runs on the whole stream, because syndrome measurements are themselves faulty and only their pattern over time is trustworthy.

Third, the cost is the honest headline. Useful distances imply something like a thousand or more physical qubits per logical one, plus real-time classical decoding, plus a way of performing logical operations on encoded states — a separate and in some ways harder problem, since most useful gates cannot be applied qubit by qubit.

• Why the surface code's two-dimensional grid of nearest-neighbour checks suits real hardware.
• How logical gates are performed without decoding — transversal gates and lattice surgery.
• Bosonic and cat codes, which build the redundancy inside a single oscillator.

Every term the collection defines is gathered in the glossary.