Part IV. Protocols and Algorithms · Chapter 25

Teleportation

Teleportation moves a qubit's state without moving the qubit — and without copying it. The price is a Bell pair, two classical bits, and the destruction of the original; this chapter traces where every one of those goes.

Steven GellerPublished July 25, 2026Revised August 14, 2026

Lab

In this chapter 8 sections

Reader question. How does quantum teleportation transfer an unknown qubit state using shared entanglement and two classical bits?

The sender entangles the input with her half of a Bell pair, measures two qubits, and sends the two-bit result; the receiver applies a corresponding Pauli correction, recovering the input state while the original is destroyed.

Scope and non-goals.

This chapter does not transport matter, send information faster than light, or clone the input.
It does not treat entanglement distribution and classical communication as free infrastructure.

Figure 25.1. Notice the direction of dependency: the classical bits flow down to Bob's correction gate, and until they arrive his wire carries nothing usable.

Ownership and resources before gates

Label input, Bell pair, parties, and classical channel.

Teleportation moves the state of a qubit from Alice's hardware to Bob's without moving the qubit itself. Nothing material travels; nothing is copied; nothing arrives before the classical message does. The protocol consumes one shared Bell pair and two classical bits, and it destroys the original in the process.

The ledger, up front:

input: one unknown qubit state at Alice's side;
shared resource: one Bell pair, split between Alice and Bob;
classical communication: two bits from Alice to Bob;
output: Bob's qubit in the original state, after his correction;
side effect: Alice's original is gone; her measurement consumed it.

Evidence boundary. Quantum teleportation transfers an unknown state using shared entanglement and two classical bits. [Charles H. Bennett et al.] [Michael A. Nielsen]

Expand the state by measurement branch

Rewrite the three-qubit state in the Bell-measurement basis.

Write the unknown input as:

\lvert\psi\rangle=\alpha\lvert0\rangle+\beta\lvert1\rangle

Alice and Bob share a Bell pair:

(\lvert00\rangle+\lvert11\rangle)/\sqrt2

Alice entangles the input with her half of the pair; CNOT from the input to her half, then H on the input; and measures both of her qubits. The measurement update rule describes what remains:

\lvert\psi_i\rangle=\frac{P_i\lvert\psi\rangle}{\sqrt{\langle\psi\rvert P_i\lvert\psi\rangle}}

Her two measurement bits identify which of four conditional states Bob's qubit now holds; each is $\lvert\psi\rangle$ up to one known correction from ${ I , X , Z , X Z }$ . Alice sends the bits; Bob applies the matching correction; his qubit is exactly $\lvert\psi\rangle$ . Until the bits arrive, Bob's qubit is; to him; a maximally mixed object carrying nothing.

Evidence boundary. The protocol destroys the sender's original state and is consistent with no-cloning. [Charles H. Bennett et al.] [William K. Wootters]

Two classical bits select four corrections

Derive the correction table.

First: teleportation is instant. It is not. Bob's reconstruction is gated on two classical bits traveling no faster than light, and before they arrive his qubit tells him nothing. The protocol transfers quantum state at the speed of a phone call plus a Bell pair.

Second: teleportation copies the input. It cannot; Chapter 21's theorem forbids it, and the protocol respects the theorem by construction: Alice's measurement destroys the original as the price of the transfer. A fax machine that burns the original is closer to the truth than a photocopier at a distance.

Evidence boundary. Classical communication is required before the receiver can select the correction, preventing faster-than-light signaling. [John Preskill] [John Watrous]

\lvert\psi\rangle=\alpha\lvert0\rangle+\beta\lvert1\rangle,\qquad F=\lvert\langle\psi\vert\phi\rangle\rvert^2

One branch traced from α,β to recovery

Follow measurement, message, and correction.

For a builder, teleportation is a distributed protocol with quantum and classical dependencies; not a gate. It earns its place as a primitive for quantum networking, modular architectures that move states between processors, and fault-tolerant circuit constructions, always with its costs attached.

The dependency graph every compiler, scheduler, or architecture memo must respect:

shared entanglement, prepared and distributed earlier;
a Bell measurement that consumes the input;
two classical bits in transit;
a conditional correction that finishes the reconstruction.

Delete any edge and the protocol fails: without fresh entanglement it degrades, without the classical bits it stalls, without the correction it outputs the wrong state confidently.

Latency and fidelity enter the network contract

Account for distribution, feed-forward, and verification.

When a networking or modular-computing pitch leans on teleportation, ask how entanglement is generated and at what rate, how its fidelity is maintained across distance or time, what the classical latency does to throughput, how corrections are applied, and which workload actually benefits.

Teleportation is real, demonstrated, and genuinely useful as a building block. It is also never free: the interesting engineering is always in the entanglement supply chain the pitch may prefer not to discuss.

Teleportation branch verifier

Acceptance contract for Teleportation branch verifier
Field	Reader-visible record
Format	Three-qubit symbolic/numerical circuit with branch-conditioned corrections
Verification	Tests random input states across all measurement branches, verifies receiver fidelity one ideally, and asserts no receiver recovery before classical bits arrive.
Availability	Source-embedded acceptance record; no separate download is claimed

{
  "artifact": "Teleportation branch verifier",
  "format": "Three-qubit symbolic/numerical circuit with branch-conditioned corrections",
  "acceptance_test": "Tests random input states across all measurement branches, verifies receiver fidelity one ideally, and asserts no receiver recovery before classical bits arrive.",
  "publication_state": "source-embedded contract and worked fixture"
}

Executable reference fixture

Run with Python 3.11 or later. The final assertion is the chapter-level pass condition for this small instance.

import math
import random

def normalize(alpha, beta):
    norm = math.sqrt(abs(alpha) ** 2 + abs(beta) ** 2)
    if norm < 1e-15:
        raise ValueError("the zero vector is not a quantum state")
    return alpha / norm, beta / norm

def h(state, qubit):
    mask = 1 << (2 - qubit)
    output = state[:]
    scale = math.sqrt(0.5)
    for basis in range(8):
        if basis & mask == 0:
            paired = basis | mask
            output[basis] = (state[basis] + state[paired]) * scale
            output[paired] = (state[basis] - state[paired]) * scale
    return output

def cnot(state, control, target):
    control_mask = 1 << (2 - control)
    target_mask = 1 << (2 - target)
    output = [0j] * 8
    for basis, amplitude in enumerate(state):
        output[basis ^ target_mask if basis & control_mask else basis] += amplitude
    return output

def alice_circuit(alpha, beta):
    state = [0j] * 8
    state[0] = alpha
    state[4] = beta
    state = cnot(h(state, 1), 1, 2)
    state = h(cnot(state, 0, 1), 0)
    return state

def receiver_branch(state, first, second):
    amplitudes = [state[(first << 2) | (second << 1) | bob] for bob in (0, 1)]
    probability = sum(abs(value) ** 2 for value in amplitudes)
    if probability < 1e-15:
        raise ValueError("impossible measurement branch")
    return probability, tuple(value / math.sqrt(probability) for value in amplitudes)

def correct(receiver, first, second):
    zero, one = receiver
    if second:
        zero, one = one, zero
    if first:
        one = -one
    return zero, one

def fidelity(left, right):
    overlap = left[0].conjugate() * right[0] + left[1].conjugate() * right[1]
    return abs(overlap) ** 2

def reduced_receiver(branches):
    rho = [[0j, 0j], [0j, 0j]]
    for probability, receiver in branches:
        for row in (0, 1):
            for column in (0, 1):
                rho[row][column] += probability * receiver[row] * receiver[column].conjugate()
    return rho

rng = random.Random(2501)
states = [normalize(1, 0), normalize(0, 1), normalize(1, 1j), normalize(3 - 2j, -1 + 4j)]
for _ in range(12):
    states.append(normalize(complex(rng.uniform(-1, 1), rng.uniform(-1, 1)),
                            complex(rng.uniform(-1, 1), rng.uniform(-1, 1))))

minimum_fidelity = 1.0
for psi in states:
    state = alice_circuit(*psi)
    branches = []
    for first in (0, 1):
        for second in (0, 1):
            probability, receiver = receiver_branch(state, first, second)
            assert abs(probability - 0.25) < 1e-12
            corrected = correct(receiver, first, second)
            branch_fidelity = fidelity(psi, corrected)
            minimum_fidelity = min(minimum_fidelity, branch_fidelity)
            assert abs(branch_fidelity - 1.0) < 1e-12
            branches.append((probability, receiver))
    rho = reduced_receiver(branches)
    assert abs(rho[0][0] - 0.5) < 1e-12 and abs(rho[1][1] - 0.5) < 1e-12
    assert abs(rho[0][1]) < 1e-12 and abs(rho[1][0]) < 1e-12
    unavailable_fidelity = sum((psi[row].conjugate() * rho[row][column] * psi[column]).real
                               for row in (0, 1) for column in (0, 1))
    assert abs(unavailable_fidelity - 0.5) < 1e-12

witness = normalize(1, 2j)
witness_state = alice_circuit(*witness)
mutated_failures = 0
for first in (0, 1):
    for second in (0, 1):
        _, receiver = receiver_branch(witness_state, first, second)
        wrong = correct(receiver, second, first)
        mutated_failures += fidelity(witness, wrong) < 1.0 - 1e-9
assert mutated_failures > 0
rejected_zero = False
try:
    normalize(0, 0)
except ValueError:
    rejected_zero = True
assert rejected_zero
print(f"PASS: 25 teleportation states={len(states)} minimum_fidelity={minimum_fidelity:.12f} swapped_correction_failures={mutated_failures}")

Scope boundary

This chapter does not transport matter, send information faster than light, or clone the input.
It does not treat entanglement distribution and classical communication as free infrastructure.

Depth commitment. One general derivation, one explicit input, four branches, and randomized property tests.

Practice problem

Teleport $\lvert\psi\rangle=(\lvert0\rangle+i\lvert1\rangle)/\sqrt{2}$ and calculate the receiver state and correction in each of four measurement branches.

Deliverable: Four branch rows with probabilities, pre-correction states, operations, and corrected fidelity.
Pass condition: The branch verifier samples or conditions every result and compares corrected states with |ψ> up to global phase.

Verification record

Expected solution form. Symbolic correction table plus randomized-state property test.

Model answer. Before correction, receiver branches are psi, X psi, Z psi, and XZ psi for measurement records 00, 01, 10, and 11 in the declared convention. Applying I, X, Z, and ZX respectively returns (|0>+i|1>)/sqrt(2) with fidelity one in every branch.

Model result and check. CI tests multiple random normalized inputs and all branches for fidelity one.

Acceptance test. The branch verifier samples or conditions every result and compares corrected states with |ψ> up to global phase.

Companion work

Artifacts for this chapter

These entries resolve to checked-in local source. Commands are reproduced exactly from the chapter manifest, and source-embedded fixtures are exported as direct downloads.

protocol fixture
Teleportation branch verifier
Download fixture (.py)Verification record (.json)
Reproduce or test
python3 tools/validate_briefs.py --briefs data/editorial_briefs_00_35.json --from 0 --through 35 --check-rewritten-sources --execute-artifacts

Provenance

Sources and review

The load-bearing claims in the chapter are mapped inline to this registered source set. A citation supports only the bounded claim beside it.

External review: Open.

How review works Revision history Report or inspect errata

Book contents

Part IV. Protocols and Algorithms

Teleportation

Ownership and resources before gates

Expand the state by measurement branch

Two classical bits select four corrections

One branch traced from α,β to recovery

Latency and fidelity enter the network contract

Teleportation branch verifier

Artifacts for this chapter

Teleportation branch verifier

Sources and review

Cite this chapter

Ownership and resources before gates#

Expand the state by measurement branch#

Two classical bits select four corrections#

One branch traced from α,β to recovery#

Latency and fidelity enter the network contract#

Teleportation branch verifier#

Artifacts for this chapter

Teleportation branch verifier

Sources and review

Prerequisites for this chapter

Next concepts from this chapter

Ownership and resources before gates

Expand the state by measurement branch

Two classical bits select four corrections

One branch traced from α,β to recovery

Latency and fidelity enter the network contract

Teleportation branch verifier