Quantum Teleportation

What teleportation actually moves

An unknown qubit is a vector |ψ⟩ = α|0⟩ + β|1⟩ on the Bloch sphere, where α and β are complex amplitudes with |α|² + |β|² = 1. The catch: you cannot measure |ψ⟩ to learn α and β. A single measurement collapses it to |0⟩ or |1⟩ and tells you almost nothing about the continuous amplitudes. And by the no-cloning theorem you cannot copy it to measure repeatedly. So how do you get this fragile, unmeasurable state from Alice to Bob without sending the particle itself across a noisy channel?

Quantum teleportation, devised by Bennett, Brassard, Crépeau, Jozsa, Peres, and Wootters in 1993, solves it. Alice and Bob first share an entangled pair. Alice performs a joint Bell measurement on her unknown qubit together with her half of the pair. She gets two random classical bits and sends them to Bob. Bob applies one of four fixed rotations, and his qubit is now in exactly the state |ψ⟩. The information teleported; no atoms were beamed anywhere.

The three ingredients

Ingredient	Role	Cost per qubit
Shared entangled pair (EPR pair / ebit)	The quantum channel that carries correlation, set up in advance	1 ebit (one Bell pair)
Bell measurement	Joint measurement on input + Alice's half; destroys the input	4 outcomes
Classical bits	Tell Bob which Pauli correction to apply; gate causality	2 bits

None of these alone does anything useful. Entanglement without classical bits gives Bob noise. Classical bits without entanglement give Bob nothing about the amplitudes. The protocol's elegance is that the two resources combine to do what neither can do alone.

Setting up the state

Start with the state to teleport on Alice's input qubit (call it qubit 1):

|ψ⟩₁ = α|0⟩ + β|1⟩

Alice and Bob share a Bell pair — the standard choice is the maximally entangled |Φ⁺⟩ on qubits 2 (Alice) and 3 (Bob):

|Φ⁺⟩₂₃ = (|00⟩ + |11⟩) / √2

The full three-qubit state is the product:

|Ψ⟩₁₂₃ = (α|0⟩ + β|1⟩) ⊗ (|00⟩ + |11⟩)/√2
       = ( α|000⟩ + α|011⟩ + β|100⟩ + β|111⟩ ) / √2

Rewriting in the Bell basis

The trick is to re-express qubits 1 and 2 (the two Alice holds) in the Bell basis instead of the computational basis. The four Bell states are:

|Φ⁺⟩ = (|00⟩ + |11⟩)/√2     |Φ⁻⟩ = (|00⟩ − |11⟩)/√2
|Ψ⁺⟩ = (|01⟩ + |10⟩)/√2     |Ψ⁻⟩ = (|01⟩ − |10⟩)/√2

Inverting these and substituting, the joint state factorizes exactly into four equally weighted terms, each pairing one Bell state of Alice's qubits with a specific transformation of Bob's qubit:

|Ψ⟩₁₂₃ = ½ [ |Φ⁺⟩₁₂ (α|0⟩ + β|1⟩)₃
            + |Φ⁻⟩₁₂ (α|0⟩ − β|1⟩)₃
            + |Ψ⁺⟩₁₂ (β|0⟩ + α|1⟩)₃
            + |Ψ⁻⟩₁₂ (β|0⟩ − α|1⟩)₃ ]

Look at what is sitting next to each Bell state on qubit 3: it is |ψ⟩ acted on by a Pauli operator. This algebraic identity is the entire protocol. Bob's qubit already contains |ψ⟩ — up to one of four known rotations.

Measure, send, correct

Alice now measures qubits 1 and 2 in the Bell basis. The four outcomes are equally likely (probability ¼ each). Her two classical result bits tell Bob exactly which term collapsed, and therefore which inverse to apply:

Bell outcome	Classical bits sent	Bob's qubit before fix	Correction Bob applies
|Φ⁺⟩	00	α|0⟩ + β|1⟩	I (do nothing)
|Φ⁻⟩	01	α|0⟩ − β|1⟩	Z
|Ψ⁺⟩	10	β|0⟩ + α|1⟩	X
|Ψ⁻⟩	11	β|0⟩ − α|1⟩	ZX

After Bob applies the indicated Pauli gate, his qubit is in the state α|0⟩ + β|1⟩ — bit for bit, amplitude for amplitude, the original |ψ⟩. Alice's qubits 1 and 2 are now collapsed Bell states holding no trace of α or β. The state has moved, not copied.

The standard circuit

In the gate model the protocol is just a handful of gates. Alice applies a CNOT from the input onto her half of the pair, then a Hadamard on the input, then measures both. Bob applies X then Z conditioned on those two bits.

// Single-qubit state vector teleportation (statevector simulation)
// Qubit 1 = unknown input, Qubit 2 = Alice's EPR half, Qubit 3 = Bob's EPR half

function teleport(alpha, beta) {
  // --- Build 3-qubit state |psi> (x) |Phi+> ---
  // amplitudes indexed by 3-bit integer q1 q2 q3
  const s = new Array(8).fill(0).map(() => [0, 0]); // [re, im]
  const inv2 = 1 / Math.SQRT2;
  // |psi> = a|0> + b|1>; |Phi+> = (|00>+|11>)/sqrt2
  // |000>: a/sqrt2  |011>: a/sqrt2  |100>: b/sqrt2  |111>: b/sqrt2
  s[0b000] = [alpha[0] * inv2, alpha[1] * inv2];
  s[0b011] = [alpha[0] * inv2, alpha[1] * inv2];
  s[0b100] = [beta[0]  * inv2, beta[1]  * inv2];
  s[0b111] = [beta[0]  * inv2, beta[1]  * inv2];

  const bit = (i, q) => (i >> (2 - q)) & 1;      // q in {0,1,2} -> qubits 1,2,3
  const flip = (i, q) => i ^ (1 << (2 - q));

  // --- CNOT control=qubit1, target=qubit2 ---
  let t = s.map(a => a.slice());
  for (let i = 0; i < 8; i++) if (bit(i, 0) === 1) t[flip(i, 1)] = s[i];
  // careful in-place: rebuild cleanly
  t = new Array(8).fill(0).map(() => [0, 0]);
  for (let i = 0; i < 8; i++) {
    const j = bit(i, 0) === 1 ? flip(i, 1) : i;
    t[j] = s[i];
  }
  s.splice(0, 8, ...t);

  // --- Hadamard on qubit1 ---
  const h = new Array(8).fill(0).map(() => [0, 0]);
  for (let i = 0; i < 8; i++) {
    const i0 = i & ~(1 << 2);          // qubit1 = 0
    const i1 = i | (1 << 2);           // qubit1 = 1
    const sign = bit(i, 0) === 0 ? 1 : -1;
    // H|x> = (|0> + (-1)^x|1>)/sqrt2 ; recompute below cleanly
  }
  // (full Hadamard + Bell-readout omitted for brevity — see Qiskit/Cirq for runnable code)
  return "Bob holds alpha|0>+beta|1> after applying the Pauli fixed by Alice's 2 bits";
}

// The key invariant proven by the algebra:
//   Bell result 00 -> Bob applies I
//   Bell result 01 -> Bob applies Z
//   Bell result 10 -> Bob applies X
//   Bell result 11 -> Bob applies ZX (X first, then Z)
console.log(teleport([0.6, 0], [0.8, 0])); // |psi> = 0.6|0> + 0.8|1>

On real hardware you would express this in Qiskit or Cirq with three qubits, a Bell-pair preparation, a CNOT + H on the sender side, two mid-circuit measurements, and classically controlled X and Z gates on the receiver. Running it and reading Bob's qubit confirms the input amplitudes are reconstructed (up to gate noise).

Why there is no faster-than-light signaling

The moment Alice measures, Bob's qubit instantly becomes one of the four rotations of |ψ⟩. It is tempting to think information jumped across instantly. It did not. From Bob's local point of view — before the two bits arrive — his qubit is a uniform mixture over all four possibilities:

ρ_Bob = ¼ ( I·|ψ⟩⟨ψ|·I + Z|ψ⟩⟨ψ|Z + X|ψ⟩⟨ψ|X + ZX|ψ⟩⟨ψ|XZ ) = I/2

That is the maximally mixed state — pure noise, independent of α and β. Bob learns nothing until the classical bits arrive over a light-speed-limited channel. This is the same reason entanglement on its own can never transmit a message: local statistics are untouched by a distant measurement.

Real experiments and numbers

Demonstration	System	Scale / fidelity
Innsbruck / Rome, 1997	Photon polarization	First demo; meters of optical table
Canary Islands, 2012	Free-space photons	143 km, ground to ground
China "Micius" satellite, 2017	Photons, ground to orbit	Up to ≈1400 km uplink
Delft / Calgary fiber, 2016	Telecom-wavelength photons	≈6–44 km of deployed city fiber
Trapped ions / NV diamond	Matter qubits	Deterministic, ~3 m, fidelity > 0.8

Photonic demos are usually probabilistic because a complete Bell measurement with linear optics succeeds only part of the time — standard beam-splitter Bell analyzers distinguish at most 2 of the 4 Bell states, capping efficiency at 50%. Matter-qubit experiments achieve deterministic teleportation by using full Bell measurements on stationary qubits, which is exactly what quantum repeaters need to stitch entanglement across long links.

Where teleportation is used

• Quantum repeaters. Long-distance entanglement is built by teleporting (entanglement-swapping) across a chain of short links, beating the exponential loss of sending photons straight down a fiber.
• Quantum networks / internet. Teleportation moves qubits between distant nodes without exposing them to the lossy channel directly.
• Gate teleportation. Hard gates (like T gates) are applied by teleporting through specially prepared resource states — the backbone of fault-tolerant magic-state distillation.
• Measurement-based quantum computing. The whole model is repeated teleportation through a cluster state, with computation steered by measurement outcomes.
• Quantum cryptography. Teleportation-based relays keep keys secure across untrusted intermediate nodes.

Common misconceptions

• "Matter is teleported." No — only the quantum state. Bob's qubit was already there; it just gets reconfigured into |ψ⟩.
• "It's instantaneous communication." No — it stalls until two classical bits arrive at sub-light speed. Causality is intact.
• "It clones the qubit." No — the Bell measurement destroys the original, so there is never a second simultaneous copy. No-cloning holds.
• "Two bits can't carry a full qubit." They don't carry it alone — the pre-shared ebit does the heavy lifting. The two bits only select which of four corrections undoes the random Bell collapse.
• "You can skip the correction." No — without the Pauli fix Bob holds a random rotation of |ψ⟩, useless on average (the I/2 mixed state).
• "Teleportation reveals the state." No — neither Alice nor Bob ever learns α and β. The state is moved blind; the amplitudes stay unmeasured throughout.