Skip to content

No cloning: the theorem that shapes everything

You cannot copy an unknown quantum state. Proven in one short argument, and the reason quantum cryptography works and error correction is hard.

An unknown qubit state on the left, a red prohibition sign, and two faded copies on the right that cannot be made.
You cannot copy an unknown state. The proof is one line of linearity.

I have mentioned the no cloning rule before, in the entanglement post and again as the reason teleportation has to destroy the original. It keeps coming up because it is one of the deepest facts in quantum computing, a single short theorem that quietly shapes the entire field. So it earns its own post. The statement is simple: you cannot copy an unknown quantum state. Not it is difficult, not we lack the technology, but it is mathematically impossible, forbidden by the structure of quantum mechanics itself. Here is why, demonstrated, and why that one impossibility matters so much.

The claim

There is no operation, no gate, no machine, no clever circuit, that takes an arbitrary unknown qubit in some state |ψ⟩ and produces two qubits both in the state |ψ⟩. A universal copy machine for quantum states does not exist and cannot be built. This is the no cloning theorem, and the word theorem is doing real work: it is proven, not observed, a consequence of the mathematics rather than a limitation of our engineering.

Notice the word unknown. You can absolutely prepare two qubits in the same known state, if you know what the state is, just build it twice. No cloning is about copying a state you do not know, taking a mystery qubit handed to you and duplicating it. That is what is impossible.

The obvious copy machine, and how it fails

The natural first guess for a quantum copier is the CNOT gate, and seeing exactly how it fails is the fastest route to understanding the theorem. CNOT does copy the basis states perfectly. Feed it |0⟩ on the control and a blank |0⟩ on the target, and you get |00⟩. Feed it |1⟩, you get |11⟩. The target became a copy of the control.

import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

for inp in ['0', '1']:
    qc = QuantumCircuit(2)
    if inp == '1': qc.x(0)
    qc.cx(0, 1)                 # try to copy qubit 0 onto qubit 1
    print(f"|{inp}>|0> -> {np.round(np.real(Statevector(qc).data), 3)}")

Run it. |0⟩ copies to |00⟩ and |1⟩ copies to |11⟩, exactly as a copier should. So far it looks like CNOT is a perfectly good cloning machine. But now feed it a superposition, the state |+⟩, and watch the copier break.

qc = QuantumCircuit(2)
qc.h(0)                         # qubit 0 is now |+>, a superposition
qc.cx(0, 1)                     # try to copy it onto qubit 1
print(np.round(np.real(Statevector(qc).data), 3))   # [0.707 0 0 0.707]

Run it. If CNOT had copied |+⟩, you would get |+⟩ on both qubits, which is the state [0.5, 0.5, 0.5, 0.5], equal weight on all four outcomes. Instead you get [0.707, 0, 0, 0.707], which is the Bell state, the entangled pair from the entanglement post. The copier did not make two independent copies of |+⟩. It produced an entangled state where the two qubits are correlated but neither is actually in the state |+⟩ on its own. The machine that flawlessly copies basis states fails utterly on a superposition, and instead of a copy it hands you entanglement. That failure is no cloning in miniature.

Why no machine can do it

The deeper reason is linearity, and it is worth seeing because it shows the impossibility is fundamental, not a flaw in CNOT specifically. Every quantum operation is linear, as the gates post established, a gate is a matrix, and a matrix respects sums, so what a gate does to a combination of states is the combination of what it does to each. Now suppose some machine could clone. It copies |0⟩ to |00⟩ and |1⟩ to |11⟩, fine. But then ask what it must do to the superposition |0⟩ plus |1⟩. Linearity forces the answer: it must give the sum of the two results, |00⟩ plus |11⟩, which is the entangled Bell state. But genuine cloning of |0⟩ plus |1⟩ should produce two copies, which multiplied out is |00⟩ plus |01⟩ plus |10⟩ plus |11⟩, a completely different state. The two demands contradict. Linearity says one thing, cloning demands another, and they cannot both hold. Since every real quantum operation is linear, no real operation can clone. The contradiction is the proof, and it is why no future technology rescues cloning: it is ruled out by the same linearity that makes everything else work.

And measuring does not rescue it

You might try a workaround: measure the unknown qubit to learn its state, then prepare two copies from what you learned. This fails too, for a reason from the measurement post. Measuring an unknown state collapses it, giving you a single outcome, not the state. A qubit in |+⟩ measured in the standard basis gives you a 0 or a 1, not the information that it was an equal superposition. One measurement of one copy cannot reveal an unknown state, so you have nothing accurate to rebuild from. Every route to copying an unknown state is blocked, the direct one by linearity and the measure then rebuild one by collapse.

Why this shapes everything

Here is why a single impossibility deserves a whole post: it quietly determines the shape of huge parts of the field.

It is why teleportation destroys the original. The last post but one ended with this thread. Because you cannot have two copies of an unknown state, moving a state must consume the source. Teleportation is built to respect no cloning, transferring the state while necessarily destroying the original. No cloning is the law that forces teleportation to be a move and not a copy.

It is the foundation of quantum cryptography. This is the most useful consequence, and it flips no cloning from a limitation into a feature. In quantum key distribution, two parties exchange qubits to establish a secret key, and the security rests on no cloning: an eavesdropper cannot copy the qubits in transit to read them secretly, because copying unknown states is impossible. Any attempt to intercept and measure them disturbs them detectably. So no cloning makes eavesdropping leave fingerprints, which is exactly what you want from secure communication. A genuinely useful, real world application built directly on the impossibility.

It is worth seeing why the fingerprints appear, because it is the same physics from earlier posts. To learn anything about a qubit in transit, an eavesdropper must measure it. But measuring an unknown state disturbs it, collapsing a superposition and changing what arrives, and because they cannot first clone the qubit to keep an undisturbed copy, they have no way to measure without leaving a trace. The legitimate parties then check a sample of their qubits, and if an eavesdropper has been measuring, the error rate in that sample is higher than physics allows for an untouched channel. The disturbance shows up as statistics that should not be there. So the security does not come from making interception hard, the way classical encryption makes it computationally expensive. It comes from making interception impossible to hide, because no cloning forbids the eavesdropper from keeping a clean copy to measure in secret. The impossibility of copying becomes the guarantee of detection, and that is a kind of security classical channels simply cannot offer.

It is why quantum error correction is hard and different. Classical error correction leans heavily on copying: store a bit three times, and if one flips, majority vote fixes it. Quantum cannot copy, so that strategy cannot be carried over as it is, and quantum error correction had to be invented from scratch with a far subtler approach that spreads information across many qubits without ever duplicating it, as the decoherence post gestured at. No cloning is a large part of why protecting quantum information is so much harder than protecting classical information.

It is worth appreciating how clever the escape from this corner had to be. Classical redundancy is conceptually trivial, just keep copies, and no cloning slams that door shut entirely. So quantum error correction has to protect information it is forbidden to copy, which sounds impossible at first hearing. The resolution is to encode a single logical qubit's worth of information across many physical qubits in a spread out, entangled way, such that the information is present in the correlations among the qubits rather than copied into any one of them. You never duplicate the state, you distribute it, and you can then detect and fix errors by measuring relationships between qubits without ever measuring or copying the protected information itself. That this is even possible is one of the genuinely beautiful results in the field, and it exists in the precise shape it does because no cloning forced it to. The theorem that forbids the easy solution is the reason the hard, elegant one had to be discovered.

What you can still do

It is easy to overcorrect and think no cloning makes quantum information impossibly fragile to work with, so it helps to mark the boundary clearly. Plenty is still allowed. You can copy known states freely, because if you know what the state is you just prepare it again from scratch, as many times as you like. The ban is only on copying states you do not know. You can move an unknown state from one qubit to another, which is exactly what teleportation does, as long as you destroy the original in the process, a move rather than a copy. And you can perfectly copy states drawn from a known set of mutually distinguishable possibilities, because if the possible states are distinguishable you can measure to find out which one you have and then prepare copies. What you cannot do is copy an arbitrary unknown state that might be any superposition at all. The impossibility is specific, and seeing its edges keeps you from concluding that quantum information cannot be handled. It can, just not duplicated blind, and a great deal of the field's cleverness is about working productively within that one boundary.

The honest framing

No cloning sounds like a pure limitation, and in some places it genuinely is one, the reason quantum error correction demanded entirely new ideas. But it is also a resource, the very thing that makes quantum cryptography secure. The same impossibility that closes one door, easy redundancy, opens another, detectable eavesdropping. That dual character is worth holding onto: in quantum computing, a constraint and a feature are often the same fact seen from two sides, and no cloning is the clearest example. It is not simply an obstacle. It is one of the load bearing walls the whole structure is built around.

A quick test before you move on

Close this and answer in your own words.

What exactly does the no cloning theorem forbid, and what does it not forbid? If you cannot distinguish copying an unknown state, which is forbidden, from preparing two copies of a known state, which is fine, reread the claim.

Why does CNOT fail to copy |+⟩, and what does it produce instead? If entanglement, a Bell state, rather than two copies is not your answer, revisit the obvious copy machine section.

And name two ways no cloning shapes the field. If you cannot give two of teleportation, cryptography, or error correction, reread the why this shapes everything section, because that is the whole reason a short theorem gets a long post.

Where I am learning it

Free. No cloning is covered in every quantum computing course and the IBM Quantum materials, usually as a short proof, but the version that taught me most was watching CNOT succeed on basis states and then fail on a superposition, which makes the abstract theorem something you can see. The linearity argument is short and worth working through once by hand. As always, the impossibility did not feel real until I tried to copy |+⟩ on my own machine and got entanglement instead of a copy.

The impossibility that builds things

No cloning is a strange kind of cornerstone: a statement about what you cannot do that ends up determining what you can. You cannot copy an unknown quantum state, full stop, and from that one impossibility flows the reason teleportation moves rather than copies, the reason quantum cryptography is secure, and a large part of why quantum error correction is its own difficult discipline.

I have come to think of it as a perfect small example of how this field works. The limitations are not just walls you bump into, they are structural, and learning to see a constraint as something that shapes and enables rather than merely forbids is part of thinking clearly about quantum computing at all. You cannot copy the unknown. Almost everything interesting downstream is built on top of that one fact.