Part III. Circuit Model · Chapter 21
No-Cloning and Why Copying Breaks Quantum Logic
There is no quantum photocopier, and the proof takes about four lines of algebra. This chapter proves no-cloning from linearity alone, maps exactly which copying still works, and turns the theorem into design constraints you will meet in every later chapter.
In this chapter 8 sections
Reader question. Why can no physical operation copy every unknown quantum state even though CNOT copies computational-basis labels?
Linearity forces a putative copier's action on a superposition to be the superposition of copied basis outputs, which differs from two independent copies because the cross terms are missing; known orthogonal basis states can be copied, but no single operation clones all unknown states.
- This chapter does not say classical data, known basis states, or measurement records cannot be copied.
- It does not use measurement disturbance as the proof or forbid state transfer by teleportation.
Specify the copier's contract
Write the desired transformation with a blank target.
Classical software copies bits constantly; backups, logs, retries, fanout. Quantum information refuses the same treatment. No unitary operation takes an arbitrary unknown state 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.
Evidence boundary. The no-cloning theorem follows from linearity/unitarity and forbids a universal copier for arbitrary unknown states. [William K. Wootters] [Michael A. Nielsen]
Basis success fixes the linear extension
Apply the assumed operation to |0>, |1>, and |+>.
Suppose a unitary copier U exists, and it handles the basis states as advertised:
Linearity then fixes what U must do to ; 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.
Evidence boundary. A CNOT can copy known computational-basis labels while producing entanglement for superposed input. [John Preskill] [Michael A. Nielsen]
The missing cross terms
Compare the actual Bell output with |+>|+>.
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.
Evidence boundary. No-cloning does not prohibit teleportation, tomography from ensembles, or classical record copying. [Charles H. Bennett et al.] [William K. Wootters] [John Watrous]
Notation contract: Unknown input |ψ>; blank |0>; linear map U; distinguish U(|ψ>|0>) from |ψ>|ψ>; equality up to global phase considered.
What copying remains legal
Separate orthogonal-state copying, measurement/repreparation, and tomography.
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.
Protocol consequences of no-cloning
Connect the theorem to QKD, teleportation, and error correction without overreach.
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.
No-cloning symbolic counterexample
| Field | Reader-visible record |
|---|---|
| Format | Notebook comparing linear output and desired tensor-square for parameterized states |
| Verification | Tests basis copying, |+> failure, nonzero fidelity gap, and explicitly labels measurement/repreparation as a different channel. |
| Availability | Source-embedded acceptance record; no separate download is claimed |
{
"artifact": "No-cloning symbolic counterexample",
"format": "Notebook comparing linear output and desired tensor-square for parameterized states",
"acceptance_test": "Tests basis copying, |+> failure, nonzero fidelity gap, and explicitly labels measurement/repreparation as a different channel.",
"publication_state": "source-embedded contract and worked fixture"
}Executable reference fixture
Run with Python 3.11 or later. The final assertion is the chapter-level pass condition for this small instance.
import cmath
import math
def normalize(state):
norm = math.sqrt(sum(abs(value) ** 2 for value in state))
if norm < 1e-15:
raise ValueError("the zero vector is not a state")
return tuple(value / norm for value in state)
def inner(left, right):
return sum(a.conjugate() * b for a, b in zip(left, right))
def kron(left, right):
return tuple(a * b for a in left for b in right)
def cnot_copy(state):
alpha, beta = normalize(state)
return alpha, 0j, 0j, beta
def desired_two_copies(state):
state = normalize(state)
return kron(state, state)
def fidelity(left, right):
return abs(inner(left, right)) ** 2
def outer(state):
return tuple(tuple(state[row] * state[column].conjugate() for column in range(len(state)))
for row in range(len(state)))
def measurement_reprepare(state):
alpha, beta = normalize(state)
return tuple(tuple((abs(alpha) ** 2 if row == column == 0 else
abs(beta) ** 2 if row == column == 3 else 0j)
for column in range(4)) for row in range(4))
def matrix_purity(matrix):
return sum(abs(value) ** 2 for row in matrix for value in row).real
scale = math.sqrt(0.5)
states = ((1, 0), (0, 1), (scale, scale), normalize((1, 2j)),
(math.cos(0.37), cmath.exp(0.8j) * math.sin(0.37)))
copy_fidelities = [fidelity(cnot_copy(state), desired_two_copies(state)) for state in states]
assert all(abs(value - 1.0) < 1e-12 for value in copy_fidelities[:2])
assert all(value < 1.0 - 1e-6 for value in copy_fidelities[2:])
pair_cases = ((states[0], states[2]), (states[0], states[3]), (states[2], states[4]))
overlap_gaps = []
for left, right in pair_cases:
input_overlap = abs(inner(normalize(left), normalize(right)))
unitary_output_overlap = abs(inner(cnot_copy(left), cnot_copy(right)))
desired_clone_overlap = abs(inner(desired_two_copies(left), desired_two_copies(right)))
assert abs(unitary_output_overlap - input_overlap) < 1e-12
assert abs(desired_clone_overlap - input_overlap ** 2) < 1e-12
overlap_gaps.append(abs(input_overlap - desired_clone_overlap))
assert min(overlap_gaps) > 0.05
plus = states[2]
linear_superposition = tuple(scale * a + scale * b for a, b in zip(cnot_copy(states[0]), cnot_copy(states[1])))
nonlinear_target = desired_two_copies(plus)
linearity_gap = math.sqrt(sum(abs(a - b) ** 2 for a, b in zip(linear_superposition, nonlinear_target)))
assert linearity_gap > 0.7
coherent_purity = matrix_purity(outer(cnot_copy(plus)))
measure_reprepare_purity = matrix_purity(measurement_reprepare(plus))
assert abs(coherent_purity - 1.0) < 1e-12 and abs(measure_reprepare_purity - 0.5) < 1e-12
zero_rejected = False
try:
cnot_copy((0, 0))
except ValueError:
zero_rejected = True
assert zero_rejected
print(f"PASS: 21 no-cloning verifier copies 2 orthogonal basis states but gives nonbasis fidelities={copy_fidelities[2:]}; min overlap contradiction={min(overlap_gaps):.3f}, linearity gap={linearity_gap:.3f}, measure/reprepare purity={measure_reprepare_purity:.3f}")Scope boundary
- This chapter does not say classical data, known basis states, or measurement records cannot be copied.
- It does not use measurement disturbance as the proof or forbid state transfer by teleportation.
Depth commitment. One universal contract, one contradiction, one exception analysis, and one protocol consequence map.
Practice problem
Assume a copier succeeds on |0> and |1>; derive its output on α|0>+β|1> and identify all α,β cases where it happens to equal two copies.
- Deliverable
- Symbolic coefficient comparison and the exceptional-state conditions.
- Pass condition
- A symbolic solver compares all four coefficients and a numerical sweep confirms the derived cases.
Verification record
Expected solution form. Two-line linearity proof expanded into coefficient equations plus parameter sweep.
Model answer. Linearity forces the copier output alpha|00>+beta|11>, while two copies contain alpha beta|01> and alpha beta|10> as well as squared endpoint coefficients. Equality occurs only for the copied basis cases alpha beta=0, not for an arbitrary superposition.
Model result and check. The notebook evaluates random normalized states and verifies failure except the derived basis cases.
Acceptance test. A symbolic solver compares all four coefficients and a numerical sweep confirms the derived cases.
Companion work
Artifacts for this chapter
These entries resolve to checked-in local source. Commands are reproduced exactly from the chapter manifest, and source-embedded fixtures are exported as direct downloads.
Reproduce or test
python3 tools/validate_briefs.py --briefs data/editorial_briefs_00_35.json --from 0 --through 35 --check-rewritten-sources --execute-artifacts
Provenance
Sources and review
- William K. Wootters and Wojciech H. Zurek. A single quantum cannot be cloned. Nature. 1982primary paper
- Michael A. Nielsen and Isaac L. Chuang. Quantum Computation and Quantum Information. Cambridge University Press. 2010textbook
- John Preskill. Lecture Notes for Physics 219: Quantum Computation. California Institute of Technology. 2018graduate lecture notes
- Charles H. Bennett et al.. Teleporting an unknown quantum state via dual classical and Einstein-Podolsky-Rosen channels. Physical Review Letters. 1993primary paper
- John Watrous. The Theory of Quantum Information. Cambridge University Press / University of Waterloo. 2018textbook
The load-bearing claims in the chapter are mapped inline to this registered source set. A citation supports only the bounded claim beside it.