Three-Qubit Phase-Flip Code

The phase-flip code long ago left the textbook and became the working model for the noise that dominates real hardware. Superconducting transmons, semiconductor spin qubits, and many trapped-ion encodings share a stark asymmetry: their dephasing time $T_2$ is far shorter than their relaxation time $T_1$, so phase errors arrive first and fastest, making a phase-protecting repetition code the natural first line of defence. Google Quantum AI's 2021 demonstration of exponential error suppression ran exactly these one-dimensional bit-flip and phase-flip repetition codes, watching the logical error fall as more physical qubits were added; their later surface-code experiments treat the two-basis stabilizer readout as $X$-type and $Z$-type checks that are direct descendants of $X_1X_2,X_2X_3$ and $Z_1Z_2,Z_2Z_3$. The idea has also become a design principle for hardware. "Biased-noise" qubits — Kerr-cat and dissipative-cat qubits built from driven superconducting oscillators — are engineered so that bit flips are exponentially suppressed at the physical level, leaving phase flips as essentially the only residual error. For such a qubit a phase-flip repetition code alone suffices for the top layer, and Amazon's 2025 "Ocelot" chip is built around cat qubits protected exactly this way, cutting the overhead of fault tolerance dramatically. The open problem the code still frames is the one Shor posed: how to stay below the fault-tolerance threshold with realistic, biased, correlated noise — where knowing which basis your errors live in is worth more than raw redundancy.

Picture three qubits, each casting a $\pm$ vote in the conjugate basis. The logical information is carried by the common sign pattern — all-plus is $|0_L\rangle$, all-minus is $|1_L\rangle$ — while a superposition $\alpha|0_L\rangle+\beta|1_L\rangle$ keeps the two patterns coherently overlaid. A single $Z$ error flips exactly one vote, breaking the unanimity. Error correction must detect the disagreement without ever asking any qubit for its absolute vote, which would collapse the superposition and destroy $\alpha,\beta$. Measuring the relative signs of neighbouring pairs — the $X$-parities $X_1X_2$ and $X_2X_3$ — does exactly this: each returns $+1$ if its pair agrees and $-1$ if it disagrees, pinning down the odd one out while learning nothing about the shared value. The first figure follows this through the encoder that prepares the votes.

The whole code is the bit-flip code seen through a Hadamard lens, and it corrects only $Z$. That makes it half of a complete scheme: stack it on top of the bit-flip code — so each $\pm$ vote is itself a bit-flip-protected triple — and the remaining $X$ gap closes. That two-layer stack is precisely Shor's nine-qubit code. But "cheap protection" is only worth having if it actually lowers the error rate, and it does so only up to a point. The second figure is the ledger every code must satisfy: the encoded logical error $p_L=3p^2-2p^3$ against the bare physical rate $p$, showing the quadratic suppression at small $p$ and the break-even crossing where redundancy stops helping.

The two logical codewords are the all-plus and all-minus strings in the conjugate basis. They are the images of the bit-flip codewords $|000\rangle,|111\rangle$ under a Hadamard on every qubit, and they span the two-dimensional code space in which one logical qubit lives.

where: $|\pm\rangle=\tfrac{1}{\sqrt2}(|0\rangle\pm|1\rangle)$ — the eigenstates of $X$ with eigenvalue $\pm1$; $|0_L\rangle,|1_L\rangle$ — the logical basis of the encoded qubit. Reading: the two codewords are the $\pm1$ eigenstates of $X^{\otimes3}$, maximally spread over the Hadamard basis rather than the computational one. Encoding is a coherent map, not a copy. An arbitrary input qubit is carried into the code space with its amplitudes intact — no-cloning is respected because what is triplicated is the basis, not the unknown numbers $\alpha,\beta$.

where: $\alpha,\beta$ — input amplitudes with $|\alpha|^2+|\beta|^2=1$. Reading: the superposition is preserved and delocalized; measuring any single qubit would project it and destroy the encoded state, which is exactly why recovery must use stabilizers instead. The stabilizer group is the set of Pauli operators that fix every codeword. Its two generators are $X$-type parity checks — the conjugate-basis analogue of the bit-flip code's $Z$-type checks.

where: $X_iX_j$ — Pauli $X$ on qubits $i,j$ and identity elsewhere, a parity check in the $\pm$ basis; $S$ — the abelian group with $S|\psi_L\rangle=+|\psi_L\rangle$ for every stabilizer $S$ and codeword $|\psi_L\rangle$. Reading: both generators return $+1$ on any codeword because each pair of votes agrees; an error that disagrees with a generator flips its sign to $-1$. The logical operators act within the code space, mapping codewords to codewords. They commute with every stabilizer but lie outside $S$, and they anticommute with each other as a logical Pauli pair must.

where: $\bar X$ — the logical bit flip, $|{+}{+}{+}\rangle\leftrightarrow|{-}{-}{-}\rangle$; $\bar Z$ — the logical phase flip, realized by any single $X_i$ up to a stabilizer. Reading: note the reversal — a single physical $X_i$ is the logical $\bar Z$, which is why one bit flip is uncorrectable and the distance against $X$ noise is $d=1$. The entire construction is fixed by one line of Clifford algebra: the Hadamard swaps $X$ and $Z$ by conjugation. This is the exact map from the bit-flip code, and every feature of this code is the $X\leftrightarrow Z$ image of a bit-flip feature.

where: $U_{\text{bit}}$ — the bit-flip encoder (two CNOTs from qubit 1 onto 2 and 3); $H^{\otimes3}$ — a Hadamard on each qubit. Reading: conjugation is an isomorphism of the whole apparatus, so codewords, stabilizers, syndromes, and distance all transport under $X\leftrightarrow Z$ with no independent work. Error detection measures the two generators, returning a two-bit syndrome. Each $Z_i$ anticommutes with exactly those generators that overlap it on a single site, so the syndrome is a distinct nonzero fingerprint for each single-qubit phase flip.

where: $s_1,s_2$ — the $\pm1$ outcomes of the two stabilizer measurements; $Z_i$ — a phase flip on qubit $i$. Reading: the four cases $\{I,Z_1,Z_2,Z_3\}$ map to four distinct syndromes, so a lone phase flip is always located and undone by re-applying $Z_i$. Finally, with independent per-qubit phase flips the majority-vote decoder fails only when two or three qubits flip. Summing those events gives the logical error rate, quadratically smaller than the physical rate at low $p$.

where: $p$ — per-qubit phase-flip probability; $p_L$ — probability the decoder yields a residual logical $\bar Z$. Reading: for small $p$, $p_L\approx3p^2\ll p$, and encoding wins whenever $3p^2-2p^3<p$, i.e. for all $p<1/2$.

How the code behaves as the noise channel and the physical rate are varied:

1 · A full correction cycle on a phase-flipped superposition (fully worked)

An encoded state $|\psi_L\rangle=\tfrac{1}{\sqrt2}|{+}{+}{+}\rangle+\tfrac{1}{\sqrt2}|{-}{-}{-}\rangle$ (that is, $\alpha=\beta=1/\sqrt2$) suffers a phase flip on qubit 3. Work out the corrupted state, both syndrome bits, the decoded location, and confirm exact recovery.

Step 1. Apply the error. $Z_3$ flips the third label of each branch: $|\psi'\rangle=\tfrac{1}{\sqrt2}|{+}{+}{-}\rangle+\tfrac{1}{\sqrt2}|{-}{-}{+}\rangle$. The logical amplitudes are still $1/\sqrt2$ each — the error has not touched them, only the sign pattern.

Step 2. Measure $X_1X_2$. On $|{+}{+}{-}\rangle$ the first two eigenvalues are $(+1)(+1)=+1$; on $|{-}{-}{+}\rangle$ they are $(-1)(-1)=+1$. Both branches agree, so $s_1=+1$.

Step 3. Measure $X_2X_3$. On $|{+}{+}{-}\rangle$: $(+1)(-1)=-1$; on $|{-}{-}{+}\rangle$: $(-1)(+1)=-1$. Both agree, so $s_2=-1$. The syndrome is $(+,-)$.

Step 4. Decode. From the table in equation (6), $(+,-)$ is the unique fingerprint of $Z_3$. Apply $Z_3$: $Z_3|\psi'\rangle=\tfrac{1}{\sqrt2}|{+}{+}{+}\rangle+\tfrac{1}{\sqrt2}|{-}{-}{-}\rangle=|\psi_L\rangle$. The state is recovered exactly, and the balanced superposition $\alpha=\beta=1/\sqrt2$ was never disturbed — both branches returned identical syndrome bits, so the logical information survived the measurement untouched.

2 · Is encoding worth it at $p=0.10$?

Independent phase flips strike each physical qubit with probability $p=0.10$. Compute the logical error, compare to the unencoded qubit, and state the margin to break-even.

Step 1. Unencoded, a lone qubit fails with probability $p=0.10$.

Step 2. Encoded, from equation (7): $p_L=3p^2-2p^3=3(0.01)-2(0.001)=0.030-0.002=\mathbf{0.028}$.

Step 3. The ratio is $0.10/0.028\approx\mathbf{3.6}$: encoding cuts the error roughly $3.6$-fold. Since $0.10<1/2$ we are comfortably on the winning side of the threshold; the margin shrinks as $p$ climbs toward $1/2$, where the advantage vanishes. At $p=0.10$ the phase-flip code lowers the logical error from $0.10$ to $0.028$.

The phase-flip code has no single "discoverer" the way a natural constant does, but it entered the world inside one landmark paper. In 1995 Peter Shor showed that a qubit could be shielded from decoherence at all — and the phase-flip repetition code is the piece of his construction that handles the uniquely quantum half of the problem.

Texts. Nielsen & Chuang, Quantum Computation and Quantum Information, §10.1.2 (the three-qubit codes) · Preskill, Lecture Notes for Physics 219, Ch. 7 · Gottesman, Stabilizer Codes and Quantum Error Correction (PhD thesis, 1997) · Mermin, Quantum Computer Science, Ch. 5 · Kitaev, Shen, Vyalyi, Classical and Quantum Computation, Ch. 14 · Lidar & Brun (eds.), Quantum Error Correction, Ch. 2. The code first appears as the outer layer of Shor's 1995 nine-qubit construction (Phys. Rev. A 52, R2493). Key consistency checks: (i) $H|0\rangle=|+\rangle$, $H|1\rangle=|-\rangle$ and $HZH=X$ confirm the encoding map and stabilizer images; (ii) the syndrome table follows from evaluating $X_iX_j$ eigenvalues on $Z_k$-corrupted codewords via $X|\pm\rangle=\pm|\pm\rangle$; (iii) $p_L=3p^2-2p^3$ follows from $\binom{3}{2}=3$ and $\binom{3}{3}=1$, with break-even condition $(2p-1)(p-1)>0\Rightarrow p<1/2$; (iv) $\bar X=Z_1Z_2Z_3$ commutes with both generators by even overlap, and anticommutes with $\bar Z=X_1$.

Prerequisites. Three-Qubit Bit-Flip Code · Pauli Group and Clifford Group · Quantum Error Model and Decoherence Channels · Stabilizer Formalism. Leads to. Shor Nine-Qubit Code · Discretization of Errors · CSS Codes · Syndrome Measurement and Decoding.

Ask the tutor: Ask me to walk a corrupted codeword through the full syndrome table, or to nest this code inside the bit-flip code and watch Shor's nine-qubit code emerge layer by layer.