Case Study: Teleportation as Architecture — Repeaters and Gate Teleportation

Executive Summary

Teleportation is presented as a communication trick and is in practice an architectural primitive. Two of the most consequential structures in quantum technology are teleportation wearing different clothes: the quantum repeater, which is the only known way to distribute entanglement over continental distances, and gate teleportation, which is how every fault-tolerant architecture applies the gates it cannot apply directly.

This case study works both, quantitatively, and shows they are the same idea.

Skills applied

• Analyzing entanglement swapping and repeater chains (§9.14).
• Computing fidelity and rate degradation across repeater segments.
• Understanding gate teleportation and its role in magic-state consumption (§9.16).
• Connecting the Eastin–Knill theorem to architectural cost.

Part A: Quantum Repeaters

Phase A1: Why direct transmission fails

Photon loss in optical fibre is exponential: at 0.2 dB/km, transmission over distance $L$ is

$$\eta(L) = 10^{-0.02 L}$$

Classical networks solve this with amplifiers. Quantum networks cannot: the no-cloning theorem forbids amplifying an unknown quantum state. This is not an engineering gap — it is a theorem.

Phase A2: Entanglement swapping

The repeater's move: instead of sending a photon 1,000 km, establish entanglement over 100 km segments and fuse them.

Alice—R₁ share a Bell pair. R₁—R₂ share a Bell pair. R₁ performs a Bell measurement on its two qubits — one from each pair — and broadcasts the two-bit outcome. The result: Alice and R₂ are now entangled, despite never having interacted.

That is exactly teleportation, applied to half of an entangled pair rather than to an ordinary qubit. Teleporting one member of an entangled pair transfers its entanglement.

$$\text{Alice}-R_1,\ R_1-R_2 \quad \xrightarrow{\text{Bell measurement at } R_1} \quad \text{Alice}-R_2$$

Phase A3: The cost of chaining

Two quantities degrade along the chain.

Fidelity. Swapping two pairs of fidelity $F$ gives approximately

$$F_{\text{swap}} \approx F^2 + \frac{(1-F)^2}{3}$$

Chaining $n$ segments at $F = 0.99$: after 2 segments 0.980, after 4 segments 0.961, after 8 segments 0.925, after 16 segments 0.857. Fidelity decays roughly geometrically, which is why entanglement purification — consuming several low-fidelity pairs to distill one higher-fidelity pair — is mandatory in any real repeater design, not optional.

Rate. Every swap requires both input pairs to be ready simultaneously. With probabilistic entanglement generation of success probability $p$ per attempt, the rate for a chain of $2^k$ segments falls off sharply, because the expected waiting time for both branches is worse than for either alone. Quantum memories that can hold a qubit while the other branch succeeds are therefore the critical enabling technology — and their coherence time sets the maximum practical chain length.

Finding. A repeater is entanglement swapping plus purification plus memory. Remove any one and the chain does not scale.

Part B: Gate Teleportation

Phase B1: The problem it solves

In a fault-tolerant architecture, Clifford gates can be applied transversally — bitwise across the code block, so an error on one physical qubit cannot spread within the block. Transversal gates are the cheap, safe way to compute on encoded data.

The Eastin–Knill theorem says no quantum error-correcting code admits a transversal universal gate set. Since Clifford gates are typically the transversal ones, the missing piece is a non-Clifford gate — conventionally $T$. It cannot be applied transversally on the surface code, and therefore cannot be applied directly at all.

Phase B2: The trick

Prepare a magic state

$$|A\rangle = \frac{1}{\sqrt2}\left(|0\rangle + e^{i\pi/4}|1\rangle\right)$$

then consume it via a teleportation-like circuit: a CNOT between the data qubit and the magic state, a measurement, and a Clifford correction conditioned on the outcome. The output is $T$ applied to the data qubit, using only Clifford operations and measurement.

The non-Clifford resource has been moved out of the circuit and into a prepared state. That relocation is the entire point: states can be prepared offline, in parallel, and verified before use, whereas gates must be applied in-line on live data.

Phase B3: The cost

Magic states cannot be prepared perfectly — preparation is itself noisy. Magic-state distillation consumes many noisy copies to produce fewer, better ones. A standard 15-to-1 protocol takes 15 states with error $\epsilon$ and yields one with error $\approx 35\epsilon^3$.

Starting from $\epsilon = 10^{-3}$:

Two rounds reach the $10^{-15}$ error typically required for a large algorithm, at 225 raw magic states per usable $T$ gate — each raw state itself encoded in a surface-code patch of perhaps a thousand physical qubits.

Finding. A single logical $T$ gate can cost more physical resources than an entire logical Clifford circuit. This is why fault-tolerant resource estimates are quoted in $T$-count, and why "magic state factories" occupy the majority of the chip area in surface-code architectures.

Phase B4: The unifying observation

Both halves of this case study are the same protocol:

Teleportation is a general mechanism for converting a prepared resource state plus measurement plus classical communication into an operation you could not otherwise perform. Distance and non-Cliffordness are two instances of "otherwise impossible."

Discussion Questions

1. No-cloning forbids amplifying quantum signals, which is why repeaters exist. Explain why entanglement swapping is not a disguised form of amplification.
2. Repeater fidelity degrades geometrically with segment count. Why does purification break the geometric decay rather than merely slowing it?
3. Eastin–Knill forbids transversal universality. Why does gate teleportation not violate it?
4. Magic-state factories dominate chip area in surface-code designs. What does that imply for algorithm design — which resource should an algorithm designer minimize?

Your Turn: Extensions

• Simulate entanglement swapping on 4 qubits and verify the end qubits are entangled by measuring CHSH.
• Compute the chained fidelity for 2, 4, 8, 16 segments starting at $F = 0.95$ and find the segment count where it drops below 0.5.
• Implement gate teleportation for $T$ using a prepared magic state and verify against a direct $T$.
• Estimate the total $T$-count of Shor's algorithm for RSA-2048 from a published resource estimate, and convert to raw magic states at 15-to-1 distillation.

Key Takeaways

• No-cloning rules out quantum amplifiers, so long-distance entanglement requires repeaters — which are entanglement swapping, i.e. teleportation applied to half of a Bell pair.
• Repeater chains need swapping and purification and quantum memory; fidelity otherwise decays geometrically with segment count.
• Eastin–Knill forbids a transversal universal gate set, so non-Clifford gates are applied by consuming prepared magic states via gate teleportation.
• Magic-state distillation is the dominant cost of fault-tolerant computation, which is why $T$-count is the standard resource metric.
• Teleportation's general form: a prepared resource state plus measurement plus classical bits buys an operation otherwise unavailable.