The No-Cloning Theorem

Imagine a photocopier that could duplicate any document, in any language, without ever reading it. Classical information behaves exactly this way. A bit string can be copied perfectly, silently, and as many times as you like. This is why backups, broadcasting, and error-correcting codes all work. Quantum information refuses this convenience. The no-cloning theorem proves that no physical process, however clever, can take an arbitrary unknown quantum state. It cannot produce two independent copies of it. This is not a technological limitation waiting for a better machine. It is a theorem, derivable in a few lines from the linearity of quantum mechanics. It sits alongside Measurement and the Born Rule and Reversibility of Quantum Computation as one of the load-bearing walls of the subject. If cloning were possible, quantum key distribution would collapse. The uncertainty principle could be circumvented by measuring many copies of a state. Quantum computers would lose the very feature that makes them different from classical ones. The theorem matters because entire technologies are built on its truth. Quantum cryptography protocols such as BB84 rely on one key fact. An eavesdropper cannot copy a qubit in transit to inspect it without disturbing it. Quantum error correction has to work around no-cloning. It does this by encoding information redundantly across entangled qubits, rather than by duplicating a single qubit's state. Even the design of quantum algorithms is shaped by it. You cannot casually "save a copy" of an intermediate superposition the way a classical program saves a variable. This article gives the precise statement of the theorem. It provides a full proof using the linearity of unitary evolution. It offers a worked demonstration showing exactly where an attempted cloning circuit breaks. It also surveys the consequences for cryptography, error correction, and the broader architecture of quantum computation. It closes by foreshadowing how the impossibility of copying states is intimately tied to the way quantum parallelism differs from classical parallelism.

Key takeaways

No unitary transformation can map every unknown quantum state $|\psi\rangle$ to $|\psi\rangle\otimes|\psi\rangle$ .
The proof follows directly from linearity: a cloner that works on two non-orthogonal states leads to a contradiction.
Orthogonal states can be perfectly distinguished and copied; the obstruction is specifically about unknown, potentially non-orthogonal states.
No-cloning underlies the security of quantum key distribution and explains why quantum error correction uses entanglement instead of duplication.
Measurement-based "copying" also fails, because measurement is generally destructive and reveals only partial classical information.
The theorem is a corollary of unitarity and the tensor-product structure of multi-qubit systems, not an extra physical postulate.

The core insight

Because quantum evolution is linear, any machine that successfully clones two different unknown states must also clone their superposition incorrectly — so no universal cloning machine can exist.

The idea

A classical bit can always be copied: read it, and write the value onto a fresh bit. This works because reading a classical bit does not disturb it, and the value is a single definite piece of information. A qubit in an unknown superposition state

|\psi\rangle = \alpha|0\rangle + \beta|1\rangle

has no such luxury. The amplitudes $\alpha, \beta$ are not directly observable — measuring the qubit collapses it according to the Born rule and destroys the very superposition you wanted to duplicate. The no-cloning theorem asks a sharper question: even without measuring, is there some unitary operation, acting jointly on the qubit and a blank ancilla, that produces two copies of $|\psi\rangle$ while leaving $\psi$ itself unknown to the machine? The answer is no, for any unitary, for any fixed machine, whenever the machine is required to work correctly on more than one non-orthogonal input state. Precisely: a universal cloning machine would be a unitary operator $U$ acting on a system qubit and a blank ancilla qubit (initialized in a fixed state $|0\rangle$ ), together possibly with some machine ancilla $|M\rangle$ , such that for every state $|\psi\rangle$ in the qubit's state space,

U\big(|\psi\rangle \otimes |0\rangle \otimes |M\rangle\big) = |\psi\rangle \otimes |\psi\rangle \otimes |M'\rangle

for some machine state $|M'\rangle$ (which may depend on $\psi$ ). The theorem states that no unitary $U$ satisfying this for all $|\psi\rangle$ exists, except in the degenerate case where the set of states to be cloned is a fixed orthonormal basis (or a single state) rather than an arbitrary unknown state drawn from a continuum. The key terminology to fix: "unknown" means the machine is given no classical description of $\psi$ , only the physical qubit itself; "clone" means producing the tensor product $|\psi\rangle\otimes|\psi\rangle$ , i.e., two independent, unentangled systems each individually in state $|\psi\rangle$ — not an entangled state that merely correlates with $\psi$ . This distinction matters, because unitary evolution can certainly entangle a qubit with an ancilla; what it cannot do is disentangle that correlation into two separate faithful copies for an arbitrary unknown input.

How it works

The proof is a short argument by contradiction that exploits two facts already in your toolkit: unitary operators preserve inner products, and unitary evolution is linear over superpositions, a consequence of the reversibility discussed in Reversibility of Quantum Computation.

Setup. Suppose, for contradiction, a cloning machine $U$ exists that works for every single-qubit state. In particular, it must work correctly on two specific, non-orthogonal, normalized states $|\psi\rangle$ and $|\phi\rangle$ , with $\langle\psi|\phi\rangle \neq 0$ and $|\psi\rangle \neq |\phi\rangle$ (up to global phase). Assume:

U(|\psi\rangle|0\rangle|M\rangle) = |\psi\rangle|\psi\rangle|M_\psi\rangle, \qquad U(|\phi\rangle|0\rangle|M\rangle) = |\phi\rangle|\phi\rangle|M_\phi\rangle.

Step 1 — compute an inner product two ways. Because $U$ is unitary, it preserves inner products between any two input states and their images:

\langle\psi|0\rangle\langle M|\;\cdot\; \big(U^\dagger U\big)\;\cdot\;|\phi\rangle|0\rangle|M\rangle = \big(\langle\psi|\langle\psi|\langle M_\psi|\big)\big(|\phi\rangle|\phi\rangle|M_\phi\rangle\big).

The left side simplifies because $U^\dagger U = I$ :

\langle\psi|\phi\rangle \cdot \langle 0|0\rangle \cdot \langle M|M\rangle = \langle\psi|\phi\rangle.

The right side is:

\langle\psi|\phi\rangle^2 \cdot \langle M_\psi|M_\phi\rangle.

So unitarity forces:

\langle\psi|\phi\rangle = \langle\psi|\phi\rangle^2\,\langle M_\psi|M_\phi\rangle.

|\langle M_\psi|M_\phi\rangle| = \frac{1}{|c|} > 1,

which is impossible for normalized states. Contradiction.

Step 3 — the only escape. The contradiction is avoided only if $c = 0$ (states orthogonal) or $c = 1$ (states identical). So a single fixed unitary $U$ can faithfully clone at most a set of mutually orthogonal states, never two distinct non-orthogonal states. Since "arbitrary unknown state" necessarily includes non-orthogonal pairs (e.g., $|0\rangle$ and $|+\rangle = \tfrac{1}{\sqrt2}(|0\rangle+|1\rangle)$ ), no universal cloner exists. An equivalent and perhaps more intuitive proof runs directly through linearity, without inner products:

Linearity argument. Suppose $U$ clones both basis states:

U(|0\rangle|0\rangle) = |0\rangle|0\rangle, \qquad U(|1\rangle|0\rangle) = |1\rangle|1\rangle

(dropping the machine register for clarity). Now feed in the superposition $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$ . Because $U$ is linear (it is a unitary matrix acting on a vector space):

U\big((\alpha|0\rangle+\beta|1\rangle)|0\rangle\big) = \alpha\, U(|0\rangle|0\rangle) + \beta\, U(|1\rangle|0\rangle) = \alpha|0\rangle|0\rangle + \beta|1\rangle|1\rangle.

But true cloning of $|\psi\rangle$ would require producing

|\psi\rangle\otimes|\psi\rangle = \alpha^2|00\rangle + \alpha\beta|01\rangle + \alpha\beta|10\rangle + \beta^2|11\rangle,

an entirely different state (an entangled Bell-like state versus a product state) unless $\alpha\beta = 0$ . Linearity forces the machine that clones the basis states to fail on their superposition. This is the heart of the theorem: cloning is a nonlinear operation, but all physically allowed evolutions are linear. Below is pseudocode for the "attempted" cloning circuit, together with a check that exposes the failure on superposition inputs — useful as a concrete falsification exercise. ``` // Attempted universal cloning circuit // Input: qubit register Q in unknown state |ψ⟩ = α|0⟩ + β|1⟩ // ancilla register A initialized to |0⟩ // Goal (impossible in general): output Q⊗A = |ψ⟩ ⊗ |ψ⟩ function ATTEMPT_CLONE(Q, A): // This is exactly the CNOT gate, which correctly "clones" // basis states |0> and |1>, but is linear, hence extends // to superpositions by linearity, NOT by copying amplitudes. apply CNOT(control = Q, target = A) return (Q, A) function CHECK_CLONE_FIDELITY(alpha, beta): // Simulate CNOT on alpha|0>|0> + beta|1>|0> // CNOT sends |00> -> |00>, |11> stays, |10> -> |11>, |01> -> |01> output_state = alpha |00> + beta |11> // entangled, NOT a product state desired_state = (alpha |0> + beta |1>) TENSOR (alpha |0> + beta |1>) = alpha^2 |00> + alphabeta |01> + alphabeta |10> + beta^2 |11> if output_state != desired_state for generic alpha, beta: report "cloning failed except when alphabeta = 0" return output_state ``` Running `CHECK_CLONE_FIDELITY` symbolically shows the CNOT-based attempt reproduces perfect copies only on the computational basis states ( $\alpha\beta=0$ ) and produces an entangled* state, not two copies, for any genuine superposition — precisely the failure mode the linearity proof predicts.

Figure

Why CNOT "clones" basis states but fails on superpositions

Complexity & correctness

The no-cloning theorem is not an algorithm with a running time; it is an impossibility result, so "complexity" here means characterizing exactly what is and isn't achievable, and at what resource cost, given the impossibility.

Correctness of the proof. The argument rests on two properties guaranteed by the axioms of quantum mechanics: 1. Unitarity preserves inner products. For any unitary $U$ and states $|a\rangle, |b\rangle$ , $\langle a|b\rangle = \langle Ua|Ub\rangle$ . This is because $U^\dagger U = I$ , a direct consequence of quantum evolution being reversible (see Reversibility of Quantum Computation). 2. Unitarity is linear. $U$ acts as a linear operator on the vector space of the joint system, a consequence of the tensor-product structure of composite quantum systems and the linearity of the Schrödinger equation. Both proofs given above (inner-product and linearity) are complete — they do not merely provide a heuristic obstruction; they derive a strict numerical contradiction ( $|\langle M_\psi|M_\phi\rangle| > 1$ ) or an outright inequality of quantum states for any nontrivial input pair. There is no loophole involving ancilla dimension, measurement-assisted feedback, or probabilistic success for the deterministic, universal version of the theorem: the contradiction holds for any Hilbert space dimension of the machine register $|M\rangle$ , since the Cauchy–Schwarz bound $|\langle M_\psi|M_\phi\rangle|\le 1$ holds regardless of dimension.

What is not forbidden — the honest tradeoffs:

Cloning a known, fixed set of orthogonal states is trivial and always allowed. If you already know $|\psi\rangle \in \{|0\rangle, |1\rangle\}$ , a CNOT gate is a perfect "cloner" relative to that basis — this is exactly how classical information embedded in a quantum computer (bits stored as $|0\rangle$ / $|1\rangle$ ) is duplicated freely. The theorem bites only when the state could be any superposition, i.e., drawn from a continuum of non-orthogonal possibilities.
Probabilistic cloning is possible for linearly independent (but non-orthogonal) states, with a known success probability strictly less than 1, via the Duan–Guo bound. This does not contradict the theorem because it is not deterministic and not universal.
Approximate cloning is possible. The optimal universal quantum cloning machine (Bužek–Hillery, and later Gisin–Massar for $N\to M$ cloning) produces imperfect copies with fidelity bounded strictly below 1 for any nontrivial cloning ratio; as the number of desired output copies $M$ grows for fixed input copies $N$ , the fidelity of each copy degrades toward the fidelity achievable by classical state estimation. This quantitative bound is itself a cousin of the no-cloning theorem and is used to bound the information an eavesdropper can extract in quantum cryptography.
Cloning a state you can classically fully specify is not "cloning an unknown state" at all — you simply run state preparation twice. No-cloning is specifically about states accessed only as physical qubits with unknown amplitudes.

Resource accounting. Because deterministic universal cloning is impossible, there is no time or space complexity to state for "the cloning algorithm" — it does not exist. The complexity question that is meaningful concerns approximate cloning: producing $M$ approximate copies from $N$ originals can be done with $O(1)$ extra qubits per copy (each copy is a physical qubit) and a fixed-size unitary independent of the unknown state, but the fidelity penalty is dictated by an information-theoretic tradeoff, not a computational one — more copies always means worse fidelity per copy, following a known closed-form expression from cloning theory.

Worked example

Take the two states relevant to the BB84 quantum key distribution protocol, since this is the setting where no-cloning has direct practical stakes.

|\psi\rangle = |0\rangle, \qquad |\phi\rangle = |+\rangle = \frac{1}{\sqrt2}(|0\rangle + |1\rangle).

These are the "rectilinear" and "diagonal" basis states an eavesdropper, Eve, might intercept without knowing which basis Alice used. Suppose (for contradiction) a cloning unitary $U$ exists with:

U(|0\rangle|0\rangle|M\rangle) = |0\rangle|0\rangle|M_0\rangle, \qquad U(|+\rangle|0\rangle|M\rangle) = |+\rangle|+\rangle|M_+\rangle.

Trace the inner-product computation step by step:

Quantity	Value
$\langle\psi\vert\phi\rangle = \langle 0\vert +\rangle$	$\frac{1}{\sqrt2}$
Left-hand side after unitarity: $\langle 0\vert +\rangle\langle 0\vert 0\rangle\langle M\vert M\rangle$	$\frac{1}{\sqrt2}\cdot 1\cdot 1 = \frac{1}{\sqrt2}$
Right-hand side: $\langle 0\vert +\rangle^2 \langle M_0\vert M_+\rangle$	$\left(\frac{1}{\sqrt2}\right)^2 \langle M_0\|M_+\rangle = \frac12 \langle M_0\|M_+\rangle$
Equate: $\frac{1}{\sqrt2} = \frac12\langle M_0\|M_+\rangle$	$\Rightarrow \langle M_0\|M_+\rangle = \sqrt2$
Cauchy–Schwarz bound	$\|\langle M_0\|M_+\rangle\| \le 1$
Conclusion	$\sqrt2 \le 1$ is false — contradiction

The contradiction is explicit and numerical: unitarity would force the machine states $M_0$ and $M_+$ to have overlap $\sqrt2$ , which exceeds the maximum possible overlap of $1$ for any pair of normalized quantum states. No choice of ancilla dimension, no choice of machine state, and no choice of unitary $U$ escapes this — the bound $|\langle M_0|M_+\rangle|\le 1$ holds in any Hilbert space. Now trace what this means operationally for Eve. If Eve intercepts a qubit in BB84 and tries to clone it before measuring, she needs a cloning device that works regardless of whether Alice sent $|0\rangle$ , $|1\rangle$ , $|+\rangle$ , or $|-\rangle$ (the four BB84 states, drawn from two mutually non-orthogonal bases). Since $|0\rangle$ and $|+\rangle$ are non-orthogonal ( $\langle 0|+\rangle = 1/\sqrt2 \ne 0$ ), the calculation above shows no universal cloner exists that handles both. Eve is stuck choosing a measurement basis before knowing which basis Alice used, which is exactly the physical mechanism that lets Alice and Bob detect eavesdropping via increased error rates on a sample of their shared bits. A second, complementary trace: apply CNOT explicitly to the state $|+\rangle|0\rangle$ to see the entanglement failure mode concretely.

|+\rangle|0\rangle = \frac{1}{\sqrt2}(|0\rangle+|1\rangle)|0\rangle = \frac{1}{\sqrt2}(|00\rangle + |10\rangle).

Apply CNOT (control = first qubit, target = second):

\text{CNOT}: |00\rangle \mapsto |00\rangle, \quad |10\rangle \mapsto |11\rangle.

\Rightarrow \frac{1}{\sqrt2}(|00\rangle + |10\rangle) \;\longmapsto\; \frac{1}{\sqrt2}(|00\rangle + |11\rangle).

The output is the Bell state $\frac{1}{\sqrt2}(|00\rangle+|11\rangle)$ — a maximally entangled state, not the desired product state $|+\rangle\otimes|+\rangle = \frac12(|00\rangle+|01\rangle+|10\rangle+|11\rangle)$ . Measuring either half of the Bell state yields a uniformly random bit, correlated with the other half but not equal to two independent copies of $|+\rangle$ : this is the concrete anatomy of the cloning failure predicted abstractly by the linearity argument.

Common pitfalls & traps

Pitfall	Why it's wrong
"No-cloning means you can never copy a qubit."	False — orthogonal, known basis states can be copied trivially (e.g., via CNOT). The theorem is about arbitrary unknown states, especially non-orthogonal ones.
"Just measure the qubit, record the result, and prepare two new qubits in that state."	Measurement collapses superpositions and yields only one classical outcome per basis choice, per the Born rule; it does not reveal $\alpha,\beta$ and destroys the original state, so the reconstructed qubits are not faithful copies.
"Entanglement is a form of cloning."	Entangling a qubit with an ancilla via CNOT correlates them but does not produce two independent systems each in state $\|\psi\rangle$ ; a Bell state is not $\|\psi\rangle\otimes\|\psi\rangle$ .
"No-cloning contradicts quantum teleportation, since teleportation moves a state elsewhere."	Teleportation destroys the original state at the sender (via measurement) while recreating it at the receiver — net one copy exists at any time, consistent with no-cloning.
"Probabilistic cloning schemes with success probability $<1$ violate no-cloning."	They don't — no-cloning forbids deterministic, universal cloning; probabilistic cloning of linearly independent states with imperfect success rate is a separate, permitted regime (Duan–Guo).
"The theorem needs a separate physical postulate beyond standard quantum mechanics."	It doesn't — it is a mathematical corollary of unitarity (reversibility) and linearity, both already implied by the standard postulates.

Common trapThe measurement escape hatch is the most tempting and most wrong workaround

Many learners assume that even if unitary cloning fails, you could still copy a state by measuring it carefully and re-preparing copies from the measurement outcome. This fails for two independent reasons: measurement in a fixed basis destroys superposition information via collapse, and even in principle you cannot determine the exact amplitudes $\alpha,\beta$ of a single unknown qubit from any finite number of measurements on that one copy — a single quantum system yields only one probabilistic bit of outcome per measurement, not the full classical description of its state. Confusing "extract some information via measurement" with "clone the full quantum state" is the single most common misunderstanding of the theorem, and it is precisely the confusion that quantum key distribution protocols are engineered to exploit against eavesdroppers.

Pioneers & history

The no-cloning theorem was proven independently by several researchers in the mid-1980s, motivated by foundational questions about what quantum mechanics permits, shortly before the field of quantum information theory took shape around the BB84 protocol and subsequent cryptographic applications.

Origins · 1 minWilliam Kent Wootters and how this was discovered

William Kent Wootters

born 1951 · American theoretical physicist, co-author of the original no-cloning proof

Wootters, together with Wojciech Zurek, published the first formal proof of the no-cloning theorem in 1982, framing it explicitly as a consequence of the linearity of quantum mechanics. Wootters later became a foundational figure in quantum information theory, contributing to entanglement measures (concurrence) and quantum teleportation theory.

History

1970

James Park publishes an early, less-cited argument anticipating the impossibility of perfect quantum measurement duplication.

1982

Wootters and Zurek publish "A Single Quantum Cannot Be Cloned," giving the now-standard linearity proof.

1982

Dennis Dieks independently derives an equivalent result, emphasizing consequences for faster-than-light signaling via entanglement.

1984

Bennett and Brassard design the BB84 quantum key distribution protocol, whose security depends directly on no-cloning.

1996

Bužek and Hillery propose the optimal universal approximate quantum cloning machine, quantifying the best possible imperfect copy.

Where this matters

Quantum cryptography. The security proofs of quantum key distribution protocols such as BB84 and E91 rely on the impossibility of an eavesdropper silently copying transmitted qubits. Because Eve cannot clone an unknown qubit, any attempt to gain information about the key necessarily perturbs the states in a statistically detectable way, which Alice and Bob check by comparing a random subset of their measurement results.

Quantum error correction. Classical error correction routinely relies on redundancy via copying (e.g., majority-vote repetition codes). No-cloning rules this out for quantum information, forcing quantum error-correcting codes — such as the Shor code and stabilizer codes — to spread information non-locally across entangled qubits rather than duplicating a single logical qubit's state. This design constraint shapes the entire architecture of fault-tolerant quantum computing.

Quantum money and unforgeable tokens. Proposals for "quantum money" exploit no-cloning directly: a banknote encoded in an unknown quantum state cannot be counterfeited by copying, only by physically stealing the original, giving a cryptographic property with no classical analog.

Interpretational and foundational physics. No-cloning rules out a naive scheme for superluminal signaling through entanglement: if cloning were possible, one party could measure many copies of an entangled partner state and statistically infer which measurement the other party performed, violating relativistic causality. The theorem is part of why entanglement correlations, while nonlocal statistically, cannot be exploited to send information faster than light.

Algorithm and protocol design. Because intermediate quantum states in an algorithm cannot be freely duplicated for "backup" or parallel branches the way classical program variables can, quantum algorithm design (foreshadowing Quantum vs Classical Parallelism) must route computation through entangling operations and interference rather than through explicit copying — a structural difference that partly explains why quantum speedups arise from constructive/destructive interference patterns rather than brute-force duplication of work.

Ask the tutor: How does the no-cloning theorem constrain the design of quantum algorithms compared to classical parallelism?

Does no-cloning mean quantum information cannot be transmitted or duplicated in any sense?

No. No-cloning forbids producing two independent, faithful copies of an arbitrary unknown quantum state from a single instance. It does not forbid transmitting a state to a new location (teleportation, where the original is destroyed), preparing many separate systems in the same known state from a classical description, or copying states drawn from a fixed set of mutually orthogonal possibilities. In quantum computers, classical bits encoded as $|0\rangle$ / $|1\rangle$ are duplicated all the time via CNOT gates, since that basis is fixed and orthogonal. The theorem specifically targets superpositions whose amplitudes are unknown to whoever holds the state.

How does no-cloning make quantum key distribution secure?

In protocols like BB84, the sender encodes bits in one of two non-orthogonal quantum bases chosen at random. An eavesdropper intercepting a qubit cannot clone it and measure the clone in both bases to learn the bit without disturbance, because no unitary can clone states drawn from non-orthogonal bases. Any measurement the eavesdropper performs on the original, without knowing the correct basis, has a substantial chance of disturbing the state. This disturbance introduces detectable errors when the legitimate parties compare a sample of their transmitted bits, exposing eavesdropping statistically.

Is no-cloning specific to qubits, or does it apply to all quantum systems?

The theorem is fully general: it applies to any quantum system, described by any Hilbert space, of any dimension, including continuous-variable systems like the quantum states of light. The proof relies only on unitarity and linearity, properties shared by the evolution of every closed quantum system regardless of its physical realization. The two-qubit examples used for teaching are simply the clearest, lowest-dimensional illustration of a fully general principle.

Can quantum error correction work at all if states can't be copied?

Yes, but it must avoid copying. Instead of duplicating a logical qubit's exact state, quantum error-correcting codes spread a single logical qubit's information across several entangled physical qubits, such that no individual physical qubit holds a readable copy of the logical state. Errors on individual physical qubits can then be detected and corrected via syndrome measurements that reveal which error occurred without revealing or disturbing the encoded logical information itself — a strategy compatible with, and in fact required by, no-cloning.

What's the difference between no-cloning and the no-deleting theorem?

No-cloning forbids creating an extra copy of an unknown state; the no-deleting theorem (a complementary result by Pati and Braunstein) forbids deterministically erasing one of two copies of an unknown state and returning a "blank" qubit plus the original, when working within reversible unitary quantum mechanics. Together, they establish that quantum information, unlike classical information, cannot be freely duplicated or freely destroyed by closed-system unitary evolution — it can only be moved, transformed, or entangled.

Does no-cloning contradict the existence of multiple identical particles, like two electrons in the same state?

No. No-cloning concerns copying an unknown state carried by a single, arbitrary physical system using a fixed physical process, given no prior classical knowledge of that state. Preparing two electrons independently, using a known preparation procedure, so that both happen to be in the same known quantum state is ordinary state preparation, not cloning of an unknown input. The theorem's force is entirely about the "unknown, using this single instance" constraint, not about whether identical states can coexist in nature.

Why can't the machine "learn" the amplitudes from repeated attempts to clone the same unknown state?

Because the theorem concerns cloning a single, unknown instance of a state without any prior information, including without repeated access to identical copies to statistically estimate its amplitudes. If you already possess many independent copies of the same unknown state, you can use quantum state tomography to estimate $\alpha, \beta$ approximately — but this consumes the copies you already had rather than creating new ones from a single input, and the estimate is never exact with finitely many copies. The theorem is precisely about the impossibility of manufacturing additional exact copies from just one, without such prior resources.