Classical computers guard against errors the obvious way: keep three copies of every bit and take a majority vote. Quantum information seems to slam the door on that plan twice over. You cannot copy an unknown qubit — the no-cloning theorem forbids it — and even if you could, reading a qubit to check it for errors collapses the very superposition you were trying to protect. So how can you ever repair a quantum state you are not allowed to look at? The three-qubit bit-flip code is the first, and cleanest, answer — the "hello world" of quantum error correction. Its trick is to measure the error without ever measuring the message.

Encoding: spread one qubit across three

We want to protect a single logical qubit in an unknown state |\psi\rangle = \alpha|0\rangle + \beta|1\rangle. Take two blank helper qubits in |0\rangle and apply two CNOT gates, both controlled by our data qubit, targeting each helper in turn. The result is the encoded (or logical) state

The two logical basis states are now |0_L\rangle = |000\rangle and |1_L\rangle = |111\rangle. Notice what did not happen: this is not three copies of |\psi\rangle. Three copies would be the product |\psi\rangle|\psi\rangle|\psi\rangle, which multiplies out to eight terms; here we have only two, |000\rangle and |111\rangle. The three qubits are entangled, not duplicated — no single qubit on its own carries \alpha or \beta. We have not dodged no-cloning; we have spread the information out so that a single mishap can be voted down.

Worked example 1: running the encoder

Start with the data qubit in |\psi\rangle and two helpers in |0\rangle, i.e. the three-qubit state

Step 1 — CNOT from qubit 1 onto qubit 2. Each term flips its second bit exactly when the first bit is 1. The \alpha term (|000\rangle) is untouched; the \beta term (|100\rangle) becomes |110\rangle:

Step 2 — CNOT from qubit 1 onto qubit 3. Again only the \beta term has a 1 in the control, so its third bit flips too:

Two gates, and the logical qubit is safely spread across three physical ones. The amplitudes \alpha, \beta rode along untouched — we never learned or disturbed them.

Detecting a flip without looking at the data

Suppose noise flips one qubit — say a stray bit-flip (an X error) lands on qubit 2, turning our encoded state into \alpha|010\rangle + \beta|101\rangle. We must not measure the data qubits to find out — that would reveal (and destroy) \alpha and \beta. Instead we ask two relative questions that never mention the actual values:

• Do qubits 1 and 2 agree? This is the parity check Z_1 Z_2.
• Do qubits 2 and 3 agree? This is the parity check Z_2 Z_3.

Each check has outcome +1 when the two qubits agree and -1 when they disagree. We extract it by CNOT-ing the two data qubits onto a fresh ancilla qubit and then measuring only the ancilla. Writing each result as a bit — 0 for "agree", 1 for "the check fired" — the pair (s_1\, s_2) is called the syndrome. Because a single flip changes exactly which neighbours disagree, the syndrome pins down the culprit:

Here is the whole circuit — encode, then extract the two parities onto ancillas a_1, a_2, then measure only the ancillas. Step through it:

Worked example 2: catch and fix a flip on qubit 2

Our state after the flip is \alpha|010\rangle + \beta|101\rangle. Run the two parity checks on each branch of the superposition:

• |010\rangle: bits are 0,1,0. Qubits 1&2 differ (Z_1 Z_2 = -1); qubits 2&3 differ (Z_2 Z_3 = -1).
• |101\rangle: bits are 1,0,1. Qubits 1&2 differ (Z_1 Z_2 = -1); qubits 2&3 differ (Z_2 Z_3 = -1).

Both branches give the same answer, (-1, -1). That is the whole magic: since the syndrome is identical on the \alpha and \beta parts, measuring it tells us only the error and leaves the superposition \alpha \,|\cdot\rangle + \beta\, |\cdot\rangle intact. The ancillas report the syndrome

We apply the correction X to qubit 2, flipping its middle bit back:

The original encoded state is restored — \alpha and \beta exactly as they were, never once observed.

Why the ancilla trick works

If you measured a data qubit directly you would project it to a definite |0\rangle or |1\rangle with probabilities |\alpha|^2, |\beta|^2 — you would learn a bit of the message and shatter the superposition. The parity checks sidestep this because Z_1 Z_2 and Z_2 Z_3 ask only whether qubits match, a question whose answer is the same for |000\rangle and |111\rangle (both "all agree"). So on the clean code the syndrome is 00 regardless of \alpha, \beta; a single flip shifts it to one of the three non-zero patterns, and every branch of the state shifts together. The measurement collapses the error onto a definite value while the encoded amplitudes ride through untouched.