The No-Cloning Theorem

In short

No quantum operation can duplicate an unknown quantum state. Formally: there is no unitary U such that U(|\psi\rangle \otimes |0\rangle) = |\psi\rangle \otimes |\psi\rangle for all |\psi\rangle. This is the no-cloning theorem, proved by Wootters and Zurek and independently by Dieks in 1982. The proof is three lines of linearity: a hypothetical universal cloner would have to be simultaneously linear (because it's unitary) and non-linear (because (\alpha|\psi\rangle + \beta|\varphi\rangle)(\alpha|\psi\rangle + \beta|\varphi\rangle) is quadratic in amplitudes). You can clone: (i) a known state (just prepare another copy), (ii) states drawn from a fixed orthonormal set (a CNOT works). You cannot clone arbitrary unknown states. Consequences: BB84 and related quantum key distribution protocols are secure against eavesdroppers, quantum error correction cannot rely on "make a backup" (it uses entanglement-based redundancy instead), and the no-communication theorem rules out faster-than-light signalling via entanglement.

Classical information is free to copy. You press Ctrl-C, a register is duplicated, no law of physics objects. The laws of thermodynamics say copying costs energy (Landauer's principle), but they don't say copying is impossible. This freedom is so basic to classical computing that we never notice it. Your phone backs up to the cloud. A git repository is replicated across machines. A PDF is emailed and re-emailed. The information persists through arbitrarily many copies, with no loss of fidelity.

Quantum information is not free to copy. And the failure is not a technological limitation — not a "current hardware cannot do it yet" problem. It is a theorem: a direct mathematical consequence of the fact that quantum evolution is linear. No present or future quantum computer, no matter how clever, can build a machine that takes in an unknown qubit and produces two perfect copies of it.

This is the no-cloning theorem, proved independently by William Wootters and Wojciech Zurek (1982) in a paper titled simply A single quantum cannot be cloned, and by Dennis Dieks in the same year. The proof fits on the back of an envelope. Its consequences reshape how quantum computing, quantum cryptography, and quantum error correction work — structurally, at the level of what protocols are possible in principle.

This chapter proves the theorem, examines what cloning is still allowed (more than you might think), and traces three major consequences: BB84-style quantum cryptography, quantum error correction without backups, and the no-communication theorem that forbids using entanglement to signal faster than light.

Classical vs quantum copying

Start with the picture. Classically, a copy gate takes a bit x and a blank register 0 and outputs (x, x):

\text{CopyBit}(x, 0) = (x, x), \qquad x \in \{0, 1\}.

This is implemented by a CNOT gate: control x, target 0. If x = 0, nothing happens; target stays 0. If x = 1, the target flips to 1. Either way, the output is (x, x). Cleanly implementable, universally useful, uncontroversial.

The naïve quantum generalisation: does there exist a unitary U_{\text{clone}} such that

U_{\text{clone}}(|\psi\rangle \otimes |0\rangle) = |\psi\rangle \otimes |\psi\rangle \qquad \text{for every } |\psi\rangle\text{?}

Read the equation carefully. For every single-qubit state |\psi\rangle — every point on the Bloch sphere — the unitary U_{\text{clone}} is supposed to take the product state |\psi\rangle|0\rangle and produce the product state |\psi\rangle|\psi\rangle. The register on the right started in |0\rangle; the cloner "copied" the first qubit onto it.

This equation turns out to be impossible to satisfy. A cloner is a self-contradicting object. Let's see why.

Classical copying is implemented by CNOT and works for every input bit. The hypothetical quantum cloner would do the analogous task for every input state — but the no-cloning theorem says no unitary can achieve this for all $|\psi\rangle$.

The proof — linearity kills the cloner

Suppose, for contradiction, that a universal quantum cloner U_{\text{clone}} exists. Pick any two distinct quantum states |\psi\rangle and |\varphi\rangle. By assumption, the cloner works on both:

U_{\text{clone}}(|\psi\rangle \otimes |0\rangle) = |\psi\rangle \otimes |\psi\rangle, \qquad U_{\text{clone}}(|\varphi\rangle \otimes |0\rangle) = |\varphi\rangle \otimes |\varphi\rangle.

U_{\text{clone}}\bigl((\alpha|\psi\rangle + \beta|\varphi\rangle) \otimes |0\rangle\bigr) = (\alpha|\psi\rangle + \beta|\varphi\rangle) \otimes (\alpha|\psi\rangle + \beta|\varphi\rangle). \qquad (\star)

Expand the right-hand side of (\star):

(\alpha|\psi\rangle + \beta|\varphi\rangle) \otimes (\alpha|\psi\rangle + \beta|\varphi\rangle) = \alpha^2|\psi\psi\rangle + \alpha\beta|\psi\varphi\rangle + \alpha\beta|\varphi\psi\rangle + \beta^2|\varphi\varphi\rangle. \qquad (\text{RHS})

Now compute the left-hand side using linearity of U_{\text{clone}}. Distribute U_{\text{clone}} over the sum inside the parenthesis:

U_{\text{clone}}\bigl((\alpha|\psi\rangle + \beta|\varphi\rangle) \otimes |0\rangle\bigr) = U_{\text{clone}}\bigl(\alpha|\psi\rangle|0\rangle + \beta|\varphi\rangle|0\rangle\bigr).

Why this step: tensor product is bilinear, and U_{\text{clone}} is a linear operator (every unitary is linear). So it distributes over sums — U(\alpha A + \beta B) = \alpha\,UA + \beta\,UB. This is the foundational fact that will break the cloner.

Apply linearity: U_{\text{clone}} acts separately on each term.

= \alpha\,U_{\text{clone}}(|\psi\rangle|0\rangle) + \beta\,U_{\text{clone}}(|\varphi\rangle|0\rangle) = \alpha|\psi\rangle|\psi\rangle + \beta|\varphi\rangle|\varphi\rangle. \qquad (\text{LHS})

Coefficient of |\psi\psi\rangle: \alpha = \alpha^2 \Rightarrow \alpha \in \{0, 1\}.
Coefficient of |\varphi\varphi\rangle: \beta = \beta^2 \Rightarrow \beta \in \{0, 1\}.
Coefficient of |\psi\varphi\rangle: 0 = \alpha\beta.
Coefficient of |\varphi\psi\rangle: 0 = \alpha\beta.

Combined with the normalisation |\alpha|^2 + |\beta|^2 = 1, the only solutions are (\alpha, \beta) = (1, 0) or (0, 1). That is: the equation can hold only when the input is already one of |\psi\rangle or |\varphi\rangle, never for a non-trivial superposition. The two sides are quadratic on the right (coming from the cloning output) and linear on the left (forced by U_{\text{clone}}'s linearity), and the only way to reconcile quadratic and linear is to restrict to values where both collapse.

This is the contradiction. No universal cloner U_{\text{clone}} can satisfy the cloning equation for all inputs. The theorem is proved in three lines. Linearity — the single defining property of unitary operators in quantum mechanics — is incompatible with universal cloning.

The no-cloning proof in one picture. Linearity forces the cloning output to be $\alpha|\psi\psi\rangle + \beta|\varphi\varphi\rangle$ (linear in amplitudes). The cloning equation demands it be $\alpha^2|\psi\psi\rangle + \ldots + \beta^2|\varphi\varphi\rangle$ (quadratic in amplitudes). Linear cannot equal quadratic in general — contradiction.

Example 1 — a cloner for the computational basis

The theorem forbids universal cloning. It does not forbid cloning some restricted class of states. Let us show that a CNOT clones the computational basis perfectly.

Step 1 — Define the cloner. Let U = CNOT with the first qubit as control and the second as target. Matrix-wise (on the basis |00\rangle, |01\rangle, |10\rangle, |11\rangle), CNOT is

U_{\text{CNOT}} = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{pmatrix}.

Step 2 — Verify on |0\rangle.

U_{\text{CNOT}}(|0\rangle \otimes |0\rangle) = U_{\text{CNOT}}|00\rangle = |00\rangle = |0\rangle \otimes |0\rangle.

Why: CNOT leaves |00\rangle unchanged because the control is 0, so the target doesn't flip. Result: |00\rangle. Two zeros — a "copy."

Step 3 — Verify on |1\rangle.

U_{\text{CNOT}}(|1\rangle \otimes |0\rangle) = U_{\text{CNOT}}|10\rangle = |11\rangle = |1\rangle \otimes |1\rangle.

Why: CNOT maps |10\rangle to |11\rangle because the control is 1, so the target flips. Result: |11\rangle. Two ones — a "copy."

Step 4 — See it fail on a superposition. Now try |+\rangle = \tfrac{1}{\sqrt 2}(|0\rangle + |1\rangle):

U_{\text{CNOT}}(|+\rangle \otimes |0\rangle) = U_{\text{CNOT}}\tfrac{1}{\sqrt 2}(|00\rangle + |10\rangle) = \tfrac{1}{\sqrt 2}(|00\rangle + |11\rangle) = |\Phi^+\rangle.

The output is the Bell state |\Phi^+\rangle, not |+\rangle \otimes |+\rangle. Let's check: the desired clone would be

|+\rangle \otimes |+\rangle = \tfrac{1}{2}(|00\rangle + |01\rangle + |10\rangle + |11\rangle),

whereas the actual output is \tfrac{1}{\sqrt 2}(|00\rangle + |11\rangle). The cross terms |01\rangle and |10\rangle are missing from the actual output, and their coefficients are 0 instead of 1/2. CNOT does not clone |+\rangle; it entangles the two qubits instead.

What this shows. CNOT is a perfect cloner for the computational basis \{|0\rangle, |1\rangle\} — two specific, orthogonal states. It is not a cloner for the X-basis state |+\rangle (nor for any non-computational-basis state). This is precisely what the no-cloning theorem predicts: orthogonal-basis cloning is fine, universal cloning is not. The CNOT is the quantum version of classical CopyBit — it works when the input is restricted to basis states and fails when the input is an arbitrary superposition.

What you can and cannot clone

The no-cloning theorem is stronger than you might think, and it is also weaker than you might think. Let's be precise about its boundaries.

You can clone a known state

If you know the state of a qubit, say it is |\psi\rangle = \cos(\theta/2)|0\rangle + e^{i\varphi}\sin(\theta/2)|1\rangle for specific numerical \theta and \varphi, then you can prepare as many copies as you like. Just build another qubit, apply the same state-preparation circuit, and you have another |\psi\rangle. There is no cloning involved — you never input the original; you just re-prepare from scratch. The no-cloning theorem has nothing to say about this.

You can clone states drawn from a fixed orthonormal set

If the input is guaranteed to be one of a fixed, known orthonormal set — say, one of \{|0\rangle, |1\rangle\} (computational basis) or \{|+\rangle, |-\rangle\} (Hadamard basis) — then a circuit exists that clones it. Example 1 above built the cloner for the computational basis. For other orthonormal bases, conjugate the CNOT with the relevant basis-change unitary: U_{\text{clone-X}} = (H \otimes H)\,U_{\text{CNOT}}\,(H \otimes I), roughly.

The key word is orthonormal. If the set is \{|0\rangle, |1\rangle, |+\rangle, |-\rangle\} — four states, not all mutually orthogonal — then no cloner works for all four simultaneously. The restriction to orthogonal inputs is what makes the circuit buildable.

You cannot clone arbitrary unknown states

This is the no-cloning theorem proper. If the input state is completely unknown — could be any point on the Bloch sphere — no unitary duplicates it.

You cannot even approximately clone perfectly for all states

A natural weakening of the theorem asks: maybe there is a cloner that works imperfectly, producing output close to |\psi\rangle|\psi\rangle but not exactly equal? This idea is called approximate cloning, and it has been studied in detail. The universal quantum cloning machine (UQCM) of Bužek and Hillery (1996) produces two approximate copies of an arbitrary input qubit, each with a fidelity of 5/6 \approx 0.833 to the original. This is the best possible for a universal 1 \to 2 cloner. Higher fidelity is impossible. Further, if you try for more copies (1 \to n cloning), the per-copy fidelity drops.

The approximate-cloning result quantifies exactly how badly cloning fails: you can never reach perfect fidelity 1 for all inputs simultaneously. Better-than-5/6 fidelity is possible only if you restrict the input set.

The three regimes of quantum cloning. A known state can be re-prepared; an unknown state from a fixed orthonormal set can be duplicated by a circuit; an arbitrary unknown state cannot be cloned at all, and the best approximate cloning reaches only fidelity $5/6$ per copy.

Example 2 — the CNOT cloner fails on $|+\rangle$

Step 1 — Compute the fidelity. The fidelity of two pure states |A\rangle and |B\rangle is F = |\langle A|B\rangle|^2. The actual output is |\Phi^+\rangle = \tfrac{1}{\sqrt 2}(|00\rangle + |11\rangle); the desired state is |+\rangle|+\rangle = \tfrac{1}{2}(|00\rangle + |01\rangle + |10\rangle + |11\rangle).

\langle \Phi^+|+,+\rangle = \tfrac{1}{\sqrt 2} \cdot \tfrac{1}{2} \bigl(\langle 00|00\rangle + \langle 00|01\rangle + \langle 00|10\rangle + \langle 00|11\rangle + \langle 11|00\rangle + \langle 11|01\rangle + \langle 11|10\rangle + \langle 11|11\rangle\bigr).

Only \langle 00|00\rangle = 1 and \langle 11|11\rangle = 1 contribute (the rest are orthogonal and vanish). So

\langle \Phi^+|+,+\rangle = \tfrac{1}{2\sqrt 2}(1 + 1) = \tfrac{1}{\sqrt 2}.

Fidelity: F = |1/\sqrt 2|^2 = 1/2.

Step 2 — Interpret. The CNOT cloner outputs a state with 50\% fidelity to |+\rangle|+\rangle when given |+\rangle|0\rangle as input. It is no more a "copy" than a random guess would be. This is consistent with the no-cloning theorem: the CNOT is built specifically to clone the computational basis; on a non-basis state it produces entanglement, not duplication.

Why fidelity 1/2: the CNOT-cloner applied to |+\rangle produces |\Phi^+\rangle, which is a Bell state — maximally entangled, and therefore far from any product state. A Bell state has fidelity at most 1/2 with any product state (this is a general bound, related to the \log 2 entanglement entropy discussed in ch.18). The CNOT does something meaningful on |+\rangle — it creates entanglement — but nothing resembling copying.

What this shows. Attempts to clone non-basis states using a basis-state cloner produce entanglement instead. The unitary is still valid and does its computation faithfully; it simply does not implement the operation we were hoping for. The no-cloning theorem forbids the hoped-for operation from being implemented by any unitary whatsoever.

Consequence 1 — BB84 and quantum cryptography

The first big consequence of no-cloning is quantum key distribution. The original protocol, BB84 (Bennett and Brassard, 1984), uses no-cloning directly to detect eavesdroppers.

The protocol in brief:

Alice wants to share a secret key with Bob. She sends a stream of qubits over a quantum channel, each qubit prepared in one of four states: |0\rangle, |1\rangle, |+\rangle, |-\rangle. She chooses the state uniformly at random.
Bob receives each qubit and measures it, choosing each time independently between the computational basis (Z) or the Hadamard basis (X). His choice is random.
After all qubits are sent, Alice and Bob publicly compare which basis each of them used (but not the outcomes). They discard the cases where they used different bases; the rest form the shared key.
If Eve (eavesdropper) intercepts a qubit mid-flight, she must measure it to learn its value. But she doesn't know which basis Alice used, so she sometimes measures in the wrong basis and disturbs the state. The disturbed state, forwarded to Bob, will sometimes give the wrong outcome even when Alice and Bob's bases agreed.

Where does no-cloning come in? Eve's natural strategy would be to clone each qubit, send one copy to Bob unharmed, and measure the other copy herself at leisure. If she could clone, the protocol would be completely insecure. The no-cloning theorem says she cannot. She must choose: either forward the qubit (learning nothing) or measure it (disturbing it). Alice and Bob can detect the disturbance by comparing a subset of their shared key publicly; if the error rate is too high, Eve is present.

This is cryptographic security grounded not in computational hardness — not in "factoring large numbers is slow" — but in a theorem of physics. No future hardware improvement can help Eve; the attack is impossible in principle. This is the strongest form of security guarantee known, and it is all downstream of no-cloning.

India and QKD. ISRO demonstrated BB84-style quantum key distribution in 2022 between Bengaluru and Hyderabad, using photons transmitted through a satellite link. The experiment was part of the National Quantum Mission (2023, ₹6000 crore budget), one of whose explicit goals is to build a national quantum-communication backbone resistant to quantum-computing attacks on classical cryptography. The security of every such transmission traces back to the no-cloning theorem you just proved.

BB84 and the no-cloning argument. Eve would like to clone each intercepted qubit, keep one copy, and send the other to Bob. The no-cloning theorem forbids this, forcing Eve into a lose-lose choice: measure and disturb (detected) or forward unmeasured (no information gained).

Consequence 2 — quantum error correction without backups

Classical error correction is straightforward: to guard a bit against noise, make three copies, and majority-vote. If one copy flips, the other two outvote it. This is how disk drives work, how RAID arrays work, how every redundancy scheme in classical computing works. Copies, majority votes, done.

And yet quantum error correction exists. The trick is to protect against errors not by copying but by entangling a logical qubit across several physical qubits, such that any single-qubit error on one of the physical qubits can be detected and corrected without ever having to read out (and thus destroy) the logical information. The canonical examples — Shor's 9-qubit code (1995), Steane's 7-qubit code (1996), the surface code — all encode |\psi\rangle = \alpha|0\rangle + \beta|1\rangle as

|\psi\rangle_L = \alpha|0\rangle_L + \beta|1\rangle_L,

where |0\rangle_L and |1\rangle_L are specific entangled multi-qubit states. The encoding is a unitary embedding, fully compatible with no-cloning: the original |\psi\rangle has been spread out, not copied.

The technical detail is in ch.194+ on quantum error correction. The important thing for now: quantum error correction is structurally different from classical error correction, and the difference is forced by no-cloning. There is no "quantum RAID-5." There are quantum codes that are more mathematically sophisticated and more expensive in qubits, because the straightforward approach is forbidden by a theorem.

Consequence 3 — the no-communication theorem

In the previous chapter you met the no-communication theorem: Alice and Bob sharing an entangled pair cannot use their local operations to send information faster than light. The theorem has a cleaner proof if you use density matrices and partial traces — and it is structurally related to no-cloning.

Here is the hand-wavy version of why no-cloning implies no-communication. Suppose Alice and Bob share |\Phi^+\rangle, and suppose cloning were allowed. Alice measures her qubit in the Z basis. With probability 1/2 she gets 0 and Bob's qubit collapses to |0\rangle; with probability 1/2 she gets 1 and Bob's qubit collapses to |1\rangle. If Bob could clone his qubit, he could make N copies, measure them all in the computational basis, and — with high probability — determine whether his qubit was in |0\rangle or |1\rangle. He'd learn Alice's measurement outcome instantly, faster than any classical signal could reach him. Faster-than-light communication.

The no-cloning theorem blocks this. Bob cannot make multiple copies of his qubit. He gets one measurement outcome per qubit, and one outcome per Bell pair does not reveal which basis Alice measured in. So Bob cannot learn anything about Alice's choices from his local operations. The no-communication theorem follows.

This is not a full proof (the actual no-communication argument uses density matrices and the cyclic property of the partial trace, ch.9), but it exposes the structural link. The three foundational no-go theorems of quantum information — no-cloning, no-communication, and no-broadcasting — are three aspects of the same underlying algebra: linearity of unitary evolution plus the tensor-product structure of composite systems. Removing any one would break the others.

Hype check. Popular treatments occasionally suggest that "entanglement could let us communicate instantly." It cannot. The no-cloning theorem, combined with the no-communication theorem, rules this out structurally. Neither is an engineering limit; both are theorems. The impossibility is as firm as the impossibility of 2 + 2 = 5.

Common confusions

"No-cloning means no quantum algorithm can use many copies of a state." Partially true, but subtle. Algorithms that need many copies of a state prepare them from scratch — that is allowed. What is forbidden is cloning an unknown state that was handed to you. If you prepared the state yourself, you know the preparation circuit, so "make another copy" means "run the preparation circuit again." No theorem blocks this.
"Approximate cloning might be good enough to break BB84." No. The 5/6 fidelity of the optimal universal cloner is not sufficient for Eve to evade detection. The security proofs of BB84 (and E91, and B92, and the rest) explicitly account for approximate cloning: Eve can do the Bužek-Hillery cloner, but doing so leaves a detectable error signature in Alice and Bob's comparisons. The security bound is derived taking optimal cloning into account, and it still leaves a gap in Eve's favour only below a specific error-rate threshold.
"No-cloning is about measurement." Partly. Measurement and no-cloning are linked — you cannot measure an unknown state repeatedly to learn it, because you only have one copy — but they are distinct theorems. No-cloning is about unitary operations (no unitary clones). The measurement postulate is separate: it says what a measurement does (project, yielding a classical outcome). Both constrain what you can learn about an unknown state, but they do so through different mechanisms.
"Cloning is the same as teleportation." No. Teleportation (ch.106 in the curriculum) moves a quantum state from Alice to Bob using an entangled pair and two classical bits. In the process, Alice's copy is destroyed — it must be, to avoid violating no-cloning. Teleportation is consistent with no-cloning because it doesn't create a second copy; it relocates the state. The original is unavoidably destroyed at the source end.
"No-cloning is a feature, not a bug." Correct — and worth internalising. The theorem sounds restrictive ("you cannot copy!") but it is actually why quantum cryptography works, why entanglement is a robust resource, and why certain classes of no-go arguments are provable at all. A quantum world with cloning would allow faster-than-light communication, break all quantum cryptography, and make most of quantum information theory meaningless. No-cloning is the structural guarantor of the interesting parts of quantum mechanics.
"The theorem applies to classical bits too." No. Classical bits copy trivially — CopyBit is a valid reversible function (it is just the identity on the first register and the first register into the second). In quantum language, CNOT restricted to computational-basis inputs is exactly the classical CopyBit, and it works perfectly. No-cloning concerns only genuine superposition states, which have no classical analogue. Classical copying is fine because "classical bit" means "qubit constrained to \{|0\rangle, |1\rangle\}" — exactly the orthonormal-set regime where cloning is allowed.

Going deeper

The three-line proof by linearity, the orthogonal-set cloner, and the BB84 consequence are the take-homes. What follows is the sharper structure: the optimal universal quantum cloning machine of Bužek and Hillery, the no-broadcasting theorem (weaker version of no-cloning, for mixed states), the no-deleting theorem (the dual), the connection to Heisenberg uncertainty, and why quantum error correction's structure is forced by no-cloning.

Optimal universal quantum cloning — Bužek-Hillery

The Bužek-Hillery 1996 machine (UQCM) takes an unknown qubit and produces two output qubits, each with reduced density matrix

\rho_{\text{out}} = \tfrac{5}{6}|\psi\rangle\langle\psi| + \tfrac{1}{6}|\psi^\perp\rangle\langle\psi^\perp|,

where |\psi^\perp\rangle is the state orthogonal to |\psi\rangle. The fidelity of each output with the original is \langle\psi|\rho_{\text{out}}|\psi\rangle = 5/6.

This is provably optimal: no 1 \to 2 quantum cloner can do better on average. The machine is implemented by a specific unitary on the input qubit plus two ancilla qubits. For 1 \to n cloning, the optimal per-copy fidelity is (2n + 1)/(3n), which approaches 2/3 as n \to \infty. You can make many imperfect copies, but each one is farther from the original as n grows.

Approximate cloning is a useful research tool: it lets you quantify how far any given cloning protocol is from the optimal one, and the optimal bounds enter the security proofs of quantum cryptography.

No-broadcasting theorem

A weaker version of cloning is broadcasting: instead of demanding |\psi\rangle|\psi\rangle as the output, demand that both output registers have the same reduced state as the input. For pure states, this is the same as cloning. For mixed states, it is a weaker requirement — but the no-broadcasting theorem (Barnum, Caves, Fuchs, Jozsa, Schumacher, 1996) says that even broadcasting is forbidden for non-commuting mixed states.

The theorem's content: a machine that broadcasts \rho_A to two output registers with identical reduced states exists if and only if all the possible input \rho_A's mutually commute (are simultaneously diagonalisable). Since non-commuting density matrices are the rule in quantum information, broadcasting is generically impossible.

No-broadcasting is the generalisation of no-cloning to mixed states and is the form cited in many modern quantum information papers. In the pure-state case they coincide.

No-deleting theorem

The no-deleting theorem (Pati and Braunstein, 2000) is the time-reversed cousin. It says: given two copies of an unknown state, |\psi\rangle|\psi\rangle, there is no unitary that transforms this into |\psi\rangle|0\rangle (deleting the second copy). Given the logical reversibility of quantum mechanics (unitaries are invertible), no-deleting is essentially equivalent to no-cloning — inverse of a universal cloner would be a universal deleter, and the impossibility of the former implies the impossibility of the latter.

Together, no-cloning and no-deleting make quantum information fundamentally conservation-law-like: you can move it, transform it, entangle it, but you cannot duplicate or erase it by unitary means alone. Measurement irreversibly destroys quantum information (collapsing to a classical bit), but that is a separate postulate, and even then the total information (quantum plus classical outcome) is preserved.

Connection to Heisenberg uncertainty

The no-cloning theorem is sometimes framed as equivalent to the Heisenberg uncertainty principle for non-commuting observables. The rough argument: if you could clone a qubit, you could measure one copy in the Z basis (getting the Z value) and the other copy in the X basis (getting the X value). You'd have simultaneous precise knowledge of both non-commuting observables X and Z for the original state — which is forbidden by uncertainty. So no-cloning implies uncertainty (or vice versa, depending on how you arrange the axioms).

Formally the two are not exactly equivalent: cloning is about unitary implementations, uncertainty is about measurement statistics. But they are close cousins in the structural landscape of quantum mechanics, and if you had only one of the two, you'd need to invent something close to the other to keep the theory consistent.

Why error correction needs entanglement-based redundancy

Classical redundancy is copying. Quantum redundancy is entanglement: the logical qubit's state is spread across many physical qubits as a specific entangled structure. A single-bit error on one physical qubit damages the entanglement structure in a detectable way, without revealing the logical amplitude.

The canonical example is the 3-qubit bit-flip code: encode \alpha|0\rangle + \beta|1\rangle as \alpha|000\rangle + \beta|111\rangle. This is not three copies of the input — it is a single entangled state in which a bit-flip error on any one qubit can be detected and corrected by measuring the parity of pairs. The Hilbert-space structure of this encoding is what no-cloning forces.

Full fault-tolerant schemes (surface code, colour codes, Bacon-Shor) follow the same philosophy: entangle instead of copy. This makes quantum error correction more complex than classical, more expensive in qubits, and more subtle in its threshold analysis — but all of it is downstream of the no-cloning theorem. Without no-cloning, quantum computing would use classical-style redundancy; with it, we get the beautiful and intricate machinery of stabiliser codes and topological encoding.

Where this leads next

Bell's theorem and CHSH — the structural cousin of no-cloning, concerning correlations rather than copying.
BB84 quantum key distribution — the first and best-known protocol whose security rests on no-cloning.
Quantum teleportation — how to move a quantum state without copying it (at the cost of destroying the original).
Quantum error correction — introduction — how to protect quantum information without the classical luxury of backup copies.
The no-communication theorem — the dual theorem forbidding FTL signalling, tightly linked to no-cloning.

References

Wikipedia, No-cloning theorem — statement, proof sketch, history, and consequences.
John Preskill, Lecture Notes on Quantum Computation, Ch. 4 (no-cloning and its consequences) — theory.caltech.edu/~preskill/ph229.
Nielsen and Chuang, Quantum Computation and Quantum Information (Cambridge, 2010), §12.1 on quantum no-cloning — Cambridge University Press.
Wikipedia, BB84 — the first quantum key distribution protocol and its no-cloning-based security argument.
Wikipedia, Quantum cloning — approximate cloning, the Bužek-Hillery UQCM, and related results.
Qiskit Textbook, Quantum Protocols and Quantum Algorithms — includes BB84 implementation and discussion of no-cloning.