foundations beginner · 13 min read · By LIPAI WANG · April 29, 2026

The No-Cloning Theorem: Why Quantum Information Cannot Be Copied

The no-cloning theorem (Wootters-Zurek 1982; Dieks 1982) is the structural reason quantum information behaves differently from classical bits. There is no unitary operation that takes an unknown qubit and outputs two identical copies. This single result underlies quantum error correction's complexity, quantum cryptography's security, and the impossibility of quantum signal repeaters that simply amplify their input. This tutorial proves the theorem in three lines and walks through its consequences.

Prerequisites: Tutorial 1: What Is a Qubit

If you give me a classical bit — a $0$ or a $1$ — I can copy it. Trivially: read the value, write it down twice. Most of computing is built on this assumption: data flows through processors and across networks because copies of data can be made and distributed at will.

Quantum information is structurally different. There is no operation that takes an unknown qubit and produces two identical copies of it. This is the no-cloning theorem (Wootters-Zurek 1982; Dieks 1982). The proof is three lines of linear algebra. The consequences shape the entire architecture of quantum computing and quantum communication: error correction must work without making backup copies, cryptography can rest on the unforgeability of quantum states, and quantum signals cannot be simply amplified by a “quantum repeater” that copies and forwards.

This tutorial proves the theorem cleanly, explains the consequences, and shows why no-cloning is the structural reason quantum information has the security and difficulty properties it does.

The theorem

No-cloning theorem. There is no quantum operation $U$ such that for every qubit state $|\psi\rangle$,

$$U \bigl( |\psi\rangle \otimes |0\rangle \bigr) \;=\; |\psi\rangle \otimes |\psi\rangle.$$

In words: there is no machine that takes an unknown quantum state $|\psi\rangle$ on the first qubit and an “ancilla” state $|0\rangle$ on the second qubit, and produces two identical copies of $|\psi\rangle$.

The three-line proof

Suppose, for contradiction, that such a unitary $U$ exists. Then for two specific qubit states, say $|0\rangle$ and $|1\rangle$:

$$U(|0\rangle \otimes |0\rangle) = |0\rangle \otimes |0\rangle, \qquad U(|1\rangle \otimes |0\rangle) = |1\rangle \otimes |1\rangle.$$

Now consider an arbitrary superposition $|\psi\rangle = \alpha |0\rangle + \beta |1\rangle$. By linearity of $U$:

$$U(|\psi\rangle \otimes |0\rangle) \;=\; \alpha \, U(|0\rangle \otimes |0\rangle) + \beta \, U(|1\rangle \otimes |0\rangle) \;=\; \alpha |00\rangle + \beta |11\rangle.$$

But the desired output, two copies of $|\psi\rangle$, is

$$|\psi\rangle \otimes |\psi\rangle \;=\; \alpha^2 |00\rangle + \alpha \beta |01\rangle + \alpha \beta |10\rangle + \beta^2 |11\rangle.$$

These two states are equal only when $\alpha\beta = 0$ — i.e., when $|\psi\rangle$ is one of the basis states $|0\rangle$ or $|1\rangle$. They are not equal for any genuinely-superposition state.

Therefore no unitary $U$ can clone an arbitrary qubit. The proof rests entirely on the linearity of quantum mechanics, which is one of the most-tested principles of physics. No-cloning is as solid as quantum mechanics itself.

What no-cloning forbids

Three things no-cloning rules out:

1. Quantum backup copies

In classical computing, error correction often works by replicating data: store three copies of each bit, vote majority on read. In quantum computing, you cannot directly replicate qubits to make backups. Quantum error correction must instead encode logical information across many physical qubits using entanglement, without ever making naive copies of the unknown logical state — the surface code (tutorial 19) and other stabilizer codes (tutorial 25) are exactly this kind of structure.

2. Quantum signal amplifiers

In classical telecommunications, long-distance signals are amplified by repeaters: detect the signal, regenerate it, transmit. The amplifier is making copies. Quantum communication cannot use this strategy — a “quantum amplifier” that copied an unknown quantum signal would violate no-cloning. This is why quantum repeaters are a hard engineering problem; they have to do something more sophisticated than amplify-and-forward.

The standard quantum-repeater architecture instead uses entanglement swapping: pre-shared entangled pairs across short links are linked together via Bell-state measurements to extend entanglement across long distances. Tutorial 49 (quantum networking) will cover this in detail.

3. Eavesdropping without disturbance

If an eavesdropper could clone a qubit being transmitted between two parties, they could keep one copy for themselves and forward the other unchanged. The two parties would never detect the eavesdropping.

No-cloning makes this impossible. Any attempt to copy a qubit on the fly disturbs it, and the disturbance is detectable by the legitimate parties. This is the structural reason BB84 quantum key distribution (Bennett-Brassard 1984) is secure: an eavesdropper cannot copy the photons without leaving evidence.

What no-cloning does not forbid

The theorem is precise. Several things you might think it forbids, it does not:

Cloning known states

If you know $|\psi\rangle$, you can prepare as many copies as you like by simply running the state preparation circuit multiple times. No-cloning forbids cloning unknown quantum states; it does not forbid making copies of states you know how to prepare from scratch.

This is the distinction between “copy” (make a duplicate of an unknown state) and “prepare” (create a known state from a fixed recipe). Classical computing does both freely; quantum computing does only the latter.

Cloning specific orthogonal states

You can build a circuit that perfectly clones any one specific state and any other specific orthogonal state, while failing on superpositions. The CNOT gate, applied to $|x\rangle \otimes |0\rangle$, gives $|x\rangle \otimes |x\rangle$ for $x \in \{0, 1\}$ — that is, CNOT clones computational-basis states. CNOT is not a violation of no-cloning because it does not clone arbitrary states (it fails on superpositions, as the proof above showed).

This is why CNOT is sometimes called a “classical copy” gate when used to copy computational-basis information.

Approximate cloning

You can build approximate clones — devices that produce two states each of which is a close approximation to the input, but neither one is exactly the input. The quantum cloning literature (Buzek-Hillery 1996 and follow-ups) characterizes the optimal trade-off: the best possible two-clone approximation has fidelity $5/6 \approx 0.83$ to the original on each output. Perfect cloning is impossible; approximate cloning is bounded.

This bound matters for quantum cryptanalysis: an eavesdropper can approximate-clone, but the resulting fidelity bound limits what they can learn before being detected.

Related theorems

No-cloning has siblings that share the same flavor:

No-broadcasting (Barnum-Caves-Fuchs-Jozsa-Schumacher 1996)

A generalization: no operation can produce a bipartite state whose marginals are both equal to a generic mixed input state. No-cloning is the special case where the input is pure.

No-deleting (Pati-Braunstein 2000)

Symmetric to no-cloning: there is no unitary $U$ that takes two identical copies of an unknown state and outputs the state plus a fixed reference (i.e., “deletes” one copy). The proof is again by linearity.

Together, no-cloning + no-deleting say: the number of copies of an unknown quantum state is conserved by unitary evolution. You cannot create copies, and you cannot destroy copies by gluing them back together.

No-signaling

Quantum mechanics does not allow faster-than-light communication via entanglement, even though entanglement produces correlations across long distances. This is the no-signaling theorem, related but distinct from no-cloning. The Bell-test correlations in tutorial 45 produce no usable signal precisely because the marginal statistics on each side are random.

A small no-cloning verification

Concrete code that attempts to clone an arbitrary qubit and fails:

import numpy as np
import pennylane as qml

dev = qml.device("default.qubit", wires=2)


@qml.qnode(dev)
def attempt_clone(angle):
    """Attempt to clone an unknown qubit state via CNOT."""
    # Prepare an unknown state on qubit 0.
    qml.RY(angle, wires=0)
    # Naive "clone" attempt: CNOT.
    qml.CNOT(wires=[0, 1])
    # Return the joint state.
    return qml.state()


# For angle 0 (state |0>), CNOT gives |00> — looks like cloning.
# For angle pi (state |1>), CNOT gives |11> — also looks like cloning.
# For angle pi/2 (state |+>), CNOT should NOT give |++>.

print("Cloning |0>:", attempt_clone(0.0))
print("Cloning |1>:", attempt_clone(np.pi))
print("Cloning |+>:", attempt_clone(np.pi / 2))

Sample output:

Cloning |0>: [1. 0. 0. 0.]                # |00>, looks cloned ✓
Cloning |1>: [0. 0. 0. 1.]                # |11>, looks cloned ✓
Cloning |+>: [0.707 0. 0. 0.707]          # (|00>+|11>)/sqrt(2), NOT |++>

The third case shows the failure: the desired output for cloning $|+\rangle$ would be $|+\rangle |+\rangle = (|00\rangle + |01\rangle + |10\rangle + |11\rangle)/2$, with all four amplitudes equal. CNOT gives $(|00\rangle + |11\rangle)/\sqrt{2}$ — an entangled state, not two independent copies. The cloning attempt produced entanglement instead of duplication. The output qubit’s marginal state is $|+\rangle$, but it is correlated with the input qubit, not an independent copy.

This is a microcosm of why naive cloning fails: trying to copy a superposition produces entanglement, and entanglement is not the same as duplication.

Common misconceptions

“No-cloning means quantum computing is impossible.” No. Quantum computing manipulates quantum states without cloning them. Algorithms like Shor’s, Grover’s, and VQE all run perfectly fine without ever needing to copy unknown states.

“CNOT clones quantum states.” It clones computational-basis states only. On general superpositions, CNOT produces entanglement, not copies. The “fan-out” of classical bits via wire branching is the operation that genuinely has no quantum analog.

“No-cloning is a technological limitation that future hardware might overcome.” Wrong. It follows from the linearity of quantum mechanics, which is foundational. No technology can violate it without violating quantum mechanics itself.

“No-cloning means quantum states cannot be measured.” It means measurements have specific structure (collapse, indeterminism, basis-dependence). You can measure a qubit, but the act of measurement destroys the original superposition. Repeated measurements of identically-prepared qubits give you statistics, not deterministic copies.

“No-cloning makes quantum networking impossible.” Harder, but not impossible. Quantum repeaters use entanglement swapping rather than amplification. Modern quantum-network protocols are designed around no-cloning, not against it.

Decision rule

Three places no-cloning matters most:

1. Quantum error correction design. Any error-correction proposal must work without copying the unknown logical state. Codes that implicitly assume cloning are wrong by construction.
2. Quantum cryptography. BB84 and related protocols rest on the impossibility of undetectable eavesdropping, which is exactly the no-cloning bound. Security proofs cite no-cloning explicitly.
3. Quantum networking architecture. Long-distance quantum communication needs entanglement-based protocols (repeaters with swapping), not amplification.

For working quantum-computing developers, no-cloning is rarely a directly-encountered constraint — it is a background assumption that shapes the architecture of quantum algorithms and protocols.

Exercises

1. Why CNOT can copy in the computational basis

Show that CNOT applied to $|x\rangle \otimes |0\rangle$ gives $|x\rangle \otimes |x\rangle$ for $x \in \{0, 1\}$. Why does this not violate no-cloning?

Show answer

CNOT: $|0\rangle |0\rangle \to |0\rangle |0\rangle$ and $|1\rangle |0\rangle \to |1\rangle |1\rangle$. Both work. The “violation” of no-cloning would require this to also work on superpositions. It doesn’t: $(\alpha |0\rangle + \beta |1\rangle) |0\rangle \to \alpha |00\rangle + \beta |11\rangle$, which is entangled, not the desired $(\alpha |0\rangle + \beta |1\rangle)(\alpha |0\rangle + \beta |1\rangle)$. CNOT clones in the computational basis only — for any other basis (the Hadamard basis, for instance), it produces entanglement, not copies. CNOT respects no-cloning by failing on the very superpositions the theorem is about.

2. The optimal approximate cloner

Buzek-Hillery 1996 showed that the best approximate qubit cloner produces two outputs each with fidelity $5/6$ to the input. What does this mean operationally for a quantum-cryptography eavesdropper?

Show answer

If the eavesdropper attempts to copy and forward, they get a copy with fidelity $5/6 \approx 83.3\%$. The forwarded state has fidelity $5/6$ to the original. The legitimate receiver sees a $1/6 \approx 17\%$ error rate on the eavesdropping-attempted qubits, which is detectable by simple parity checks. This is the structural reason BB84 has a non-zero error threshold for tolerable eavesdropping — below ~$11\%$ measured error, the protocol can extract a secret key; above that, it aborts. The Buzek-Hillery bound provides one of the tightest known constraints on undetectable eavesdropping.

3. No-deleting from no-cloning

Use no-cloning to argue that no-deleting must also hold. (Hint: think about what time reversal does.)

Show answer

Quantum mechanics is time-reversal symmetric for unitaries (every unitary $U$ has an inverse $U^\dagger$). If you could delete one of two copies of $|\psi\rangle$ — i.e., have $|\psi\rangle |\psi\rangle |\text{ancilla}\rangle \to |\psi\rangle |0\rangle |\text{outcome}\rangle$ — then running the protocol backwards would clone an unknown state from a single copy plus an ancilla. By time-reversal symmetry, no-deleting is equivalent to no-cloning. This is one reason the two theorems are typically proven together — they are the same theorem viewed from different time directions.

4. Why entanglement isn’t a substitute for cloning

Suppose someone proposes “use entanglement to share a copy of $|\psi\rangle$ with a remote party — entangle a local qubit with a remote one, and the remote qubit becomes a copy.” What is wrong with this?

Show answer

Entanglement does not produce two independent copies. If you entangle a local qubit (in state $|\psi\rangle$) with a remote one, the resulting bipartite state is entangled, not two independent copies. The remote qubit’s marginal state is identical to the local one, but the two are correlated, not independent. Measuring one collapses the other. They cannot be used independently as if they were two unrelated copies. This is why “quantum teleportation” doesn’t violate no-cloning — it transfers a state from one party to another, destroying the original in the process. Copies are not made; the state is moved. Entanglement-based remote-state preparation is the closest quantum-mechanical analog of cloning, and it always involves loss of the original.

Where this goes next

Tutorial 47 covers density matrices and mixed states — the formalism needed to describe noisy and partially-known quantum states. Tutorial 48 covers the Bloch sphere as the natural geometry of single-qubit states.

---

Weekly dispatch

Quantum, for people who already code.

One serious tutorial per week, plus the industry moves that actually matter. No hype, no hand-waving.

Email Subscribe

Free. Unsubscribe anytime. We will never sell your email.