Case Study: Why You Cannot Just Copy the Qubit

Executive Summary

Classical error correction is conceptually simple: store three copies, take a majority vote. Every engineer's first instinct on hearing about quantum errors is to do the same thing, and the instinct fails for three independent reasons, each of which teaches something about why quantum error correction had to be invented rather than adapted.

This case study attempts the naive approach, watches it fail three distinct ways, and then constructs the three-qubit code that works — showing precisely which feature of the failed approach each fix replaces.

Skills applied

• Proving the no-cloning theorem and applying it (§22.10).
• Recognizing measurement-induced collapse as a design constraint.
• Understanding phase errors as invisible to bit-flip codes.
• Constructing syndrome measurements that avoid collapsing the logical state.

Attempt 1: Copy the qubit

The plan: given $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$, make copies $|\psi\rangle|\psi\rangle|\psi\rangle$ and majority-vote.

Why it fails. No unitary can perform $|\psi\rangle|0\rangle \mapsto |\psi\rangle|\psi\rangle$ for arbitrary $|\psi\rangle$. Suppose $U$ did. Then for two states $|\psi\rangle, |\phi\rangle$:

$$\langle\psi|\phi\rangle = \langle\psi|\langle 0|U^\dagger U|\phi\rangle|0\rangle = \langle\psi|\phi\rangle^2$$

using unitarity. So $x = x^2$, forcing $\langle\psi|\phi\rangle \in \{0, 1\}$ — the states must be identical or orthogonal. A cloner working on arbitrary states cannot exist.

The no-cloning theorem is a two-line consequence of unitarity. It is not a technological limitation and will not be engineered around.

What CNOT actually does. The obvious circuit — CNOT from the data qubit onto two ancillas — produces

$$\alpha|000\rangle + \beta|111\rangle$$

which is not $|\psi\rangle^{\otimes 3} = (\alpha|0\rangle+\beta|1\rangle)^{\otimes 3}$. It is an entangled state, not three copies. Measuring one qubit collapses all three.

This turns out to be the useful thing rather than the disappointing thing — but it is not copying.

Attempt 2: Measure the copies and vote

The plan: accept the entangled state above, measure all three qubits, take the majority.

Why it fails. Measurement in the computational basis returns 000 or 111 with probabilities $|\alpha|^2, |\beta|^2$ — and destroys the superposition. You have recovered a classical bit, correctly, and lost the quantum information entirely.

For a computation this is fatal: the logical qubit was in a superposition that the algorithm depends on, and error correction has just collapsed it.

Design constraint discovered. Whatever we measure must reveal the error without revealing the state.

Attempt 3: The three-qubit bit-flip code

The fix: measure parities, not qubits.

Encode $|\psi_L\rangle = \alpha|000\rangle + \beta|111\rangle$. Measure two stabilizers using ancillas:

$$S_1 = Z_1Z_2, \qquad S_2 = Z_2Z_3$$

data q0 ──●───────
          │
data q1 ──X───●───
              │
data q2 ──────X───

anc a0 ───────────  measure Z1Z2
anc a1 ───────────  measure Z2Z3

Each stabilizer answers "do these two qubits agree?" — a question whose answer is identical for the $|000\rangle$ and $|111\rangle$ branches. Because both branches give the same syndrome, measuring it does not distinguish them, so the superposition survives.

Apply the indicated $X$ and the state is restored, still coherent, still unmeasured.

This is the central trick of QEC: stabilizers commute with the logical operators, so measuring them extracts error information while leaving logical information untouched.

Attempt 4: A phase error arrives

Apply $Z_1$ to the encoded state:

$$\alpha|000\rangle + \beta|111\rangle \ \longrightarrow\ \alpha|000\rangle - \beta|111\rangle$$

Measure the stabilizers: $Z_1Z_2 = +1$, $Z_2Z_3 = +1$. Syndrome clean. The code reports no error.

But the logical state is now wrong — a logical $Z$ has been applied. The bit-flip code is completely blind to phase errors.

Third failure. Classical codes only face bit flips. Quantum codes face bit flips and phase flips, and a code protecting against one may offer zero protection against the other.

The resolution: concatenation

Protect against phase errors by encoding in the conjugate basis:

$$|+_L\rangle = |{+}{+}{+}\rangle, \qquad |-_L\rangle = |{-}{-}{-}\rangle$$

with stabilizers $X_1X_2$ and $X_2X_3$. This corrects phase flips and is blind to bit flips — the mirror image.

Shor's 9-qubit code concatenates the two: encode each qubit of the phase-flip code into a three-qubit bit-flip block. The result corrects any single-qubit error, at a cost of 9 physical qubits per logical qubit.

What each failure taught

Every real quantum code — Steane, surface, colour, qLDPC — respects all three constraints. They are not design choices; they are the boundary conditions the physics imposes.

Discussion Questions

1. The no-cloning proof takes two lines from unitarity. Why does that make it stronger than an engineering limitation?
2. Stabilizers give the same value on both logical branches. Explain why that is exactly the condition for preserving superposition.
3. The bit-flip code has a clean syndrome under $Z_1$. What does "clean syndrome, wrong state" mean for a code designer?
4. The 5-qubit code is provably minimal for correcting arbitrary single-qubit errors. Why can't 4 qubits suffice? (Consider counting syndromes against errors.)

Your Turn: Extensions

• Implement the three-qubit bit-flip code, inject each single-qubit $X$, and verify the syndrome table.
• Apply $Z_1$ and confirm the syndrome stays clean while the logical state is corrupted.
• Build the phase-flip code by conjugating with Hadamards and verify its complementary behaviour.
• Implement Shor's 9-qubit code and verify it corrects $X$, $Y$, and $Z$ on any single qubit.

Key Takeaways

• No-cloning follows in two lines from unitarity, so classical copy-and-vote redundancy is unavailable in principle.
• CNOT-based "copying" produces an entangled block, not copies — and that entanglement is the resource QEC actually uses.
• Measuring data qubits destroys the superposition; stabilizer (parity) measurements extract error information while leaving logical information intact.
• Quantum errors come in two types, and a code protecting against bit flips can be entirely blind to phase flips.
• Every real quantum code satisfies all three constraints simultaneously; they are boundary conditions from physics, not design preferences.