No-Cloning and Why Copying Breaks Quantum Logic

The copy that linearity forbids

Classical software copies bits constantly — backups, logs, retries, fanout. Quantum information refuses the same treatment. No unitary operation takes an arbitrary unknown state $|\psi ⟩$ and a blank register and returns two copies:

The claim is precise, and its boundaries matter. Known basis states can be duplicated — a CNOT does it. What cannot exist is a universal copier that works on every unknown qubit, because such a machine contradicts the linearity of quantum evolution.

A two-line proof

Suppose a unitary copier U exists, and it handles the basis states as advertised:

Linearity then fixes what U must do to $|+⟩|b⟩$ — it has no choice:

But a genuine clone of $|+⟩$ would be:

The two right-hand sides are different states. The contradiction needs no measurement anywhere; it is arithmetic. A second proof route uses inner products: copying would map the overlap between two states to its square, and squaring preserves overlaps only for states that are identical or orthogonal. That is why a cloner restricted to a known orthogonal basis can exist, and a universal one cannot.

The theorem was proved in 1982 by Wootters and Zurek, and independently by Dieks — remarkably late for a result this elementary. Within a few years it had stopped being a limitation and started being a feature: quantum key distribution (Chapter 26) rests directly on the fact that an eavesdropper cannot copy the unknown states passing through the channel.

Worked example: the missing cross terms

Run the candidate copier on the superposition input explicitly:

Distribute U over the sum — linearity forces this, because gates do not get to peek:

Compare with the target state $|+⟩|+⟩$. The copier's output is missing the $|01⟩$ and $|10⟩$ cross terms — in fact it is a Bell state, entangled rather than duplicated. And notice what did work: for inputs $|0⟩$ and $|1⟩$, the same machine (a CNOT with target 0) copies perfectly. Basis copying is legal; universal cloning is not. The difference is the entire content of the theorem.

Two overreactions to avoid

The first misreading explains no-cloning as "measuring the qubit disturbs it." Measurement disturbance is real, but it is not the theorem: the proof above never measures anything. Even a perfectly gentle, measurement-free copier is impossible. Resting the argument on measurement makes it weaker than the truth.

The second misreading overshoots and concludes that quantum information can never be replicated in any sense. Classical records copied from measurement outcomes replicate fine. Known orthogonal states replicate fine. Quantum error correction spreads one logical qubit's information across many physical qubits — but that is protection, not photocopying: no two of the physical qubits each hold the unknown state.

Programming without a clipboard

For a developer, no-cloning deletes a reflex. You cannot snapshot an unknown intermediate state for backup, logging, retry, or fanout to parallel workers. Quantum programs route around this with reversible transformations, ancillas, uncomputation, and measurements placed only where a classical record is actually wanted.

Debugging changes character too. There is no print statement for an unknown hardware state: reading it changes the experiment. Simulators will happily show you a statevector, but that visibility belongs to the classical model of the computation — it is not an operation the computation itself can perform.

Claims this theorem kills on sight

No-cloning is a diligence filter. Any architecture that quietly assumes backing up unknown qubits, broadcasting one quantum state to many processors, or reading a state without disturbing it is assuming a machine the theorem forbids.

Serious designs show their workaround instead: teleportation with its entanglement budget (Chapter 25), error-correcting codes with their overhead, classical summaries of quantum data, or tomography with its sampling cost. The workaround is usually where the real engineering expense sits, so its absence from a pitch is information too.

Exercise

The proof, both ways. Write the assumed basis-cloning action, apply linearity to $|+⟩|b⟩$, and exhibit the mismatch with $|+⟩|+⟩$. Finish by naming one product or architecture claim that this theorem forces you to question.

• Submit: the linearity result, the full expansion of the desired clone, and the two states side by side with the differing terms marked.
• Check: redo the argument with inner products — show that cloning would square overlaps, and name the two cases where squaring is harmless.
• Repair: if your proof leans on measurement disturbance, or you caught yourself claiming classical bits cannot be copied, rework Chapter 12 (Unitary Operations and Reversibility) and Chapter 20 (Bell States and GHZ States) — the first for linearity, the second for telling entanglement apart from duplication.

Check your understanding

From memory: prove that no universal unitary copier exists, state exactly which copying operations remain legal, and give one engineering consequence of each.

Oral defense: a teammate proposes to "just checkpoint the qubit and restore it if the gate fails." Explain precisely which step the theorem blocks.

If you get stuck

If the boundaries blur — known-basis copying versus unknown-state cloning versus entanglement versus measurement — revisit Chapter 12 (Unitary Operations and Reversibility) for the operator mechanics and Chapter 20 (Bell States and GHZ States) for the entangled output this chapter's copier accidentally produces.