Errors, Noise & Quantum Error Correction

Qubits fail in four ways you can measure. They lose energy (T1). They lose their phase (T2). Their gates are a little off. Their readout sometimes lies. Real device pages list all four. Each one grows fast as a circuit gets longer. That is why quantum error correction exists at all.

Our simulator has no noise on purpose. So we add errors by hand. We put a real X gate (a bit flip) or Z gate (a phase flip) into the circuit, right where the fault would strike. That turns noise into something you can place, trace by hand, and predict exactly. It also shows a surprising rule: one error that goes into a CX gate can come out as two.

You cannot copy an unknown qubit. Say a machine copies |0⟩ and |1⟩ correctly. Then a rule called linearity forces it to entangle a superposition instead of copying it. Two lines of algebra prove it. So quantum error correction protects information by spreading it across entangled qubits. It never keeps backup copies.

The three-qubit bit-flip code stores one logical qubit as α|000⟩ + β|111⟩. It spots any single X error (bit flip) with a majority vote and undoes it exactly. It gets back the original amplitudes, not just the odds. In this chapter you run the whole cycle — encode, add an error, correct — on three qubits. You trace every prediction by hand first.

The bit-flip code can't see Z (phase-flip) errors. A Z passes every parity check with a clean syndrome, yet it damages the stored superposition. The fix is to wrap the code in Hadamard gates. That stores the data in the |+++⟩/|−−−⟩ basis instead. Now every Z error turns into an X error, which the repetition code already catches. It works because H·Z·H = X.

Shor's nine-qubit code was the first code to protect a qubit against any single-qubit error. It wraps the three-qubit phase-flip code around three copies of the three-qubit bit-flip code. It works because of one key fact. Once the parity checks act, every possible single-qubit error — even a tiny partial turn — behaves like one of just four cases. The four cases are: no error, a bit flip (X), a phase flip (Z), or both (XZ).

A stabilizer is a parity check. It is a measurement that asks "are these qubits the same or different?" It never asks what value either one holds. The answers from all the checks form a bit pattern called the syndrome. Each syndrome points to exactly one fix. That is how a code can find an error without collapsing the superposition it protects.

The surface code protects one logical qubit with a flat grid of physical qubits. The qubits are linked only by small parity checks between next-door neighbours. Flat superconducting chips already have that kind of wiring. Companies settled on it for two reasons. It still works when physical error rates are around 1%, which is unusually forgiving. And you scale it up by simply making the patch bigger.

A logical qubit is one error-corrected qubit built from many physical qubits. The exchange rate is steep. At surface-code distance 25, one logical qubit costs about 1,250 physical qubits. So 1,000 logical qubits means roughly 1.25 million physical ones. (This is example scaling math, not a company's figure.) That multiplication, plus extra time and extra normal computing, is why you should read every company's "logical qubit" announcement carefully. Always ask: is it demonstrated, or only on a roadmap?

Error mitigation cleans up answers after noisy runs. It re-weights, stretches back, or throws away measured results, and it needs no extra qubits. Error correction stops errors during the computation, but it needs a large number of extra qubits. Today's uncorrected devices rely on mitigation. Its costs grow exponentially as circuits get bigger. That is exactly why the field is working its way toward correction.