The Three-Qubit Code

The three-qubit bit-flip code protects one logical qubit from the bit-flip channel, the quantum analogue of a bit that randomly flips $0 \leftrightarrow 1$. It encodes a single logical qubit $|\psi\rangle_L = \alpha|0\rangle_L + \beta|1\rangle_L$ into three physical qubits via the encoding map

so that an arbitrary state $\alpha|0\rangle + \beta|1\rangle$ becomes the entangled state $\alpha|000\rangle + \beta|111\rangle$. This is emphatically not three independent copies of $\alpha|0\rangle+\beta|1\rangle$ — that would violate the no-cloning theorem. It is one logical qubit's amplitude structure spread coherently across a triple of physical qubits, all correlated. The error model under consideration is the independent bit-flip channel: each physical qubit, independently, either survives unchanged (probability $1-p$) or is hit by a Pauli $X$ operator (probability $p$), which swaps $|0\rangle \leftrightarrow |1\rangle$. This is a caricature of real noise, but it captures the essential difficulty: an $X$ error can strike any one of the three qubits, at an unknown time, and we must find and undo it without ever learning $\alpha$ or $\beta$. The key mechanism is syndrome extraction. Rather than measuring the three data qubits directly (which would collapse the superposition and destroy $\alpha,\beta$), the protocol measures two parity checks: whether qubits 1 and 2 agree, and whether qubits 2 and 3 agree. These parities are the eigenvalues of the stabilizer generators $Z_1Z_2$ and $Z_2Z_3$. Crucially, $Z_1Z_2$ and $Z_2Z_3$ commute with the logical operators $X_L = X_1X_2X_3$ and $Z_L = Z_1Z_2Z_3$, so measuring them extracts error information while leaving the encoded logical state completely undisturbed. This idea — measure operators that commute with the logical algebra but anticommute with likely errors — is the seed from which the entire Stabilizer Codes formalism grows.

Encoding. Starting from $|\psi\rangle|0\rangle|0\rangle = (\alpha|0\rangle+\beta|1\rangle)|0\rangle|0\rangle$, two CNOT gates, controlled by qubit 1 and targeting qubits 2 and 3, produce

Noise. The channel independently applies $X$ to each of the three qubits with probability $p$, and leaves it alone with probability $1-p$. We assume (for the basic analysis) at most one qubit is flipped per round — a good approximation when $p$ is small, since two simultaneous flips occur with probability $O(p^2)$.

Syndrome extraction. Two ancilla qubits, initialized to $|0\rangle$, are used to non-destructively measure the parities $Z_1Z_2$ and $Z_2Z_3$. This is done with CNOT gates: ancilla $a_1$ is flipped by qubits 1 and 2 (measuring $Z_1 \oplus Z_2$ in the computational basis sense), and ancilla $a_2$ is flipped by qubits 2 and 3.

Correction. The two classical bits $(s_1, s_2)$ obtained from measuring the ancillas identify which qubit (if any) was flipped, via a lookup table. A classically controlled $X$ gate is applied to that qubit, restoring the encoded state exactly. ``` // THREE-QUBIT BIT-FLIP CODE function ENCODE(psi): // psi lives on qubit q0; q1, q2 start at |0> CNOT(q0 -> q1) CNOT(q0 -> q2) return (q0, q1, q2) // now alpha|000> + beta|111> function NOISE(q0, q1, q2, p): for q in (q0, q1, q2): with probability p: apply X(q) return (q0, q1, q2) function EXTRACT_SYNDROME(q0, q1, q2): a1, a2 <- |0>, |0> // fresh ancillas CNOT(q0 -> a1); CNOT(q1 -> a1) // a1 = q0 XOR q1 CNOT(q1 -> a2); CNOT(q2 -> a2) // a2 = q1 XOR q2 s1 <- MEASURE(a1) // classical bit, Z-basis s2 <- MEASURE(a2) return (s1, s2) function RECOVER(q0, q1, q2, s1, s2): // Syndrome table (derived below) if (s1, s2) == (0, 0): pass // no error else if (s1, s2) == (1, 0): apply X(q0) // q0 flipped else if (s1, s2) == (1, 1): apply X(q1) // q1 flipped else if (s1, s2) == (0, 1): apply X(q2) // q2 flipped return (q0, q1, q2) // restored to alpha|000> + beta|111> function DECODE(q0, q1, q2): CNOT(q0 -> q2) CNOT(q0 -> q1) return q0 // logical qubit recovered ``` The syndrome table is derived directly from the parity structure. If qubit $i$ alone is flipped, it disagrees with its neighbors; the two parity bits record exactly which boundary of agreement/disagreement appears, pinpointing $i$ uniquely, regardless of $\alpha$ and $\beta$.

Resource cost. Encoding one logical qubit costs 2 CNOT gates and 2 extra physical qubits. Syndrome extraction costs 4 CNOT gates and 2 ancilla qubits, plus 2 classical measurements. Recovery costs at most 1 conditional $X$ gate. All of this is $O(1)$ — constant overhead independent of circuit depth — per round of error correction. Repeating this every fixed number of time steps, over a computation of $T$ logical gates, multiplies total resource use by a constant factor, not asymptotically, since the code distance stays fixed at $d=3$ physical qubits per logical qubit.

Why this is efficient in practice: the only growth in overhead comes from wanting a lower logical error rate, which requires larger codes (distance $d$ scales with desired suppression), not from this specific code's mechanics. The three-qubit code is a proof of concept with minimal $d=3$; larger stabilizer and topological codes trade more qubits for better suppression, following the same syndrome-extraction blueprint.

Correctness proof sketch. The crux of quantum error correction is recognizing that even though a general error is a continuous quantum channel, our measurement of the syndrome projects it onto a discrete outcome. Here is the precise argument. Let the codespace be $\mathcal{C} = \text{span}\{|000\rangle, |111\rangle\}$. Consider the four possible single-qubit error operators: $I$ (no error), $X_1$, $X_2$, $X_3$ (bit-flip on qubit 1, 2, or 3). Apply one of these to an encoded state $|\psi_L\rangle = \alpha|000\rangle+\beta|111\rangle$:

These four resulting states live in four mutually orthogonal two-dimensional subspaces of the 8-dimensional Hilbert space $(\mathbb{C}^2)^{\otimes 3}$. Orthogonality is easy to check: the basis strings $\{000,111\}$, $\{100,011\}$, $\{010,101\}$, $\{001,110\}$ are pairwise disjoint sets of bit strings, hence the subspaces they span are orthogonal. The syndrome measurement is precisely a projective measurement that distinguishes these four orthogonal subspaces — it measures $Z_1Z_2$ and $Z_2Z_3$, whose four joint eigenspaces are exactly the four subspaces above:

Because measuring which orthogonal subspace the state lies in does not disturb the state within that subspace, the coefficients $\alpha,\beta$ survive completely intact — this is the standard projective-measurement postulate applied to a degenerate two-dimensional eigenspace. Once the syndrome (i.e., the subspace) is known, applying the inverse Pauli ($X_i$ again, since $X_i^2=I$) maps the state back to $\mathcal{C}$ exactly, recovering $\alpha|000\rangle+\beta|111\rangle$ with fidelity 1. This is the general mechanism behind all of quantum error correction, first formalized as the Quantum Error Correction Conditions (Knill–Laflamme criteria): correctable errors must map the codespace into mutually orthogonal subspaces indexed by distinguishable syndromes, and within each subspace act identically up to a fixable unitary. The three-qubit code satisfies this exactly for the single-bit-flip error set $\{I, X_1, X_2, X_3\}$.

Honest limitations.

• If two of the three qubits flip simultaneously, the resulting state lands in the same subspace as a single flip on the third qubit (e.g., $X_1X_2|\psi_L\rangle = \alpha|110\rangle+\beta|001\rangle$, indistinguishable in syndrome from $X_3$ alone), and the recovery procedure misdiagnoses and actively introduces a logical error. This is why the code corrects at most one bit-flip error; it has distance $d=3$.
• The code offers zero protection against phase-flip ($Z$) errors: applying $Z_1$ to $\alpha|000\rangle+\beta|111\rangle$ produces $\alpha|000\rangle-\beta|111\rangle$, an undetectable logical phase error, since $Z_1$ has trivial syndrome only when it acts identically on the code as $Z_2$ or $Z_3$ up to sign — in fact any single $Z_i$ flips the relative sign and is not even correctable in principle by this code, since $Z_1$, $Z_2$, $Z_3$ all commute with both stabilizers and act as the same logical operator (up to global phase) on the codespace, making them indistinguishable from each other and from a logical $Z$ error.
• The syndrome extraction circuit itself, if implemented with noisy CNOTs, can propagate errors onto the data qubits or introduce faulty syndromes — full fault tolerance requires additional care (repetition of syndrome measurement, fault-tolerant gadgets), a topic that becomes central once we scale to Stabilizer Codes and beyond.

Take the logical state $|\psi_L\rangle = \tfrac{1}{\sqrt2}(|0\rangle_L + |1\rangle_L) = \tfrac{1}{\sqrt2}(|000\rangle + |111\rangle)$, i.e. $\alpha=\beta=1/\sqrt2$. Suppose the noise channel flips qubit 2 (an $X_2$ error).

The crucial detail: the syndrome $(1,1)$ came out identically on both branches $|010\rangle$ and $|101\rangle$ of the superposition. This is exactly the orthogonality argument from the correctness proof made concrete — the measurement reveals where the error struck without ever distinguishing the $\alpha$-branch from the $\beta$-branch, so no information about $\alpha,\beta$ leaks out and no collapse of the logical superposition occurs. Now contrast with a double error: suppose instead $X_1$ and $X_2$ both strike. Then $|000\rangle \to |110\rangle$ and $|111\rangle\to|001\rangle$, giving $\tfrac{1}{\sqrt2}(|110\rangle+|001\rangle)$. Checking parities: $a_1 = 1\oplus1=0$ and $0\oplus0=0$ (consistent, $s_1=0$); $a_2=1\oplus0=1$ and $0\oplus1=1$ (consistent, $s_2=1$). Syndrome $(0,1)$ — the table says "qubit 2 (index 2) was flipped," so recovery applies $X$ to $q_2$, giving $\tfrac{1}{\sqrt2}(|111\rangle+|000\rangle)$ up to relabeling — but wait, tracing through carefully: $X_2$ applied to $|110\rangle$ gives $|111\rangle$ and to $|001\rangle$ gives $|000\rangle$, yielding $\tfrac{1}{\sqrt2}(|111\rangle+|000\rangle) = |\psi_L\rangle$. In this particular case the double error happens to be corrected — but this is a coincidence of this specific pair; in general, a double bit-flip $X_iX_j$ is indistinguishable from a single flip $X_k$ on the third qubit and the "correction" instead applies $X_k$, producing $X_iX_jX_k|\psi_L\rangle = X_1X_2X_3|\psi_L\rangle$, which equals the logical $X_L$ operator and swaps $\alpha\leftrightarrow\beta$ — a full logical error. This illustrates precisely why the code's guarantee is limited to at most one physical bit-flip per round.

The three-qubit bit-flip code marks the moment quantum error correction stopped being a theoretical impossibility and became an engineering blueprint.

Every current effort to build a fault-tolerant quantum computer relies on the same conceptual skeleton first exhibited by the three-qubit code: encode redundantly, extract syndromes without measuring logical information, and correct. Google's and IBM's superconducting qubit programs run repetition codes — direct multi-qubit generalizations of this bit-flip code — as calibration and demonstration experiments for logical error suppression. Trapped-ion platforms (Quantinuum, IonQ) and neutral-atom arrays (QuEra, Pasqal) similarly benchmark syndrome-extraction cycles using small stabilizer codes derived from this exact template. Beyond hardware demonstrations, the three-qubit code is the pedagogical entry point to the entire modern theory of fault tolerance. The Knill–Laflamme correctability conditions it satisfies generalize directly to arbitrary Stabilizer Codes, including the surface code that underlies most large-scale fault-tolerant architecture roadmaps today. Its natural extension, combining bit-flip and phase-flip protection, is precisely Shor's original nine-qubit code — the historical proof that quantum computation can, in principle, be made arbitrarily reliable despite continuous, uncontrollable noise.

Ask the tutor: How would you modify this code and its circuit to correct a phase-flip (Z) error instead of a bit-flip?