The No-Cloning Theorem Revisited

The no-cloning theorem, proved by Wootters and Zurek and independently by Dieks in 1982, states that there is no unitary transformation $U$ acting on two quantum systems such that, for an arbitrary unknown state $|\psi\rangle$ and a fixed "blank" state $|e\rangle$,

holds simultaneously for all possible input states $|\psi\rangle$ in a Hilbert space of dimension greater than one. Here $U$ is meant to be a single, fixed unitary — the "cloning machine" — that works universally, without knowing $|\psi\rangle$ in advance. If it knew $|\psi\rangle$, of course, it could just prepare a second copy directly; the entire content of the theorem is about unknown states. The key word is unknown. If you are handed a classical description of a state — "prepare $|+\rangle$" — you can trivially make as many copies as you like by re-running the preparation procedure. The theorem forbids something much more specific: a machine that takes a physical qubit in an unspecified state and outputs two physical qubits in that same state, without ever learning what the state was. This is exactly the operation a photocopier performs for classical bits, and exactly the operation that turns out to be physically impossible for quantum bits. The proof rests on one fact you already know: quantum evolution (in the absence of measurement) is unitary, and unitary operators are linear. Linearity is a strong constraint — it means the action of $U$ on a superposition is completely determined by its action on the basis states making up that superposition. Cloning, by contrast, is an inherently nonlinear operation: it squares the input in some sense ($|\psi\rangle \mapsto |\psi\rangle\otimes|\psi\rangle$ is quadratic in the amplitudes of $|\psi\rangle$). A linear machine cannot implement a quadratic map consistently across all inputs, and that tension is the entire proof.

The cleanest way to see the impossibility is to assume a cloner exists and derive a contradiction. We work in a two-dimensional Hilbert space (qubits) for concreteness; the argument generalizes immediately to any Hilbert space of dimension $\geq 2$.

Setup. Suppose a universal cloning unitary $U$ exists, acting on a two-qubit system: the data qubit (holding the unknown state) and a target qubit initialized to a fixed blank state $|e\rangle$. Universality means that for every state $|\psi\rangle$ in the qubit's Hilbert space,

Step 1 — apply the assumption to two specific states. Pick two arbitrary states $|\psi\rangle$ and $|\varphi\rangle$ in the same Hilbert space. By assumption, the same fixed $U$ clones both:

Step 2 — compute the inner product two ways. Because $U$ is unitary, it preserves inner products between any two vectors it acts on. Compute the inner product of the two input states $|\psi\rangle|e\rangle$ and $|\varphi\rangle|e\rangle$, then compute the inner product of their images, and set them equal. Input side:

Output side:

Unitarity of $U$ requires these to be equal:

Step 3 — solve the resulting equation. Let $c = \langle\psi|\varphi\rangle$, a complex number with $|c|\le 1$ by the Cauchy–Schwarz inequality. The equation $c = c^2$ has exactly two solutions: $c = 0$ or $c = 1$.

• $c = 1$ means $|\psi\rangle = |\varphi\rangle$ (identical states, up to global phase already fixed by normalization).
• $c = 0$ means $|\psi\rangle$ and $|\varphi\rangle$ are orthogonal.

Step 4 — the contradiction. We chose $|\psi\rangle$ and $|\varphi\rangle$ to be arbitrary states. But the equation forces every pair of states handled by $U$ to be either identical or perfectly orthogonal. In any Hilbert space of dimension $\ge 2$ there exist pairs of distinct, non-orthogonal states — for a qubit, $|0\rangle$ and $|+\rangle = \tfrac{1}{\sqrt2}(|0\rangle+|1\rangle)$ are a standard example, with $\langle 0|+\rangle = \tfrac{1}{\sqrt2} \ne 0, 1$. Since $U$ must clone these states too, we reach a contradiction. No such universal $U$ can exist. $\blacksquare$ Note precisely what survives the proof: a machine restricted to cloning states drawn from a single fixed orthogonal set (e.g. only $|0\rangle$ and $|1\rangle$) is perfectly consistent with unitarity, because for orthogonal states $c=0$ satisfies the constraint. This is exactly why classical bits — always encoded in orthogonal states like $|0\rangle,|1\rangle$ — can be copied freely, while generic superpositions cannot.

A second argument: linearity alone

It is worth seeing an even more elementary version of the proof that uses only linearity, not unitarity, to build intuition for why cloning is the wrong shape of operation. Suppose $U$ successfully clones two orthogonal basis states:

Now consider the superposition $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$. Linearity of $U$ dictates:

But a genuine clone of $|\psi\rangle$ would require:

These two expressions are different whenever $\alpha\beta \ne 0$ (i.e., whenever $|\psi\rangle$ is a genuine superposition, not just $|0\rangle$ or $|1\rangle$). Instead of a clean product state $|\psi\rangle|\psi\rangle$, linearity produces an entangled state $\alpha|00\rangle+\beta|11\rangle$. The machine that correctly clones the basis states necessarily fails to clone their superpositions — it entangles instead. This is the deep reason cloning fails: linear machines distribute over superpositions additively, but cloning demands a multiplicative (quadratic) relationship between input and output amplitudes. ``` PSEUDOCODE: Attempted Universal Cloner (and why it fails) Input: register D holding unknown state |psi> (data) register T holding fixed blank state |e> (target) Output: claim: D and T both hold |psi> procedure ATTEMPT_CLONE(U, |psi>):

# U is assumed fixed and independent of psi (the "universal" requirement) joint_state <- TensorProduct(|psi>, |e>) result <- ApplyUnitary(U, joint_state) return result

# Consistency check across two distinct, non-orthogonal test states psi1 <- |0> psi2 <- |+> # (|0> + |1>) / sqrt(2), not orthogonal to |0> out1 <- ATTEMPT_CLONE(U, psi1) # must equal |0>|0> out2 <- ATTEMPT_CLONE(U, psi2) # must equal |+>|+> inner_before <- InnerProduct(psi1 (x) |e>, psi2 (x) |e>) # = <0|+> = 1/sqrt(2) inner_after <- InnerProduct(out1, out2) # = <0|+>^2 = 1/2 if inner_before != inner_after: raise Contradiction("U cannot be unitary and clone both psi1 and psi2")

# This is not a bug to patch — it is a proof that no valid U exists. ``` The pseudocode is not an algorithm you can fix by debugging; it is a proof by contradiction rendered as a runnable consistency check. Any implementation attempt necessarily trips the `Contradiction` branch for some pair of inputs, because the contradiction is derived from unitarity itself, not from a coding error.

The no-cloning theorem is not an algorithm with a runtime, but it has a precise "complexity" reading worth stating carefully: it is a zero-query impossibility result — no unitary exists, period, regardless of how much time, how many ancilla qubits, or how many gates you are willing to spend. This distinguishes it from computational hardness results (like factoring being hard for classical computers), which are conjectured asymptotic difficulties. No-cloning is an exact, information-theoretic impossibility that holds even with unbounded resources.

Correctness of the proof (recap of the invariant). The proof exploits a single invariant that any unitary operator must preserve: inner products between pairs of states. This is precisely the defining property of unitary operators, $U^\dagger U = I$, which implies $\langle a|b\rangle = \langle Ua|Ub\rangle$ for all vectors $a, b$. The cloning hypothesis forces the post-cloning inner product to be the square of the pre-cloning inner product. Since squaring is not the identity function except at $0$ and $1$, and since Hilbert spaces of dimension $\ge 2$ always contain non-orthogonal, non-identical state pairs, the invariant is violated. The argument is airtight and uses no unstated assumptions beyond linearity/unitarity of quantum evolution — a postulate you already accept for qubit and multi-qubit states evolving in isolation.

Generalization to mixed states and the density-matrix argument. The same conclusion follows even more starkly using density matrices and the linearity of quantum channels (completely positive trace-preserving maps, of which unitaries are a special case). Because any physically allowed evolution — including those augmented with measurement and classical feedback — is linear on density matrices, the argument extends beyond unitary cloners to arbitrary quantum operations. This closes the loophole "maybe cloning needs an extra measurement or classical control step" — it does not help, because the fundamental obstruction is linearity of the map on the state space, not the specific unitary structure.

What no-cloning does not forbid.

• Cloning a known state: if you know $|\psi\rangle$'s classical description, prepare as many copies as you like from scratch. This uses no cloning device at all — it just re-runs the state preparation.
• Cloning states from a known orthogonal set: a machine restricted to $\{|0\rangle, |1\rangle\}$ can clone perfectly, since orthogonal states satisfy $c=0$ in the proof and no contradiction arises. This is exactly how classical information embedded in quantum hardware (computational basis states) can be freely copied.
• Approximate cloning: quantum machines can produce imperfect copies with fidelity less than 1. The optimal achievable fidelity for universal approximate cloning of qubits is a well-studied quantity (the Bužek–Hillery cloner achieves $5/6$ fidelity for one-to-two qubit cloning), and no-cloning is precisely the statement that this fidelity can never reach $1$ for non-orthogonal inputs.
• Cloning half of an entangled pair alone: this would violate no-cloning combined with the no-signaling principle, and is separately forbidden, but the elementary proof above already covers arbitrary unknown single-system states.

Honest tradeoff. The theorem is a hard mathematical wall, not an engineering target to optimize around. Quantum error correction sidesteps it not by cloning logical information but by spreading it non-locally across many physical qubits via entanglement — recoverable from partial loss, but never duplicated in the classical sense. This is why quantum error-correcting codes are structurally different from classical repetition codes, and why building fault-tolerant quantum computers is fundamentally harder than classical redundancy engineering.

Let's trace the contradiction concretely with explicit numbers, using the qubit states $|0\rangle$ and $|+\rangle$, and a hypothetical blank state $|e\rangle=|0\rangle$ (a common convention; the argument is insensitive to this choice). Suppose a cloning unitary $U$ existed with the defining property:

The unitarity requirement in row 6 is violated numerically: $1/\sqrt2 \approx 0.7071$ while $1/2 = 0.5$. These are different real numbers, so no unitary $U$ satisfying rows 3 and 4 simultaneously can exist — the specific claimed action of $U$ is internally inconsistent with the requirement that unitaries preserve inner products.

A concrete cryptographic reading of this same computation. Suppose an eavesdropper Eve intercepts a qubit in BB84 encoded as either $|0\rangle$ or $|+\rangle$ (the two bases Alice might use), and tries to clone it before forwarding it to Bob. If Eve had a perfect cloner, she could keep one copy, forward the other undisturbed, and measure her copy after learning which basis Alice used — detecting nothing wrong and learning everything. The table above shows precisely why she cannot: any unitary Eve builds that clones $|0\rangle$ correctly is forced by inner-product preservation to fail at cloning $|+\rangle$, and vice versa. This forced imperfection is exactly what BB84 exploits — Eve's tampering necessarily introduces detectable disturbance, quantified later as an error rate in the sifted key, foreshadowing The BB84 Protocol.

The theorem arrived almost as an afterthought to a failed proposal: physicist Nick Herbert had suggested in 1981 a scheme (nicknamed FLASH, for "First Laser-Amplified Superluminal Hookup") purporting to use quantum cloning to send superluminal signals by exploiting entanglement correlations. Wootters, Zurek, and Dieks proved cloning impossible partly in direct response, closing the loophole Herbert's proposal depended on and simultaneously establishing one of the deepest results in quantum information theory. The episode is a canonical illustration of how attempted violations of relativity or causality in quantum mechanics are consistently blocked by structural theorems like no-cloning and no-signaling working in tandem.

Quantum key distribution. Every practical QKD protocol — The BB84 Protocol, E91, and their descendants — derives its security guarantee from no-cloning. An eavesdropper cannot intercept a transmitted qubit, clone it, forward a pristine original, and measure the clone offline; any attempt to extract information necessarily disturbs the transmitted state in a way Alice and Bob can statistically detect. Commercial QKD systems deployed by companies like ID Quantique and Toshiba, and metropolitan quantum networks in China and Europe, rest on this single theorem.

Quantum error correction and fault tolerance. Because logical qubits cannot be protected by naive duplication, quantum error-correcting codes (Shor's 9-qubit code, surface codes used by Google and IBM's superconducting processors) encode information through entanglement across many physical qubits. The entire architecture of fault-tolerant quantum computing is shaped by working around no-cloning rather than through it.

Quantum money and unforgeable tokens. Wiesner's quantum money scheme (predating even the 1982 proof, conceived in the late 1960s) proposed banknotes encoded in quantum states that counterfeiters cannot copy — a direct cryptographic application of no-cloning, decades ahead of its formal proof, now revived in modern proposals for quantum-secure digital currency and unclonable authentication tokens.

Device authentication and quantum tokens. No-cloning underlies proposals for physically unclonable quantum identification tags and quantum-secure certificates, where the impossibility of duplicating a device's quantum signature provides tamper-evidence impossible to achieve with classical bit strings.

Foundational quantum theory. The theorem is a cornerstone result cited whenever textbooks establish the boundary between classical and quantum information — it is often the first "quantum information cannot do X" theorem students encounter, setting up the intuition needed for the Quantum Teleportation protocol and for understanding entanglement-based security proofs throughout Quantum Key Distribution Principles.

Ask the tutor: How does the no-cloning theorem's inner-product argument change if the two states being compared are mixed states instead of pure states?