Quantum error correction

Qubits rot in microseconds, yet a useful algorithm needs billions of reliable gate operations. Something has to give. The answer is one of the most surprising results in the field: you can build an almost-perfect qubit out of many terrible ones - and you can do it without ever violating the rule that says you cannot copy a qubit.

Spreading is not copying

No-cloning forbids making independent copies of an unknown state - two separate qubits that each carry the full $\alpha |0⟩+\beta |1⟩$. That is not what error correction does. Instead we spread one logical state across several physical qubits in an entangled way:

$\alpha |0⟩+\beta |1⟩⟶\alpha |000⟩+\beta |111⟩$.

Look closely: no single qubit here holds $\alpha |0⟩+\beta |1⟩$ on its own. If you measured just one, you would get 0 or 1 at random and learn nothing about $\alpha$ and $\beta$. The information lives in the correlations between the three, not in any copy. That is perfectly legal, and you build it with two CNOTs, not a cloning machine.

from qiskit import QuantumCircuit

qc = QuantumCircuit(3)      # q0 carries the unknown state alpha|0> + beta|1>
qc.cx(0, 1)                 # spread it onto q1 ...
qc.cx(0, 2)                 # ... and q2, giving alpha|000> + beta|111>
# no qubit now holds the state alone - it lives in the correlations

Read the error, not the data

Now for the second half of the trick. Measuring the data qubits would collapse the superposition and destroy $\alpha$ and $\beta$ - fatal. So we do not measure the data. We measure parities: does qubit 0 agree with qubit 1? Does qubit 1 agree with qubit 2? A parity is a single yes-or-no fact about a pair, and crucially it says nothing about whether they are both 0 or both 1.

These two answers are the syndrome. In the encoded state all three qubits agree, so both parities read "same" (0, 0). Flip one qubit and the parities it touches turn to "different", and the exact pattern points straight at the culprit - without ever revealing the logical bit.

Run the full cycle

Encode a logical bit, inject a flip on any qubit, then measure the two syndromes and correct. Watch the key move: switch the logical bit between 0 and 1 with the same qubit flipped, and the syndrome is identical. The syndrome learned where the error is and nothing about what you stored.

From three qubits to a real code

The three-qubit code is a toy: it only catches bit flips, and a qubit can also suffer a phase flip (the Z error that scrambles the equator). Real codes protect against both. The workhorse today is the surface code: a two-dimensional grid of physical qubits with the same idea scaled up - lots of local parity checks, no data ever measured, one robust logical qubit hiding in the correlations of many physical ones.^[2]

But scaling only helps if the hardware is good enough to begin with. That is the content of the threshold theorem: if every physical operation errs less often than a fixed threshold - roughly $0.1$ to $1\%$ per gate - then piling on more physical qubits makes the logical error rate fall exponentially. Below threshold, bigger is better, without limit. Above it, every extra qubit you add introduces more errors than it fixes, and correction never catches up.

Check yourself