The No-Cloning Obstacle

Classical engineering protects data by copying it. RAID mirrors disks; ECC memory stores extra bits; TCP retransmits packets; you back up your laptop. The recipe is universal: keep several copies, and when one breaks, the others out-vote it.

So the obvious plan for protecting a qubit — a quantum bit holding a superposition, a weighted combination of 0 and 1 whose weights (amplitudes) square to measurement probabilities — is: make three copies, majority-vote later. If that plan worked, quantum error correction would be a footnote.

It does not work, and not because engineers haven't found the right gadget yet. Copying an unknown quantum state is mathematically impossible — the famous no-cloning theorem. This chapter proves it with two lines of algebra you can check by hand, then demonstrates it live: we build the most natural candidate copy machine, run it, and watch the output counts tell us it made something entangled instead of two copies.

Every quantum gate is linear: feed it a weighted sum of inputs and you get the same weighted sum of the outputs. This is not a modeling convenience — it is one of the bedrock rules of quantum mechanics, confirmed everywhere the theory has been tested.

Now suppose some two-qubit machine U copies the basis states onto a blank qubit: U(|0, blank⟩) = |0,0⟩ and U(|1, blank⟩) = |1,1⟩. The CX gate does exactly this for definite values — the control writes its value onto a 0-target; see CNOT and controlled operations. Feed it the superposition |+⟩ = 0.70711·(|0⟩+|1⟩), and linearity leaves no freedom at all:

1. U(|+, blank⟩) = 0.70711·U(|0, blank⟩) + 0.70711·U(|1, blank⟩) = 0.70711·|00⟩ + 0.70711·|11⟩.
2. But a true copy would be two independent |+⟩ qubits written side by side, and independent qubits combine by multiplying their weights — each of the four outcomes gets amplitude 0.70711 × 0.70711 = 0.5 — so a true copy would be |+⟩|+⟩ = 0.5·|00⟩ + 0.5·|01⟩ + 0.5·|10⟩ + 0.5·|11⟩.

Compare the |00⟩ amplitudes: 0.70711 versus 0.5. Compare the |01⟩ amplitudes: 0 versus 0.5. These are different states — so U copied the basis states but failed on their superposition. Any linear machine fails the same way; Wootters and Zurek proved the general version in 1982: no device can clone unknown, non-orthogonal states (non-orthogonal means the states overlap, like |0⟩ and |+⟩ — pairs no measurement can reliably tell apart; perfectly distinguishable states such as |0⟩ versus |1⟩ are the one case a copier can handle, which is just classical copying). What linearity produced instead — 0.70711·(|00⟩+|11⟩) — is a Bell pair: the qubits are entangled, correlated so strongly that neither has a definite state of its own (see entanglement).

Put the two distributions side by side, computing each probability as amplitude squared:

• CX "copy": P(00) = 0.70711² = 0.500, P(11) = 0.500, P(01) = P(10) = 0² = 0.
• True copies |+⟩|+⟩: P = 0.5² = 0.25 for each of the four outcomes.

In 1000 shots the first machine gives roughly 500 / 0 / 0 / 500 and the second roughly 250 / 250 / 250 / 250. You cannot mistake one for the other — the missing 01 and 10 outcomes are the experimental fingerprint of entanglement standing exactly where copies were supposed to be.

Two subtleties worth being precise about. First, copying known states is allowed and easy — we just did it by running H twice; a copier for states you already know how to prepare is just preparation. The impossibility bites only for a state handed to you unlabeled. Second, you cannot rescue the copier by peeking first: measurement collapses a superposition to a single outcome and destroys the amplitudes you were trying to preserve — the weights 0.70711 are simply gone after one look. Unknown, unmeasurable, uncopyable: that is the bind error correction must escape.

Here is the escape. Look again at what the CX actually built: 0.70711·(|00⟩+|11⟩). It is not two copies — but it is a kind of redundancy. The logical value is now written into the correlation between the qubits rather than into either qubit alone. Damage one qubit and the correlation pattern changes in a detectable way — detectable, it will turn out, without ever reading the protected data itself.

Extend the same move to three qubits and a general state: α|0⟩ + β|1⟩ (the Greek letters α and β naming the two amplitudes, whatever values they happen to hold) becomes α|000⟩ + β|111⟩ (two CX gates, built in full next chapter). Note carefully what this is not: it is not three copies — three copies would be (α|0⟩+β|1⟩) taken three times over, which no-cloning forbids for unknown α and β. Instead, one logical qubit is smeared across three physical ones. Each individual qubit, examined alone, shows only a biased coin — |α|² heads, |β|² tails — and reveals nothing about the phase relationship between α and β. The information lives in the trio jointly, the same three-way correlation structure explored in GHZ states and correlations.

So the corrected slogan for quantum redundancy: don't copy — spread. Entanglement, the very phenomenon that broke our copy machine, is the resource that replaces copying.

No-cloning is not an abstract inconvenience — it dictates real engineering constraints on every platform in our QPU index:

• No checkpoints. A classical program can snapshot its memory and roll back on failure. A quantum program cannot: saving a mid-run copy of the state is exactly what the theorem forbids. Once a run goes wrong, you re-run from scratch — one reason result statistics, not single shots, are the working currency of quantum computing.
• No peeking either. The obvious alternative — measure mid-run "just to check" — destroys the superposition it inspects. Readout on real devices is a destructive and error-prone event in its own right; see readout fidelity.
• No quantum signal boosters. Classical networks work because repeaters copy and amplify bits along the way. Qubits in flight cannot be amplified that way, which is why long-distance quantum links remain a genuinely hard, active research problem rather than a deployment detail.

Every error-correction scheme on every architecture — superconducting, trapped-ion, neutral-atom; see physical vs logical qubits — is built on the spread-don't-copy principle you just verified in the counts.