Introduction

Imagine a photocopier for quantum states — a machine that reads a qubit and produces two identical copies. It sounds useful. In fact, it is impossible.

In 1982, William Wootters and Wojciech Zurek proved that no physical process allowed by quantum mechanics can duplicate an unknown quantum state. The same year, Dennis Dieks arrived at the same result independently. The result is now called the no-cloning theorem.

The proof fits in a single paragraph and uses nothing more than the linearity of quantum mechanics — the very rule that gives qubits their power is the rule that makes cloning illegal. This is not a technological limitation waiting to be engineered away; it is a consequence of the universe's own rules.

And that impossibility turns out to be extremely useful. It is the mathematical fact that makes quantum cryptography — and quantum key distribution in particular — provably secure against eavesdropping.

Try It: The Failing Copy Circuit

The most natural attempt at copying a qubit uses a CNOT gate: apply it with the original qubit as control and an ancilla qubit ∣0⟩|0\rangle as target. For basis states it works perfectly. For a superposition it fails silently — the output is not two copies of the original; it is an entangled pair.

<div class="controls">
  <label class="ctrl-label">Input qubit |ψ⟩:</label>
  <div class="presets">
    <button class="preset active" data-state="0">|0⟩</button>
    <button class="preset" data-state="1">|1⟩</button>
    <button class="preset" data-state="plus">|+⟩</button>
    <button class="preset" data-state="minus">|−⟩</button>
  </div>
  <button id="run" type="button">Run circuit</button>
</div>
<div id="circuit-view" class="circuit-view" aria-live="polite"></div>
<div id="result" class="result-box" aria-live="polite"></div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; padding: 14px; }
.controls { display: flex; align-items: center; gap: .6rem; flex-wrap: wrap; margin-bottom: .8rem; }
.ctrl-label { font-size: .88rem; font-weight: 600; color: #444; white-space: nowrap; }
.presets { display: flex; gap: .35rem; }
.preset { font: 600 13px ui-monospace, monospace; padding: .3rem .65rem;
          border: 1.5px solid #8fa6be; background: #f0f4f8; color: #1d3557;
          border-radius: 6px; cursor: pointer; transition: all .15s; }
.preset.active { background: #1d3557; color: #fff; border-color: #1d3557; }
#run { font: 600 14px system-ui; padding: .4rem .9rem; background: #2a7de1; color: #fff;
       border: none; border-radius: 8px; cursor: pointer; margin-left: auto; }
#run:hover { background: #1a6dd1; }
.circuit-view { background: #f8fafc; border: 1px solid #d0dce8; border-radius: 10px;
                padding: 1rem 1.2rem; font-family: ui-monospace, monospace; font-size: .82rem;
                line-height: 2; margin-bottom: .8rem; min-height: 120px; }
.wire { display: flex; align-items: center; gap: .3rem; margin: .15rem 0; }
.wire-label { width: 56px; font-weight: 700; color: #1d3557; text-align: right; flex-shrink: 0; }
.wire-line { flex: 1; height: 2px; background: #a0b4c8; position: relative; }
.gate-box { display: inline-flex; align-items: center; justify-content: center;
            width: 38px; height: 28px; border: 1.8px solid #1d3557; background: #e8f0fb;
            border-radius: 5px; font: 700 12px ui-monospace; color: #1d3557;
            position: absolute; top: 50%; left: 50%; transform: translate(-50%,-50%); }
.gate-ctrl { width: 10px; height: 10px; border-radius: 50%; background: #1d3557;
             position: absolute; top: 50%; left: 50%; transform: translate(-50%,-50%); }
.gate-vert { position: absolute; left: 50%; top: -14px; bottom: -14px;
             width: 2px; background: #1d3557; transform: translateX(-50%); z-index: 0; }
.state-chip { display: inline-block; font: 600 12px ui-monospace; padding: .15rem .45rem;
              border-radius: 5px; background: #e8eef3; color: #1d3557; margin: 0 .2rem; }
.result-box { border-radius: 10px; padding: .75rem 1rem; font-size: .9rem; line-height: 1.55;
              border: 1.5px solid transparent; display: none; }
.result-box.ok { background: #edfaf3; border-color: #4caf85; color: #0a4a26; display: block; }
.result-box.warn { background: #fff8e6; border-color: #e6a817; color: #6b4200; display: block; }
.result-box strong { display: block; font-size: .95rem; margin-bottom: .3rem; }
.arrow { color: #2a7de1; font-weight: 700; }
.bell-note { margin-top: .4rem; font-size: .82rem; opacity: .85; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// No-Cloning Theorem Demo
// Shows why the CNOT "copy" circuit works for |0⟩ and |1⟩ but produces
// an entangled Bell state (not two copies) when the input is a superposition.
//
// State representation: complex amplitudes [a00, a01, a10, a11]
// for the two-qubit basis |00⟩, |01⟩, |10⟩, |11⟩.
// Qubit 1 = original (control), Qubit 2 = ancilla (target), starts in |0⟩.

const STATES = {
  '0':    { label: '|0⟩',   amp: [1,0,0,0] },   // |0⟩|0⟩ → CNOT → |00⟩
  '1':    { label: '|1⟩',   amp: [0,0,1,0] },   // |1⟩|0⟩ → CNOT → |11⟩
  'plus': { label: '|+⟩',   amp: [1/Math.SQRT2, 0, 1/Math.SQRT2, 0] },  // superposition
  'minus':{ label: '|−⟩',   amp: [1/Math.SQRT2, 0, -1/Math.SQRT2, 0] }, // superposition
};

// CNOT gate: control=qubit1, target=qubit2
// Maps: |00⟩→|00⟩, |01⟩→|01⟩, |10⟩→|11⟩, |11⟩→|10⟩
function applyCNOT(amp) {
  const [a00, a01, a10, a11] = amp;
  return [a00, a01, a11, a10]; // swap a10 <-> a11
}

function fmtAmp(v) {
  if (Math.abs(v) < 1e-9) return null;
  const s = Math.abs(v - 1/Math.SQRT2) < 1e-9 ? '1/√2' :
            Math.abs(v + 1/Math.SQRT2) < 1e-9 ? '-1/√2' :
            Math.abs(v - 1) < 1e-9 ? '1' :
            Math.abs(v + 1) < 1e-9 ? '-1' : v.toFixed(3);
  return s;
}

function describeState(amp) {
  const labels = ['|00⟩','|01⟩','|10⟩','|11⟩'];
  const terms = amp.map((a, i) => {
    const f = fmtAmp(a);
    if (!f) return null;
    const prefix = f.startsWith('-') ? f : (f === '1' ? '' : f);
    return (prefix ? prefix + '·' : '') + labels[i];
  }).filter(Boolean);
  return terms.join(' + ').replace(/\+ -/g, '− ') || '0';
}

// Determine if the output is a product state or entangled
// Output [a00, a01, a10, a11] is separable iff a00*a11 == a01*a10
function isSeparable(amp) {
  return Math.abs(amp[0]*amp[3] - amp[1]*amp[2]) < 1e-9;
}

// Build the circuit diagram
function renderCircuit(inputLabel, outputAmp, inputAmp) {
  const cv = document.getElementById('circuit-view');
  const outDesc = describeState(outputAmp);
  cv.innerHTML = "\n    " + fmt(`<div class="wire">
      <span class="wire-label">ψ:</span>
      <span class="state-chip">%inputLabel%</span>
      <span class="arrow"> ──── </span>
      <span style="position:relative;display:inline-block;width:60px;height:30px;">
        <span class="gate-vert"></span>
        <span class="gate-ctrl"></span>
      </span>
      <span class="arrow"> ──── </span>
      <span class="state-chip">%inputLabel%</span>
    </div>
    <div class="wire">
      <span class="wire-label">|0⟩:</span>
      <span class="state-chip">|0⟩</span>
      <span class="arrow"> ──── </span>
      <span style="position:relative;display:inline-block;width:60px;height:30px;">
        <span class="gate-box">⊕</span>
      </span>
      <span class="arrow"> ──── </span>
      <span class="state-chip">?</span>
    </div>
    <div style="margin-top:.5rem;font-size:.8rem;color:#555;">
      Output state: <strong style="color:#1d3557">%outDesc%</strong>
    </div>`, { inputLabel: inputLabel, outDesc: outDesc });
}

let currentState = '0';

function run() {
  const s = STATES[currentState];
  const out = applyCNOT(s.amp);
  const sep = isSeparable(out);
  renderCircuit(s.label, out, s.amp);

  const rb = document.getElementById('result');
  const outDesc = describeState(out);

  if (sep) {
    // For |0⟩ and |1⟩ the output is a product state that "looks like a copy"
    let cloneDesc = '';
    if (currentState === '0') cloneDesc = `|0⟩ ⊗ |0⟩ — looks like two copies of |0⟩!`;
    if (currentState === '1') cloneDesc = `|1⟩ ⊗ |1⟩ — looks like two copies of |1⟩!`;
    rb.className = 'result-box ok';
    rb.innerHTML = fmt(`<strong>Basis state: copy appears to work.</strong>
      Output = %outDesc% = %cloneDesc%
      <div class="bell-note">For basis states the CNOT produces the right result by coincidence. But this only works because the input was already a definite classical bit — no quantum superposition involved. Try |+⟩ or |−⟩ to see the theorem in action.</div>`, { outDesc: outDesc, cloneDesc: cloneDesc });
  } else {
    // Superposition → entangled Bell state
    let expected = currentState === 'plus'
      ? '|+⟩ ⊗ |+⟩ = (|00⟩+|01⟩+|10⟩+|11⟩)/2'
      : '|−⟩ ⊗ |−⟩ = (|00⟩−|01⟩−|10⟩+|11⟩)/2';
    rb.className = 'result-box warn';
    rb.innerHTML = fmt(`<strong>Superposition: cloning fails — output is entangled.</strong>
      Got: %outDesc% (a Bell state)<br>
      Expected for a true copy: %expected%<br>
      <div class="bell-note">The CNOT spread the superposition across both qubits instead of duplicating it. The two qubits are now <em>entangled</em> — measuring one instantly determines the other. This is not two independent copies of the input; it is a completely different state. The no-cloning theorem says no unitary can do better.</div>`, { outDesc: outDesc, expected: expected });
  }
}

document.querySelectorAll('.preset').forEach(btn => {
  btn.addEventListener('click', () => {
    document.querySelectorAll('.preset').forEach(b => b.classList.remove('active'));
    btn.classList.add('active');
    currentState = btn.dataset.state;
    document.getElementById('result').className = 'result-box';
    document.getElementById('result').innerHTML = '';
    document.getElementById('circuit-view').innerHTML =
      '<span style="color:#999;font-size:.85rem">Press Run circuit to see the output.</span>';
  });
});
document.getElementById('run').addEventListener('click', run);

// Initial render placeholder
document.getElementById('circuit-view').innerHTML =
  '<span style="color:#999;font-size:.85rem">Select an input state and press Run circuit.</span>';
Result
Console

Try each preset state and press Run circuit. For ∣0⟩|0\rangle and ∣1⟩|1\rangle the copy looks correct. For ∣+⟩=(∣0⟩+∣1⟩)/2|{+}\rangle = (|0\rangle+|1\rangle)/\sqrt{2} the output is (∣00⟩+∣11⟩)/2(|00\rangle+|11\rangle)/\sqrt{2} — an entangled Bell state, not two independent copies of ∣+⟩|{+}\rangle. The CNOT spreads the superposition across both qubits instead of duplicating it.

The Proof

The no-cloning theorem is proven impossible — not just hard, not NP-complete, but ruled out by the structure of quantum mechanics itself (Wootters & Zurek, 1982).

Here is the core argument. Suppose a unitary operation UU can clone any state:

  • On basis states it would need: U(∣0⟩∣0⟩)=∣0⟩∣0⟩U(|0\rangle|0\rangle) = |0\rangle|0\rangle and U(∣1⟩∣0⟩)=∣1⟩∣1⟩U(|1\rangle|0\rangle) = |1\rangle|1\rangle.
  • Now apply it to a superposition ∣+⟩=(∣0⟩+∣1⟩)/2|{+}\rangle = (|0\rangle + |1\rangle)/\sqrt{2}. By linearity of UU:

U(∣+⟩∣0⟩)=U(∣0⟩∣0⟩)+U(∣1⟩∣0⟩)2=∣00⟩+∣11⟩2U(|{+}\rangle|0\rangle) = \frac{U(|0\rangle|0\rangle) + U(|1\rangle|0\rangle)}{\sqrt{2}} = \frac{|00\rangle + |11\rangle}{\sqrt{2}}

  • But a perfect clone would require:

U(∣+⟩∣0⟩)=∣+⟩∣+⟩=∣00⟩+∣01⟩+∣10⟩+∣11⟩2U(|{+}\rangle|0\rangle) = |{+}\rangle|{+}\rangle = \frac{|00\rangle+|01\rangle+|10\rangle+|11\rangle}{2}

Those two results are different states. Contradiction — no such UU exists.

The argument generalizes: for any two non-orthogonal states ∣ψ⟩|\psi\rangle and ∣ϕ⟩|\phi\rangle, assuming a cloner leads to ∣⟨ψ∣ϕ⟩∣2=∣⟨ψ∣ϕ⟩∣|\langle\psi|\phi\rangle|^2 = |\langle\psi|\phi\rangle|, which is only satisfied when the inner product is 0 or 1 (orthogonal or identical). So non-orthogonal states can never both be cloned by the same device.

What the theorem does NOT forbid:

  • Copying classical information extracted from a measurement (but that collapses the state).
  • Copying a known state — you can prepare as many copies of ∣+⟩|{+}\rangle as you like if you already know it is ∣+⟩|{+}\rangle.
  • Quantum teleportation — which moves a state to another location (destroying the original) without ever violating the theorem.

The theorem sits alongside other fundamental quantum limits: just as Grover's algorithm cannot be sped up beyond its quadratic bound, no cleverness can produce a universal quantum copier.

Where It Matters

The impossibility of cloning is not just a curiosity — it is load-bearing infrastructure for the whole field of quantum information:

  • Quantum key distribution (QKD): in the BB84 protocol (Bennett & Brassard, 1984), Alice sends qubits to Bob in random bases. An eavesdropper (Eve) cannot copy them to read later; any intercept disturbs the state, and Alice and Bob can detect the disturbance. The security proof is exactly the no-cloning theorem.
  • Quantum money: Wiesner (1969, published 1983) proposed banknotes carrying quantum states. A forger cannot copy the state to make duplicates — the first known application of the idea.
  • Quantum error correction: classical error correction copies bits for redundancy. Because qubits cannot be cloned, quantum error correction uses entanglement across multiple physical qubits instead, encoding one logical qubit into many without ever copying the state directly.
  • Quantum repeaters: long-distance quantum networks cannot amplify qubits the way classical repeaters boost signals. Instead they use entanglement swapping — a deep workaround born from the same constraint.
  • Fundamental physics: the theorem is deeply connected to the quantum no-deletion theorem (Pati & Braunstein, 2000), which shows that quantum information cannot be erased either without leaving a trace elsewhere — a striking symmetry.

Every secure quantum channel and every quantum error-correcting code owes its existence to the fact that a qubit cannot be silently duplicated.

Conclusion

The no-cloning theorem is one of the most elegant results in physics: a handful of lines of algebra, using only the linearity that gives quantum computing its power, proves that quantum states can never be silently duplicated.

That limitation is, paradoxically, an asset. It means that any quantum channel is eavesdrop-detectable by physics alone — not by a clever protocol, but by the universe's own rules. It forces quantum error correction to invent entanglement-based redundancy, and it underpins the security of every quantum cryptographic scheme in existence.

The next time you read about a "quantum-safe" encryption system, remember that its safety ultimately traces back to a single word: linearity. The same property that lets a qubit be in a superposition of states is the property that forbids anyone from making a quiet copy — and that is a very deep thing.

Share this article

Pick a channel — or use your device's native share sheet.

Comments

Loading comments...

https://www.kipuhub.com/en/article/no-cloning-theorem/Content licensed under CC BY-NC 4.0.