hard

Quantum Error Correction

Decoherence threatens every qubit — the 3-qubit bit-flip code shows how redundancy and syndrome measurement fight back.

Real qubits are fragile. Stray fields, heat, and unwanted interactions cause decoherence and noise, randomly disturbing the delicate amplitudes. Worse, the obvious classical fix — “just copy the bit three times and take a majority vote” — is blocked by the no-cloning theorem and by the fact that measuring a qubit destroys its superposition. Quantum error correction has to detect and repair errors without ever reading $\alpha$ or $\beta$ .

The 3-qubit bit-flip code is the simplest example. Step through it below: encode one logical qubit into three, let noise flip one of them, measure the syndrome to locate the flip, and apply a correction.

logical |ψ⟩ angle70°

bit flip on:

qubit 0

qubit 1

qubit 2

syndrome:s₀₁ (q0⊕q1) = —s₁₂ (q1⊕q2) = —

Speed

logical state: 0.819|0⟩ + 0.574|1⟩ → encoded as 0.819|000⟩ + 0.574|111⟩

Encode: α|0⟩ + β|1⟩ → α|000⟩ + β|111⟩ using two CNOTs. The three qubits now agree.

Encoding

We spread one logical qubit across three physical qubits using two CNOTs:

$\alpha|0\rangle + \beta|1\rangle \;\longrightarrow\; \alpha|000\rangle + \beta|111\rangle$

This is not cloning — there is still only one quantum state, now entangled across three qubits. The amplitudes $\alpha, \beta$ are never duplicated; only the classical pattern (all-zeros vs. all-ones) is made redundant.

Detecting the error

Suppose noise flips qubit $1$ , turning the state into $\alpha|010\rangle + \beta|101\rangle$ . We must find the culprit without learning $\alpha$ or $\beta$ . The trick is to measure parities rather than the qubits themselves:

$s_{01}$ = parity of qubits $0$ and $1$ (do they match?)
$s_{12}$ = parity of qubits $1$ and $2$

These two bits form the syndrome. They reveal whether neighbors disagree, but reveal nothing about the encoded amplitudes — so the superposition survives the measurement. The mapping is unambiguous:

$s_{01}$	$s_{12}$	flipped qubit
0	0	none
1	0	qubit 0
1	1	qubit 1
0	1	qubit 2

Correcting it

Once the syndrome names the offending qubit, applying an $X$ gate flips it back, restoring $\alpha|000\rangle + \beta|111\rangle$ and therefore the logical state. The correction is itself a quantum operation, so the protected superposition is recovered exactly — no information was lost. Try the none option in the visualizer to confirm that a clean round produces syndrome $00$ and leaves the state untouched.

Limits and the bigger picture

This code only fixes a single bit flip; two simultaneous flips would fool the majority and produce a logical error. It also does nothing about phase flips (the $Z$ -type error). The famous 9-qubit Shor code stacks a bit-flip code and a phase-flip code to correct any single-qubit error, and modern surface codes extend the idea to large 2D lattices. The strategy is always the same: redundancy plus syndrome measurements that diagnose errors without disturbing the data — the foundation of fault-tolerant quantum computing.

The Shor code (9 qubits)

The 3-qubit code above fixes a bit flip ( $X$ ) but is blind to a phase flip ( $Z$ ). The fix for phase flips is elegant: a phase flip in the standard basis is a bit flip in the Hadamard basis. So the phase-flip code is just the bit-flip code conjugated by Hadamards — encode with $H$ on every qubit, and a $Z$ error becomes an $X$ error that the same parity machinery catches:

$Z = H X H$

Peter Shor’s 9-qubit code concatenates the two: it nests a bit-flip code inside a phase-flip code, encoding one logical qubit into $9$ physical qubits arranged as 3 blocks of 3.

$|0\rangle_L = \tfrac{1}{2\sqrt2}\big(|000\rangle + |111\rangle\big)^{\otimes 3}, \qquad |1\rangle_L = \tfrac{1}{2\sqrt2}\big(|000\rangle - |111\rangle\big)^{\otimes 3}$

Two layers of syndrome measurement then cooperate:

Inner (bit-flip) syndrome — within each block of 3, the same parity checks as before locate a single $X$ error and fix it with an $X$ .
Outer (phase-flip) syndrome — a $Z$ on any qubit in a block flips that block’s sign ( $|000\rangle + |111\rangle \to |000\rangle - |111\rangle$ ). Comparing the signs across the three blocks locates which block carries the phase error and fixes it with a $Z$ .

Because any single-qubit error is a combination of $X$ , $Z$ , and $Y = iXZ$ , correcting bit flips and phase flips independently corrects every single-qubit error — even a small continuous rotation, which the syndrome measurement discretizes into one of these cases. Inject a bit flip, a phase flip, or both on any qubit and step through detection and correction:

error on qubit:

bit flip Xphase flip Z

block 0|000⟩+|111⟩

block 1|000⟩+|111⟩

block 2|000⟩+|111⟩

syndromes:inner (bit): —outer (phase): —