Gates and Circuits

The no-cloning theorem

You cannot copy an unknown qubit

~10 minLesson 13 of 24Written by Claude Fable 5

Copying is the most unremarkable thing a computer does. Every memcpy, every git clone, every variable assignment duplicates data without a second thought. So it comes as a genuine shock that an unknown qubit is the one piece of information in the universe you provably cannot copy. Not because the hardware is not good enough yet, but because a copier would contradict the linearity of the gates themselves.

The two obvious cloners, and why they fail

Before the proof, dispose of the two schemes everyone reaches for first. Scheme one: measure the qubit and prepare a fresh one in whatever you saw.

To copy an unknown qubit |psi> = a|0> + b|1>, you measure it and prepare a new qubit in the outcome you got. Does that copy |psi>?

Scheme two is subtler: skip measurement and use a CNOT, feeding the unknown qubit as the control and a blank $∣0 ⟩$ as the target, the fan-out trick from the CNOT lesson. For a basis state it works. For a superposition it entangles instead of copying. Play with the exact fidelity gap before we prove it must exist.

Wire an unknown qubit as the control of a CNOT and a blank |0> as the target, the obvious way to duplicate it. Slide the input from a pole toward the equator and watch the copy fall apart.

unknown input |psi> at theta = 90°

The unknown input |psi> on one qubit.

|0>

|1>

step 0/1

What a true copy |psi> tensor |psi> would look like.

|00>

|01>

|10>

|11>

What the CNOT actually outputs: c|00> + s|11>.

|00>

|01>

|10>

|11>

copy fidelity0.500

Off the poles the two states disagree. The CNOT entangles the qubits instead of copying, and the fidelity sags, bottoming out at 0.5 for |+>. No wiring fixes this.

The one-line proof

The says no gate can copy an arbitrary unknown state. Suppose one could: a unitary $U$ that, for every state $∣ ψ ⟩$ , takes the qubit plus a blank into two copies,

U (∣ ψ ⟩ \otimes ∣0 ⟩) = ∣ ψ ⟩ \otimes ∣ ψ ⟩ for all ∣ ψ ⟩ .

Apply it to the two basis states, which it must handle in particular: $U (∣0 ⟩ ∣0 ⟩) = ∣0 ⟩ ∣0 ⟩$ and $U (∣1 ⟩ ∣0 ⟩) = ∣1 ⟩ ∣1 ⟩$ . Now feed it a superposition $∣ ψ ⟩ = a ∣0 ⟩ + b ∣1 ⟩$ . Because $U$ is linear, it distributes over the sum:

U ((a ∣0 ⟩ + b ∣1 ⟩) ∣0 ⟩) = a U (∣0 ⟩ ∣0 ⟩) + b U (∣1 ⟩ ∣0 ⟩) = a ∣00 ⟩ + b ∣11 ⟩ .

But the definition of cloning demands the output be $∣ ψ ⟩ \otimes ∣ ψ ⟩$ , which multiplies out to:

∣ ψ ⟩ \otimes ∣ ψ ⟩ = (a ∣0 ⟩ + b ∣1 ⟩) \otimes (a ∣0 ⟩ + b ∣1 ⟩) = a^{2} ∣00 ⟩ + ab ∣01 ⟩ + ab ∣10 ⟩ + b^{2} ∣11 ⟩ .

Set the two results equal. Linearity gave $a ∣00 ⟩ + b ∣11 ⟩$ ; cloning demands $a^{2} ∣00 ⟩ + ab ∣01 ⟩ + ab ∣10 ⟩ + b^{2} ∣11 ⟩$ . They match only if $ab = 0$ , that is, only if $a = 0$ or $b = 0$ , which means only for the basis states themselves. For any genuine superposition the copier is impossible. That is the whole theorem, and it rests on nothing but linearity.^[1]

The boundary the widget drew

A CNOT copier is not useless, it is exactly right on

∣0 ⟩

and

∣1 ⟩

and wrong everywhere in between, worst at

∣ + ⟩

where the copy fidelity bottoms out at

\frac{1}{2}

. The output there is the entangled

a ∣00 ⟩ + b ∣11 ⟩

, not two separate copies. Cloning works precisely on the states that behave classically and fails precisely where quantumness lives.

Why this is a feature

No-cloning sounds like a limitation, and for error correction it is an obstacle to work around. But it is also the guarantee behind quantum key distribution: an eavesdropper cannot copy the qubits in transit to read them later, because the copy would be imperfect and, worse for them, would disturb the originals in a way the legitimate parties can detect. A classical bit can be silently wiretapped and duplicated; an unknown qubit cannot. Security that rests on a theorem, not on an assumed-hard computation, is a rare and valuable thing.^[2]

import numpy as np

def cnot_copy_fidelity(theta):
    c, s = np.cos(theta / 2), np.sin(theta / 2)
    # desired perfect copy |psi> tensor |psi>
    desired = np.array([c*c, c*s, s*c, s*s])
    # what CNOT(|psi>|0>) actually gives: c|00> + s|11>
    actual = np.array([c, 0, 0, s])
    return abs(desired @ actual) ** 2

cnot_copy_fidelity(0.0)        # 1.0    -> |0>, copies perfectly
cnot_copy_fidelity(np.pi)      # 1.0    -> |1>, copies perfectly
cnot_copy_fidelity(np.pi / 2)  # 0.5    -> |+>, the copy is entanglement, not a clone

The CNOT copier's fidelity to a true copy: perfect on basis states, 1/2 at |+>.

Lock it in

No-cloning: no unitary can copy an arbitrary unknown qubit; it follows from linearity alone, not from hardware limits.
Measure-and-re-prepare fails because measurement collapses the state and hides the amplitudes; a CNOT copier entangles instead of copying.
Cloning works only on the basis states |0> and |1> (fidelity 1) and is worst at |+> (fidelity 1/2), where the output is entangled.
The theorem is a feature: it underpins quantum key distribution, where an eavesdropper cannot copy qubits without disturbing them.

Recall: why can an unknown qubit not be copied, and name one thing no-cloning makes possible.

The linearity argument in one sentence, plus its payoff. Try to state it, then check.

The no-cloning theorem follows most directly from which property of quantum gates?

You try to clone |+> by using it as the control of a CNOT onto a |0> target. What do you actually get?

Match each item to its fact.

drop here

Cannot duplicate an unknown quantum state.

drop here

Freely copyable any number of times.

drop here

Destroys the superposition it reads.

drop here

Security that relies on no-cloning.

Primary source

Quantum Country, Quantum computing for the very curious

The no-cloning section runs the same linearity argument and connects it to why measurement cannot substitute for copying. A tight, well-tested walk-through of the exact reasoning above.

Sources