3-Qubit Bit-Flip Code

In 1995, Peter Shor was trying to prove that large-scale quantum computation was hopeless. Every noise source — a stray magnetic field, a thermal vibration, a photon from the environment — would accumulate errors at a rate that seemed to swamp any possible computation. Classical error correction, via repetition, could not be imported: you cannot copy a qubit, you cannot measure it without collapse, and the errors are continuous. The walls, as discussed in why QEC is hard, were three and tall.

Shor's great insight was that those walls had doors. A qubit can be encoded, not copied. A parity can be measured without revealing the state it is a parity of. And a continuous error collapses onto a discrete one the moment you measure. His 1995 paper — Scheme for reducing decoherence in quantum computer memory — demonstrated all three ideas in a single construction: the 9-qubit code. The 3-qubit bit-flip code is the simplest piece of that construction, isolated for pedagogical clarity. It protects against one specific kind of error — a Pauli X on a single physical qubit — and the protection is exact.

This chapter builds the code from scratch. You will see the encoding circuit and understand why it is not cloning. You will trace a bit-flip error through the syndrome measurement and verify by hand that the logical amplitudes survive. You will compute the failure probability and compare it to the classical repetition code. And you will see the honest limitation — that Z errors slip straight through — which motivates the phase-flip and Shor's codes that follow.

The encoding — one qubit into three, via two CNOTs

The bit-flip code encodes one logical qubit into three physical qubits. The two codewords (the "logical |0\rangle" and "logical |1\rangle") are

A superposition \alpha|0\rangle + \beta|1\rangle encodes to

The encoding circuit is almost embarrassingly simple. Start with the data qubit in state \alpha|0\rangle + \beta|1\rangle and two ancilla qubits in |0\rangle. Apply a CNOT with the data qubit as control and ancilla 1 as target; then a CNOT with the data qubit as control and ancilla 2 as target. That is the entire encoder.

Trace through the algebra to see why this works. The initial state is

The first CNOT flips qubit 1 when qubit 0 is |1\rangle. On |000\rangle the control is |0\rangle, so qubit 1 stays |0\rangle; on |100\rangle the control is |1\rangle, so qubit 1 flips to |1\rangle. The state becomes

The second CNOT flips qubit 2 when qubit 0 is |1\rangle. Same argument: |000\rangle is untouched, |110\rangle becomes |111\rangle. Final state:

Why this is not cloning

Every time a student sees this for the first time, the instinct is to say, "So you have made three copies of the data qubit." No, you have not — and the distinction matters. Cloning would produce

which, expanded, has eight basis kets with coefficients \alpha^3, \alpha^2\beta, \alpha^2\beta, \alpha\beta^2, \alpha^2\beta, \alpha\beta^2, \alpha\beta^2, \beta^3. The encoding, by contrast, produces only two basis kets: \alpha|000\rangle + \beta|111\rangle. Why these are different states: the cloned state is a tensor product of three identical factors — every one of the eight three-qubit basis kets appears with the combinatorially appropriate weight. The encoded state is a sum of just the two "consensus" basis kets, with weights \alpha and \beta. Measure the first qubit of the cloned state: you get |0\rangle with probability |\alpha|^2, and the other two qubits are independently in \alpha|0\rangle + \beta|1\rangle each. Measure the first qubit of the encoded state: you get |0\rangle with probability |\alpha|^2, but the other two qubits are now perfectly correlated — both in |0\rangle. The encoded state's three qubits are entangled, not independent.

This distinction is the first insight that made quantum error correction possible. Copying is forbidden; entangling is allowed and in fact routine. The encoding circuit uses only unitary operations (initialisation and CNOTs), which quantum mechanics permits. The output is a single three-qubit entangled state, and all the "redundancy" that protects the logical bit lives in the correlations between the three physical qubits, not in any individual qubit.

The error model — a single bit-flip

Suppose each of the three physical qubits independently suffers a bit-flip (X) error with probability p. This is the independent bit-flip channel — an idealisation that captures the dominant error mode in many physical qubit implementations (spin flips, T1 decay on certain platforms). The eight possible error events and their probabilities are:

• Nothing happens (I \otimes I \otimes I): probability (1-p)^3.
• X on qubit 0 only: probability p(1-p)^2.
• X on qubit 1 only: probability p(1-p)^2.
• X on qubit 2 only: probability p(1-p)^2.
• X on qubits 0 and 1: probability p^2(1-p).
• X on qubits 0 and 2: probability p^2(1-p).
• X on qubits 1 and 2: probability p^2(1-p).
• X on all three: probability p^3.

The code is designed to correct the four low-weight events — no error, or a single error on one of the three qubits. It cannot correct the multi-qubit events, but those have probability O(p^2) or O(p^3), so for small p they are rare.

Write out what happens to the encoded state under each of the four correctable error events.

Each single-qubit X error takes the state out of the code space — the two-dimensional subspace spanned by |000\rangle and |111\rangle — and into a different two-dimensional subspace. The four subspaces (one for no error, three for each single-qubit flip) are orthogonal and together span a large chunk of the eight-dimensional three-qubit Hilbert space. The plan is: detect which subspace the state is in, without measuring where in that subspace — and then apply the correction that maps it back.

Syndrome measurement — parity, not identity

Here is the trick. Rather than measure each qubit individually (which would collapse the superposition), measure two parity operators whose eigenvalues identify the error subspace but do not reveal \alpha or \beta.

The two parity operators for the bit-flip code are

Z_0 Z_1 is "+1 if qubits 0 and 1 agree, -1 if they disagree"; Z_0 Z_2 is "+1 if qubits 0 and 2 agree, -1 if they disagree". Neither operator reveals the actual values of any qubit — only whether a pair agrees.

Why Z Z measures parity: Z|0\rangle = +|0\rangle and Z|1\rangle = -|1\rangle. Applied to a two-qubit state, ZZ|xy\rangle = (-1)^{x+y}|xy\rangle — +1 if x and y are equal, -1 if different. The eigenvalue (-1)^{x+y} depends only on the parity x \oplus y, not on the individual values. Measuring ZZ projects onto the "same" subspace (eigenvalue +1, spanned by |00\rangle and |11\rangle) or the "different" subspace (eigenvalue -1, spanned by |01\rangle and |10\rangle).

Apply S_1 and S_2 to each of the four post-error states. For the no-error state \alpha|000\rangle + \beta|111\rangle:

• On |000\rangle: Z_0 Z_1 = (+1)(+1) = +1. Z_0 Z_2 = (+1)(+1) = +1.
• On |111\rangle: Z_0 Z_1 = (-1)(-1) = +1. Z_0 Z_2 = (-1)(-1) = +1.

Both basis kets give the same eigenvalues, so the whole superposition is a simultaneous +1 eigenstate of both S_1 and S_2. Measuring either returns +1 deterministically, and leaves the state unchanged. Why the state is unchanged: when you measure an observable on one of its eigenstates, the outcome is certain (the corresponding eigenvalue) and the state after measurement is the same eigenstate — no collapse, no reduction. The encoded superposition \alpha|000\rangle + \beta|111\rangle survives the S_1, S_2 measurement intact.

Now the state after an X_1 error: \alpha|010\rangle + \beta|101\rangle.

• On |010\rangle: Z_0 Z_1 = (+1)(-1) = -1. Z_0 Z_2 = (+1)(+1) = +1.
• On |101\rangle: Z_0 Z_1 = (-1)(+1) = -1. Z_0 Z_2 = (-1)(-1) = +1.

Both kets give (S_1, S_2) = (-1, +1) — again deterministic, the superposition is undisturbed. The error syndrome (-1, +1) uniquely identifies "bit-flip on qubit 1".

Repeat for the other two single-qubit errors. The complete syndrome table is:

Four distinct syndromes, four distinct (correctable) errors. The syndrome tells you exactly which physical qubit flipped, and the \alpha, \beta amplitudes are preserved throughout.

Recovery — one X, and done

After reading the syndrome, you know exactly which physical qubit needs flipping back. Apply the matching X:

• (+, +): do nothing (state is already in the code space).
• (-, -): apply X to qubit 0.
• (-, +): apply X to qubit 1.
• (+, -): apply X to qubit 2.

Since X^2 = I, applying X exactly undoes a previous X on the same qubit. The state returns to \alpha|000\rangle + \beta|111\rangle, and you are back in the code space with the original amplitudes.

To recover the logical qubit as a single physical qubit (for further computation or readout), apply the decoding circuit: the same two CNOTs in reverse order (CNOT 0 \to 2 then CNOT 0 \to 1). The state \alpha|000\rangle + \beta|111\rangle goes back to (\alpha|0\rangle + \beta|1\rangle)|0\rangle|0\rangle — the original data qubit, with the two ancillas returned to |0\rangle. The decoding is exact because the entire encode-error-syndrome-correct cycle has been unitary (plus the syndrome measurement, which returned deterministic results on the eigenstates).

Failure probability and the quadratic suppression

The code corrects any single-qubit X error (four out of eight possible error events). It fails when two or three qubits flip — events with total probability

For small p, P_{\text{fail}} \approx 3p^2. The unprotected qubit has failure probability p; the encoded logical qubit has failure probability \approx 3p^2. For p = 10^{-3}, this drops from 10^{-3} to 3 \times 10^{-6} — a factor-300 improvement.

This is the same quadratic suppression as the classical 3-bit repetition code. The formula is identical. What is quantum about the bit-flip code is how the suppression is achieved — via entangled encoding and parity measurement rather than via copies and direct reads — and what price is paid. The price is: the code only works for X errors. Any Z or Y error passes through undetected and uncorrected.

The honest limitation — Z errors are invisible

Apply a Z error to qubit 0 of the encoded state \alpha|000\rangle + \beta|111\rangle:

The relative phase between |0\rangle_L and |1\rangle_L has flipped: \beta \mapsto -\beta. This is a real error on the logical qubit — it turns |+\rangle_L = (|0\rangle_L + |1\rangle_L)/\sqrt 2 into |-\rangle_L = (|0\rangle_L - |1\rangle_L)/\sqrt 2, a completely different logical state.

Now measure the syndromes on \alpha|000\rangle - \beta|111\rangle:

• S_1 = Z_0 Z_1: on |000\rangle, +1; on |111\rangle, +1. Outcome +1.
• S_2 = Z_0 Z_2: same, outcome +1.

The syndrome is (+, +) — identical to the "no error" syndrome. The bit-flip code has no idea a Z error happened. It would cheerfully declare "no correction needed" and leave the logical state corrupted.

Why the bit-flip code misses Z errors: the syndromes S_1, S_2 are built from Z operators, which commute with any single-qubit Z error. Commuting means they share eigenstates, so applying a Z error does not move the state between S_1/S_2 eigenspaces — and the syndromes report no change. The code detects errors only if they anticommute with at least one syndrome operator. X_i anticommutes with some Z_iZ_j (yes, detected); Z_i commutes with every Z_jZ_k (no, not detected).

This is why the bit-flip code on its own is not a useful quantum code. On real hardware, both X and Z errors occur at comparable rates; correcting only half of them is no better than correcting neither. The bit-flip code is a pedagogical building block, not a production code. The phase-flip code (ch. 117) handles Z errors by running the bit-flip code in the Hadamard-rotated basis. The Shor 9-qubit code (ch. 118) concatenates the two: phase-flip-encode each qubit of a bit-flip encoding, giving a 9-qubit code that corrects any single-qubit Pauli error. From the Shor code onward, quantum error correction becomes genuinely useful.

Worked examples

Why this matters. The 3-qubit bit-flip code is the first worked example of the idea that made large-scale quantum computing conceivable. Every later code — the phase-flip code, the Shor 9-qubit code, the Steane code, the surface code, the colour code — is a refinement of the same four-step template: encode into an entangled subspace, accept errors that knock you out of the subspace, measure parity-like operators to identify the error, apply the matching correction. Shor's 1995 paper was not just a technical construction; it was an existence proof. Once you see the bit-flip code work, the question changes from "is quantum error correction possible?" to "what is the optimal overhead?" — a very different, and much more tractable, question.

Common confusions

• "The code copies the bit." No. Copying would produce (\alpha|0\rangle + \beta|1\rangle)^{\otimes 3}, a state with eight nonzero amplitudes \alpha^3, \alpha^2\beta, \ldots, \beta^3. The encoding produces \alpha|000\rangle + \beta|111\rangle, a state with two nonzero amplitudes. These are different states with different properties. The encoded state's three qubits are entangled; the copied state's three qubits are independent. No-cloning forbids the latter; the encoding circuit produces the former using ordinary unitary gates.

• "Syndrome measurement destroys the superposition." No. The syndrome operators Z_0 Z_1 and Z_0 Z_2 commute with the logical operators X_L = X_0 X_1 X_2 and Z_L = Z_0 Z_1 Z_2 (and hence with any operator on the logical qubit). Commuting observables share eigenstates; measuring a commuting observable does not disturb the state relative to the logical basis. The encoded amplitudes \alpha, \beta are preserved because what is being measured is the error subspace, not the logical subspace.

• "The bit-flip code protects against phase errors." No, it does not. Every Z error on any physical qubit produces the "no error" syndrome (+, +), so the code does not detect Z and does not correct it. Phase protection requires the phase-flip code (ch. 117), which measures X-basis stabilisers, or a combined scheme like Shor's 9-qubit code (ch. 118).

• "Measuring the qubits individually is the same as measuring Z_0 Z_1 and Z_0 Z_2." No, these are fundamentally different. Individual measurements collapse each qubit to a definite |0\rangle or |1\rangle, destroying the superposition \alpha|000\rangle + \beta|111\rangle into one computational-basis state. Parity measurements project onto parity eigenspaces, which each contain both |000\rangle and |111\rangle — so the superposition survives within the parity eigenspace.

• "The code's failure rate of 3p^2 is the same as classical repetition." The formula is identical, yes — and that is not a coincidence. The structure of which error events break the code (any two or three qubits getting the wrong symbol) is the same in both codes. But the mechanism is different: classically, the two-flip event means the majority is wrong; quantumly, the two-flip event means the syndrome points to the wrong qubit, and the "correction" actually makes things worse (it introduces a third error, producing a logical X).

• "Continuous X rotations are undetected because they are small." Not quite. A continuous rotation e^{-i\epsilon X_i} = \cos(\epsilon)I - i\sin(\epsilon)X_i, applied to the encoded state, produces a superposition \cos(\epsilon)|\psi_L\rangle - i\sin(\epsilon) X_i|\psi_L\rangle. When you measure the syndrome, this superposition collapses: with probability \cos^2(\epsilon) you get the "no error" syndrome and the state is exactly |\psi_L\rangle; with probability \sin^2(\epsilon) you get the "error on qubit i" syndrome and the state is exactly X_i|\psi_L\rangle, which the correction fixes. The continuous error discretises to one of two outcomes, each of which the code handles — this is the discretisation theorem in action.

Going deeper

Stabiliser formalism preview

The 3-qubit bit-flip code is the simplest stabiliser code. A stabiliser code is defined by a set of commuting Pauli operators (the stabilisers) whose simultaneous +1 eigenspace is the code space. For this code, the stabilisers are S_1 = Z_0 Z_1 and S_2 = Z_0 Z_2; the code space is the two-dimensional subspace of states that are +1 eigenstates of both — the span of |000\rangle and |111\rangle.

Errors are detected by measuring the stabilisers. An error E is detected iff it anticommutes with some stabiliser — because anticommuting means ES_1 = -S_1 E, so applying E to a +1 eigenstate gives a -1 eigenstate, which the syndrome measurement reveals. X_i anticommutes with Z_j Z_k whenever i \in \{j, k\} — detected. Z_i commutes with every Z_j Z_k — undetected.

The logical operators are Pauli operators that commute with every stabiliser (so they map the code space to itself) but are not themselves stabilisers. For this code, Z_L = Z_0 Z_1 Z_2 is the logical Z (since Z_L|000\rangle = +|000\rangle and Z_L|111\rangle = -|111\rangle, as Z|0\rangle = +|0\rangle and Z|1\rangle = -|1\rangle) and X_L = X_0 X_1 X_2 is the logical X (mapping |000\rangle \leftrightarrow |111\rangle). The full stabiliser formalism is developed in stabilizer formalism intro (ch. 119).

Continuous X errors and discretisation

Suppose a noisy gate applies the unitary U = \exp(-i\theta X_1) — a small-angle rotation about the X axis on qubit 1 — to the encoded state. Then

This is a superposition of the no-error state and the "X on qubit 1" state. When the syndrome is measured:

• With probability \cos^2\theta, the outcome is (+, +); the state collapses to |\psi_L\rangle.
• With probability \sin^2\theta, the outcome is (-, +); the state collapses to X_1|\psi_L\rangle, which the subsequent X_1 correction fixes.

Either way, after correction, the state is |\psi_L\rangle exactly. The continuous error has been projected to one of two discrete outcomes, both of which the code handles. The same argument works for any single-qubit unitary that is a combination of I and X_i: the syndrome discretises it to a "no error" or "X on qubit i" outcome.

For arbitrary single-qubit unitaries involving Y or Z — which the bit-flip code cannot correct — the discretisation still happens (the state collapses onto \{I, X_i, Y_i, Z_i\} eigenspaces), but the Y_i and Z_i outcomes are not in the correctable set and are missed by the bit-flip code. Shor's 9-qubit code enlarges the correctable set to all single-qubit Paulis.

Generalisation to n-qubit repetition

Nothing about the 3-qubit construction is special to the number three. For any odd n, you can define an n-qubit bit-flip code with codewords |0\rangle_L = |0 \cdots 0\rangle (n zeros) and |1\rangle_L = |1 \cdots 1\rangle. The stabilisers are the n - 1 independent parity operators Z_0 Z_1, Z_0 Z_2, \ldots, Z_0 Z_{n-1} (or any maximally independent subset). The code corrects up to \lfloor (n-1)/2 \rfloor simultaneous X errors, with failure probability O(p^{(n+1)/2}) for small p.

The same caveat applies: even large n does not buy any protection against Z errors. Classical information theory happens to live on the bit-flip axis, but quantum mechanics is two-dimensional (any combination of X and Z axes). You cannot escape the need for the phase-flip code — or, more efficiently, the Shor-style concatenation that handles both.

Fault-tolerant syndrome extraction

The account in this article has glossed over a practical issue: you cannot directly "measure Z_0 Z_1" the way you measure a single qubit. In real hardware, you introduce an ancilla qubit in the |0\rangle state, apply two CNOTs (from each of the data qubits to the ancilla), and then measure the ancilla in the computational basis. The ancilla outcome is 0 if the two data qubits agree (parity +1) and 1 if they disagree (parity -1).

The tricky part: if the CNOT gates themselves are noisy, the syndrome extraction can propagate errors between qubits. A single physical error during syndrome extraction can produce a two-qubit error on the data, which the distance-3 code cannot correct. Fault-tolerant syndrome extraction uses specifically engineered ancilla layouts (cat states, Steane-style reflection, flag qubits) to prevent this error propagation.

For the bit-flip code, the simplest fault-tolerant scheme uses two independent ancillas per stabiliser: the first extracts the syndrome, the second catches any error introduced during the first extraction. If the two ancillas disagree, the syndrome is discarded and the measurement is repeated. Real hardware (IBM, Google, Quantinuum) implements such schemes for distance-3 and distance-5 surface codes; the 3-qubit bit-flip code is rarely run on its own, but its logic appears inside every code on modern quantum hardware.

Indian QEC research context

Indian quantum-error-correction research is a real and growing programme within the National Quantum Mission (2023). Active groups include:

• TIFR Mumbai — theoretical work on stabiliser codes, LDPC-style quantum codes, and small experimental demonstrations on NMR platforms in the 2000s and 2010s.
• IIT Madras — collaborations with IBM Quantum Network enabling code-level experiments on IBM superconducting hardware.
• IISc Bangalore — algorithmic research on decoding for surface codes and colour codes.
• Raman Research Institute Bangalore — quantum-optics experiments on photonic qubit error correction.

Early NMR-based demonstrations of error-correcting codes (including the 3-qubit bit-flip code and small Steane-code experiments) were published by Indian groups in the 2000s; the work was important historically for showing QEC works outside theory, even before superconducting and trapped-ion platforms dominated.

Where this leads next

• Classical repetition codes — the classical ancestor of this construction.
• No-cloning theorem — why the encoded state is not three copies.
• Phase-flip code — the Hadamard-rotated cousin that catches Z errors.
• Shor 9-qubit code — concatenate bit-flip and phase-flip to handle any single-qubit error.
• Stabilizer formalism intro — the unifying framework that generalises S_1, S_2 to arbitrary Pauli stabilisers.
• Syndrome measurement — the ancilla-based circuit for implementing S_1, S_2 in real hardware.

References

1. Peter Shor, Scheme for reducing decoherence in quantum computer memory (1995), Physical Review A — arXiv:quant-ph/9508027.
2. Daniel Gottesman, Stabilizer codes and quantum error correction (PhD thesis, 1997) — arXiv:quant-ph/9705052.
3. John Preskill, Lecture Notes on Quantum Computation, Ch. 7 (quantum error correction, with the bit-flip code as opening example) — theory.caltech.edu/~preskill/ph229.
4. Nielsen and Chuang, Quantum Computation and Quantum Information (2010), §10.1–10.2 — Cambridge University Press.
5. Wikipedia, Quantum error correction — overview with explicit discussion of the bit-flip code.
6. Qiskit Textbook, Introduction to Quantum Error Correction using Repetition Codes — runnable code for the 3-qubit bit-flip example.