Distributed Quantum Computing

A distributed quantum computer is a collection of small quantum processors — each holding a modest register of qubits — wired together by two very different kinds of link: quantum channels that distribute entanglement between the nodes, and classical channels that carry measurement outcomes and control signals. The motivation is entirely physical. A monolithic device is capped by how many high-quality qubits one can co-locate, cool, and control coherently in a single package, so the natural route to scale is to partition one large computation across many small modules. The theoretical payoff is a theorem with a slogan: given enough shared entanglement and classical communication, a network of small processors can execute any circuit a large machine could, with only a constant-factor overhead per gate that crosses between nodes. The whole subject is organised by one resource — the Einstein–Podolsky–Rosen (EPR) pair — and one rule for using it — local operations and classical communication (LOCC). Two protocols do all the work. Quantum teleportation moves an unknown qubit across the network by consuming one Bell pair and two classical bits, with no qubit ever traversing the quantum channel. Gate teleportation turns that idea sideways: teleport the data through a gate rather than an identity, and a two-qubit operation acts between qubits held at different nodes. A nonlocal CNOT, the canonical case, costs exactly one Bell pair and one classical bit each way. The expensive quantum link is therefore used only offline, to mint generic Bell pairs in advance; at runtime only classical bits fly. Because real channels are noisy, the entanglement that fuels the machine must be purified by distillation and stitched into long range by entanglement swapping — the bookkeeping of ebits and cbits that turns a rack of small chips into one computer.

Key takeaways

Distributed quantum computing (DQC) partitions an algorithm across nodes joined by quantum channels (to share entanglement) and classical channels (to carry control), reproducing the logic of one monolithic machine.
The universal primitive is the EPR pair used under LOCC: one shared Bell state and two classical bits teleport an arbitrary qubit, and gate teleportation moves nonlocal gates onto pre-shared entanglement.
A nonlocal CNOT between two nodes costs exactly one Bell pair and two classical bits — one cbit each way — through the cat-entangler / cat-disentangler construction, and this is optimal.
Entanglement is a strictly conserved, consumable currency: LOCC can never raise it (it is a monotone), so every nonlocal entangling gate must spend an ebit that was distributed in advance.
Noisy links are healed offline: entanglement distillation upgrades many low-fidelity pairs into fewer high-fidelity ones, and entanglement swapping extends Bell pairs across repeater chains.
DQC is dual to measurement-based computation — a cluster state spread across nodes is already a distributed machine — and connects to fault tolerance through lattice surgery and magic-state injection.
Key idea: a shared EPR pair plus classical communication converts a nonlocal quantum gate into local operations — one Bell pair and two cbits per direction implement a nonlocal CNOT — so entanglement (distributed in advance) and classical bits (sent at runtime) are the two currencies that let small processors act as one large machine.

Where this lives today

Distributed quantum computing has moved from resource theory to running hardware. Trapped-ion groups have executed genuine nonlocal gates between physically separate modules: a photon heralds a Bell pair linking matter qubits in two traps, and gate teleportation then enacts a CNOT across the gap — the Oxford and Delft programmes have demonstrated deterministic teleported two-qubit gates and even a distributed algorithm run across a photonic network link, with the quantum channel used only to mint entanglement. Commercial roadmaps are built on the same idea: Quantinuum's QCCD ion-trap machines shuttle and interconnect zones, IonQ pursues photonic interconnects between cores, and IBM's modular plan couples chips with short-range links and classical feed-forward. In parallel, the quantum-internet effort — Delft's multi-node network, fibre and free-space repeater testbeds, and the Micius satellite that distributed entangled pairs across more than a thousand kilometres — is engineering the entanglement-swapping and distillation stack that will supply ebits at scale. The open frontier is the compiler and the budget: partitioning large algorithms to minimise the entanglement crossing node boundaries, distilling raw links up to gate-quality fidelity fast enough, and merging distributed error-correcting patches by lattice surgery — turning a rack of small, imperfect processors into one fault-tolerant machine whose elementary act is still a single shared Bell pair.

The physical picture

Picture two chess players at distant boards who must make a single coordinated, genuinely entangling move. Each can touch only their own piece — a local operation — and phone the other — classical communication. No amount of talking lets them create a correlation that was not somehow arranged in advance; to enact a joint move neither could make alone they must have set up a shared Bell pair beforehand. The Bell pair is the pre-arranged quantum correlation, the phone call carries a random measurement outcome, and the recipient applies a correction conditioned on it. Together those three ingredients enact a gate that spans the gap. Teleportation is the atom of this idea: a qubit's information can be relocated as two classical bits riding on one unit of pre-shared entanglement, the original destroyed in the act. Gate teleportation runs the same machinery through a gate rather than an identity, so the gate acts "in transit" between nodes.

Figure

A nonlocal CNOT between Node A and Node B consumes exactly one shared Bell pair Φ⁺ (one ebit) and two classical bits — the outcome x sent A→B and z sent B→A — while no data qubit ever crosses the quantum channel, so the total cost is 1 ebit + 2 cbit

Entanglement is a conserved, distillable currency, and this is what makes DQC an accounting discipline. You spend Bell pairs to perform nonlocal gates, and you replenish them by purifying noisy raw pairs — because no local shuffling and no volume of phone calls can ever manufacture an ebit from nothing. The quantum and classical channels play deliberately asymmetric roles. The quantum link is used offline and asynchronously: distribute Bell pairs whenever a photon happens to be heralded, store them, and retry on failure, all long before the algorithm runs. Only the classical link must be fast at runtime, because feed-forward corrections cannot wait. This asymmetry is why a distributed processor tolerates a slow, lossy quantum channel far better than one might guess — link speed is decoupled from gate speed. The second figure shows the machinery that keeps the currency spendable: entanglement distillation, which trades many mediocre pairs for one good one.

Figure

Entanglement distillation with the BBPSSW recurrence F′ = (F² + (1/9)(1−F)²) / (F² + (2/3)F(1−F) + (5/9)(1−F)²): two Werner pairs of fidelity F yield one pair of fidelity F′ whenever F > 1/2. Starting at F = 0.70 gives F′ = 0.735 with success probability 0.68 — the blue curve bows above the diagonal, so iterating drives fidelity toward 1

The core equations

The resource that fuels everything is a single maximally entangled pair — one ebit — shared one qubit per node. Every protocol below is a way of spending it.

|\Phi^+\rangle = \tfrac{1}{\sqrt{2}}\big(|00\rangle + |11\rangle\big) \qquad (1)

where: $|\Phi^+\rangle$ — one of the four Bell states, the standard maximally entangled two-qubit resource, worth exactly one ebit; $|00\rangle,|11\rangle$ — computational basis states of the pair, the first qubit held at node A, the second at node B. Reading: the state is symmetric between the nodes, and either half examined alone is the maximally mixed $I/2$ — all the value lives in the correlation, which is why distributing this state is the only thing the quantum channel is ever asked to do. Teleportation is the identity protocol of the network: it relocates an arbitrary qubit using one ebit and two cbits, with no qubit crossing the channel. A Bell measurement on Alice's side collapses Bob's half onto the input up to a Pauli named by the two outcome bits.

|\psi\rangle_A\,|\Phi^+\rangle_{AB} \;\xrightarrow{\text{Bell meas. on }A}\; \tfrac{1}{2}\sum_{j=0}^{3} (\sigma_j|\psi\rangle)_B \otimes |\beta_j\rangle_A \qquad (2)

where: $|\psi\rangle$ — the arbitrary unknown qubit to be transferred; $\sigma_j\in\{I,X,Z,XZ\}$ — the Pauli correction indexed by the two-bit outcome $j$ ; $|\beta_j\rangle$ — the Bell state Alice's measurement projects onto. Reading: each of the four outcomes occurs with probability $\tfrac14$ (the amplitude $\tfrac12$ squared), and until the two bits reach Bob his qubit is $I/2$ — no signal has travelled, only a correlation has been consumed. Gate teleportation is the engine of distributed computing: replace the identity channel by a gate $U$ , prepared offline into the resource state, and the same Bell measurement delivers $U|\psi\rangle$ instead of $|\psi\rangle$ .

(I\otimes\langle\Phi^+|)\big(|\psi\rangle\otimes(U\otimes I)|\Phi^+\rangle\big)\ \propto\ U|\psi\rangle \qquad (3)

where: $(U\otimes I)|\Phi^+\rangle$ — the resource state, a gate applied to half a Bell pair and stored in advance; $\langle\Phi^+|$ — a Bell measurement projecting the input against the resource. Reading: the output is $U|\psi\rangle$ up to a Pauli byproduct set by the measurement outcome, so the expensive gate is performed before the data arrives and only cheap Pauli corrections happen at runtime — the reason Clifford gates distribute almost for free. The target of a distributed program is a two-qubit gate whose qubits live on different nodes; the CNOT is the maximally entangling representative and its distributed cost is the field's headline number.

\mathrm{CNOT}_{c\to t}\ =\ 1\ \text{ebit} + 1\ \text{cbit}_{A\to B} + 1\ \text{cbit}_{B\to A} \qquad (4)

where: $c$ — control data qubit at node A; $t$ — target data qubit at node B; the two cbits carry the cat-entangler outcome $x$ and the cat-disentangler outcome $z$ . Reading: one shared Bell pair plus one classical bit each way suffices, and no fewer resources can work — this is the optimal cost of a maximally entangling nonlocal gate, derived below and matching Eisert et al. Why the ebit is not optional is a theorem about entanglement itself: it is a monotone under LOCC, quantified for pure states by the entropy of a reduced density matrix.

E(\rho_{AB})=S(\rho_A)=-\mathrm{Tr}(\rho_A\log_2\rho_A),\qquad E\big(\Lambda_{\mathrm{LOCC}}(\rho)\big)\le E(\rho) \qquad (5)

where: $E$ — entanglement measured in ebits, equal to $1$ for $|\Phi^+\rangle$ ; $S(\rho_A)$ — von Neumann entropy of the reduced state; $\Lambda_{\mathrm{LOCC}}$ — any channel built from local operations and classical communication. Reading: because local operations and classical messages can only redistribute entanglement, never increase it, a gate that raises $E$ must be fed by a pre-shared ebit — the quantitative statement that the quantum channel is irreplaceable. Long-range links are built by entanglement swapping: a repeater node fuses two short Bell pairs into one long one by measuring the two qubits it holds in the Bell basis.

\Phi^+_{AC}\otimes\Phi^+_{CB}\ \xrightarrow{\text{Bell meas. at }C}\ \Phi^+_{AB} \qquad (6)

where: $C$ — an intermediate repeater node holding one qubit from each short pair; $\Phi^+_{AB}$ — the resulting long-range pair between the end nodes, recovered after a Pauli correction announced by $C$ . Reading: swapping is teleportation with an entangled state as the payload, and chaining it across a line of repeaters — each patched by distillation — is exactly how a continental quantum internet distributes the ebits that DQC consumes.

Derivation ANonlocal CNOT via a shared Bell pair

The goal is to implement a CNOT whose control sits at node A and whose target sits at node B, using one pre-shared Bell pair and one classical bit in each direction, with no data qubit ever crossing the quantum channel — and to show this cat-entangler / cat-disentangler construction is a sequence of Clifford operations whose net effect on the two data qubits is exactly the desired gate. Label the shared pair $a$ (with Alice) and $b$ (with Bob); the data qubits are the control $c$ at A and the target $t$ at B. We distribute the pair offline, use it to carry the control's value across the gap, apply a local CNOT at B, then erase the residual entanglement.

Step 1. Distribute the resource offline: $|\Phi^+\rangle_{ab}=\tfrac{1}{\sqrt2}(|00\rangle+|11\rangle)$ , Alice holding $a$ and Bob holding $b$ . This is the only use of the quantum channel, and it happens long before the gate is scheduled. Why: separating the quantum step (slow, retried until heralded) from the runtime steps (all classical and local) is the entire architectural point of distributed computing.

Step 2. Cat-entangler at A: apply $\mathrm{CNOT}_{c\to a}$ , measure $a$ in the $Z$ basis to get a bit $x$ , and send $x$ to Bob, who applies $X^x$ to $b$ . The control's amplitude is now copied across both nodes into the cat state $\alpha|0\rangle_c|0\rangle_b+\beta|1\rangle_c|1\rangle_b$ . Why: this shares the classical value of the control between the two processors without measuring the control itself, so its superposition is preserved while its "which-branch" information reaches B.

Step 3. Local CNOT at B: apply $\mathrm{CNOT}_{b\to t}$ , entirely within Bob's module. Because $b$ now holds a faithful copy of the control, this flips the target exactly when the control is $|1\rangle$ — precisely the action the nonlocal gate demanded. Why: the hard nonlocal step has been reduced to an ordinary local gate, which is why the interconnect never has to perform a two-qubit operation across the gap.

Step 4. Cat-disentangler at B: apply $H$ to $b$ , measure it in $Z$ to get a bit $z$ , send $z$ to Alice, who applies $Z^z$ to the control $c$ . This uncomputes the shared control so $b$ returns to a fresh product state and $c$ is restored. Why: without this erasure the ancilla $b$ would stay entangled with the data and corrupt later gates; the disentangler closes the protocol on exactly $\mathrm{CNOT}_{c\to t}$ .

Step 5. Account for the resources: one Bell pair was consumed and two classical bits, $x$ and $z$ , were exchanged — one each way. Nothing quantum traversed the link at runtime. Why: this is the boxed cost of equation (4), and matching it against the LOCC bound below shows it cannot be beaten. *Each step is a Clifford circuit; propagating the stabilizers $X_cX_a$ and $Z_cZ_a$ through the sequence confirms the net unitary on $(c,t)$ is $\mathrm{CNOT}$ after the two Pauli corrections, at a total cost of one ebit and two cbits.*

Go deeper · Derivation B · 2 minTeleportation as a special case of gate teleportation

Derivation BTeleportation as a special case of gate teleportation

The goal is to expose teleportation and distributed gates as one construction seen at two settings of a knob: teleportation is gate teleportation through the identity, and promoting the identity to a gate $U$ teleports the data while simultaneously applying $U$ — the mechanism by which a gate acts between nodes. Along the way we see why the byproduct operator stays a Pauli for Clifford gates but demands an extra correction for non-Clifford gates like $T$ , which is exactly the seam where magic states enter. The resource state is $(U\otimes I)|\Phi^+\rangle$ , prepared offline, and the input is Bell-measured against its first half.

Step 1. Set $U=I$ . The resource is a plain Bell pair, and Bell-measuring the input against half of it is ordinary teleportation: the output is $|\psi\rangle$ up to one of the four Paulis $\{I,X,Z,XZ\}$ named by the two outcome bits. Why: this recovers equation (2) as the "gate = nothing" case, anchoring the general protocol in the primitive everyone already trusts.

Step 2. Insert a gate: prepare $|\chi_U\rangle=(U\otimes I)|\Phi^+\rangle$ ahead of time. Bell-measuring the input against the first half of this state projects the second half onto $U|\psi\rangle$ , up to a Pauli. Why: the expensive operation $U$ is spent offline on a generic half-Bell-pair, so at runtime the data merely gets consumed by a measurement — the gate has effectively "already happened".

Step 3. Track the byproduct. A Pauli correction $\sigma_j$ from the measurement passes through the gate as $U\sigma_j=(U\sigma_jU^\dagger)U$ . If $U$ is Clifford, $U\sigma_jU^\dagger$ is again a Pauli, so the correction stays Pauli and can be carried in software as a relabelling of the "Pauli frame". Why: this is why distributing Clifford gates is nearly free — no extra quantum operation is ever needed, only bookkeeping.

Step 4. Take $U=T=\mathrm{diag}(1,e^{i\pi/4})$ . Now $T\sigma_jT^\dagger$ is not Pauli; the byproduct may require an $S=\mathrm{diag}(1,i)$ correction conditioned on the outcome. Supplying $T$ this way is exactly injecting a magic state. Why: it pinpoints where a distributed Clifford network hits its wall and must import a distilled non-Clifford resource, linking DQC to magic-state distillation. *Direct substitution gives $(I\otimes\langle\Phi^+|)(|\psi\rangle\otimes(U\otimes I)|\Phi^+\rangle)=\tfrac12\,U|\psi\rangle$ up to the transpose/ricochet convention and a Pauli byproduct.*

Go deeper · Derivation C · 1 minEntanglement is LOCC-monotone, so nonlocal gates must spend ebits

Derivation CEntanglement is LOCC-monotone, so nonlocal gates must spend ebits

The goal is to prove the structural fact that underwrites the whole resource accounting: no protocol of local operations and classical communication can increase entanglement, so a gate that produces entanglement from product inputs — any nonlocal entangling gate — cannot be executed by LOCC alone and must consume a pre-shared ebit. The argument uses only the Kraus structure of LOCC channels and the invariance of entanglement measures under local unitaries, and it ends by pinning the CNOT's cost at exactly one ebit.

Step 1. Write any LOCC channel in its separable Kraus form, $\Lambda(\rho)=\sum_k (A_k\otimes B_k)\,\rho\,(A_k\otimes B_k)^\dagger$ , a convex mixture of local operations conditioned on classical messages. Why: fixing the mathematical shape of "what LOCC can be" is what lets us bound its effect on entanglement, rather than reasoning informally about "just talking".

Step 2. Local unitaries leave entanglement fixed: $E\big((U_A\otimes U_B)\rho(U_A\otimes U_B)^\dagger\big)=E(\rho)$ , because $E$ depends only on the Schmidt coefficients and those are invariant under local basis changes. Why: it isolates the only operations that could plausibly change $E$ — measurements and their classically-communicated outcomes — for the next step to handle.

Step 3. Local measurement with classical communication cannot raise $E$ on average: $\sum_k p_k\,E(\rho_k)\le E(\rho)$ , from convexity of the entanglement measure together with the local structure. Entanglement can be redistributed among branches but never created. Why: this is the precise sense of "monotone" — it forbids conjuring correlation out of local randomness and phone calls, closing every LOCC loophole.

Step 4. Apply it to the target gate. A CNOT maps the product input $|+\rangle|0\rangle$ to the Bell state $|\Phi^+\rangle$ , raising $E$ from $0$ to $1$ ebit. Since LOCC cannot supply that increase, exactly one ebit must be pre-distributed and consumed. Why: it converts the abstract monotonicity theorem into the concrete price tag of equation (4), and shows the cat-entangler protocol is not merely sufficient but necessary. *The CNOT entangling power is one ebit — Schmidt rank 2 is generated from a product input — which is exactly the amount that must be pre-shared, confirming the cost of equation (4).*

Limiting cases

The cost of every distributed primitive is fixed by information-theoretic accounting, not by hardware — the table reads off the exchange rates.

Case	Result	Meaning
Teleport one qubit	$1\ \text{ebit} + 2\ \text{cbit} \longrightarrow 1\ \text{qubit transferred}$	One Bell pair and two classical bits move an arbitrary qubit; tight — fewer of either fails by no-signalling and entanglement monotonicity.
Nonlocal CNOT	$\mathrm{CNOT}_{A\to B}=1\ \text{ebit}+2\ \text{cbit}$	The cat-entangler / cat-disentangler cost; optimal for a maximally entangling two-qubit gate.
Superdense coding (dual)	$1\ \text{ebit}+1\ \text{qubit}\longrightarrow 2\ \text{cbit}$	The time-reverse trade: pre-shared entanglement doubles a quantum channel's classical capacity.
Distillation yield	$D(\rho)\le 1,\quad D(\Phi^+)=1$	Distillable entanglement per noisy copy under LOCC; equals $1$ only for a pure maximally entangled pair, $0$ for any separable state.
CHSH certificate	$S\le 2\ (\text{LHV}),\ S_{\max}=2\sqrt2\ (\text{quantum})$	A shared pair's CHSH value above $2$ certifies genuine entanglement in the link; Tsirelson caps it at $2\sqrt2\approx2.828$ .

Common trapClassical communication and entanglement are not interchangeable

The seductive error is to think one resource can stand in for the other — that with enough classical chatter you could skip the Bell pair, or that a stockpile of entanglement lets you dispense with the phone call. Neither substitution works, and each fails for a sharp reason. LOCC alone can never increase entanglement (it is a monotone), so no volume of classical bits will conjure the ebit a nonlocal entangling gate consumes. Conversely, shared entanglement alone can never signal (no-signalling): each party's reduced state is $I/2$ regardless of what the other does, so without the classical outcome bits Bob's qubit after teleportation is pure noise carrying zero information. A nonlocal gate genuinely requires both currencies, spent in the right order — entanglement distributed in advance, classical bits sent at runtime — and any protocol that assumes one suffices silently breaks.

Worked examples

1 · Distilling a usable Bell pair from noisy links (fully worked)

A photonic interconnect heralds Werner pairs of fidelity $F=0.70$ to the target state $|\Phi^+\rangle$ — too noisy to fuel a fault-tolerant gate. Using the BBPSSW recurrence, find the fidelity and success probability after one round of distillation, and the trend under iteration.

Step 1. Write the recurrence. Two identical Werner pairs of fidelity $F$ , processed by a bilateral CNOT and a coincidence measurement, yield one pair of fidelity

F' = \frac{F^2 + \tfrac19(1-F)^2}{F^2 + \tfrac23 F(1-F) + \tfrac59(1-F)^2},

and the denominator is exactly the probability $p$ that the round succeeds. The map has a fixed point at $F=\tfrac12$ and pushes $F$ upward for every $F>\tfrac12$ .

Step 2. Substitute $F=0.70$ , so $1-F=0.30$ . Numerator: $0.70^2+\tfrac19(0.30)^2=0.49+\tfrac19(0.09)=0.49+0.01=\mathbf{0.50}$ . Denominator: $0.49+\tfrac23(0.70)(0.30)+\tfrac59(0.09)=0.49+0.14+0.05=\mathbf{0.68}$ .

Step 3. Divide: $F'=0.50/0.68=\mathbf{0.735}$ , achieved with success probability $p=\mathbf{0.68}$ . Each surviving round consumes two pairs to make one better pair — a yield below $\tfrac12$ — so distillation buys fidelity at the price of ebits.

Step 4. Iterate. Feeding $0.735$ back in gives $\approx0.80$ , then $\approx0.86$ , climbing toward $1$ ; the curve in the second figure lies above the diagonal throughout $(\tfrac12,1)$ , so the fixed point at $F=1$ is the attractor. One round takes 0.70 → 0.735 at 68% success; below F = ½ no purification is possible.

2 · Resource budget for a distributed sub-circuit

A control qubit on node A must apply CNOTs onto five target qubits held on node B. Compare the naive cost with the cat-entangler optimisation, in ebits and cbits.

Step 1. Naive count. Treat each nonlocal CNOT independently: by equation (4) each costs $1$ ebit $+2$ cbit, so five gates cost $5$ ebits $+10$ cbit. Every gate re-distributes and re-erases the same control.

Step 2. Optimise. Run the cat-entangler once to share the control's value onto a single ancilla on node B, apply all five CNOTs locally at B, then run the cat-disentangler once to erase it. The shared control is reused across the whole group.

Step 3. Recount. The optimised protocol spends $1$ ebit $+2$ cbit total, independent of how many targets the control feeds. Sharing the control collapses 5 ebits + 10 cbit down to 1 ebit + 2 cbit — a fivefold entanglement saving that generalises: a control fanning out to $m$ targets on one remote node costs one ebit, not $m$ .

Step 4. Read the lesson. Compiling a distributed circuit is a graph-partitioning problem — cut the circuit so that few control qubits cross node boundaries and each crossing control serves many targets, minimising total ebits, the scarce currency.

3 · Teleportation moves a qubit with no qubit crossing the link

Alice holds an unknown $|\psi\rangle=\alpha|0\rangle+\beta|1\rangle$ and shares $|\Phi^+\rangle$ with Bob. She Bell-measures her two qubits and gets outcome $\Psi^+$ . What must Bob do, and what did the link carry?

Step 1. Expand the joint three-qubit state in Alice's Bell basis. Each of the four outcomes leaves Bob's qubit equal to $|\psi\rangle$ up to a fixed Pauli: $\Phi^+\to I$ , $\Phi^-\to Z$ , $\Psi^+\to X$ , $\Psi^-\to XZ$ .

Step 2. For the observed outcome $\Psi^+$ , Bob's qubit is $X|\psi\rangle=\beta|0\rangle+\alpha|1\rangle$ . He applies $X$ to recover $|\psi\rangle$ exactly. Bob applies a single Pauli X.

Step 3. Tally the channel usage. One ebit was consumed and two classical bits (the outcome label) crossed to Bob; no physical data qubit traversed the quantum channel. The information moved as 1 ebit + 2 cbit — and before the two bits arrive, Bob's qubit is I/2, so no signal outran the classical message.

Physics of the portrait

Distributed quantum computing is, at bottom, the theory of entanglement as a countable, spendable resource — and that theory has a single principal architect, the physicist who turned "spooky action" into a currency with an exchange rate.

Origins · 1 minCharles H. Bennett and how this was discovered

Charles H. Bennett

born 1943 · quantum information as a physical resource: teleportation, superdense coding, and entanglement distillation

Charles H. Bennett is an American physicist and information theorist at IBM Research whose work built, with a few close collaborators, the resource theory that distributed quantum computing runs on. Trained as a chemist at Brandeis and Harvard, he first made his name in the physics of computation — reversible computing and, with Rolf Landauer, the thermodynamic cost of erasing information, exorcising Maxwell's demon by charging entropy to the demon's memory. Turning to quantum information, he and Gilles Brassard invented quantum key distribution (the BB84 protocol) in 1984, showing the no-cloning theorem could be a security guarantee rather than a nuisance. With Stephen Wiesner he found superdense coding in 1992: one pre-shared ebit lets a single qubit carry two classical bits. The next year, with Brassard, Crépeau, Jozsa, Peres, and Wootters, he published quantum teleportation — the discovery that an unknown state can be reconstructed at a distance from two classical bits and one shared Bell pair, the primitive from which all of DQC descends. In 1996 he and co-workers formalised entanglement distillation and the purification of noisy mixed states, and introduced the entanglement measures and LOCC paradigm that make "one ebit" a precise quantity. That framework — entanglement as something conserved, quantified, distilled, and traded against classical communication — is exactly the accounting a distributed quantum computer keeps, which is why teleportation and gate teleportation, not any particular hardware, are the true foundations of the field.

History

1992

— Bennett and Wiesner introduce superdense coding: one ebit lets a qubit carry two classical bits

1993

— Bennett, Brassard, Crépeau, Jozsa, Peres, and Wootters publish the quantum teleportation protocol

1996

— Bennett and co-workers formalise entanglement distillation and mixed-state purification

1999

— Gottesman and Chuang introduce gate teleportation and the quantum-software model of computation

2000

— Eisert, Jacobs, Papadopoulos, and Plenio prove the nonlocal CNOT costs one ebit and two cbits

Going further

Texts. Nielsen & Chuang, Quantum Computation and Quantum Information, §1.3.7 (teleportation) and ch. 12 (entanglement as a resource) · Preskill, Lecture Notes on Quantum Computation, ch. 4–5 · Watrous, The Theory of Quantum Information, ch. 6 (bipartite entanglement and LOCC) · Wilde, Quantum Information Theory, ch. 6 (teleportation and superdense coding) · Kitaev, Shen & Vyalyi, Classical and Quantum Computation, ch. 11–12 · Bennett et al., Phys. Rev. Lett. 70, 1895 (1993), teleportation; Gottesman & Chuang, Nature 402, 390 (1999), gate teleportation; Eisert, Jacobs, Papadopoulos & Plenio, Phys. Rev. A 62, 052317 (2000), optimal nonlocal gate cost. The key numerical results collected in this article are: the teleportation cost of $1$ ebit $+\,2$ cbit and the four Pauli corrections from the Bell-basis expansion; the nonlocal CNOT cost of $1$ ebit $+\,2$ cbit confirmed by cat-entangler / cat-disentangler stabilizer tracking; the superdense coding dual ( $1$ ebit $+\,1$ qubit $\to 2$ cbit); LOCC monotonicity of entanglement with $E=S(\rho_A)$ for pure states; the BBPSSW distillation recurrence giving $F=0.70\to F'=0.735$ at success probability $0.68$ , with fixed point $F=\tfrac12$ ; and Tsirelson's bound $S_{\max}=2\sqrt2$ .

Prerequisites. Measurement-Based Quantum Computation · Cluster States and Graph States · Measurement Calculus and Pattern Compilation · Flow and Gflow Conditions. Leads to. Topological Quantum Computation · Magic State Distillation · Toric Code and Topological Order.

Ask the tutor: Ask me to walk through the cat-entangler stabilizer tracking line by line, or to work out the full ebit-and-cbit budget for distributing a specific circuit across two or three nodes.

What is the difference between teleportation and gate teleportation?

They are the same protocol at two settings of one knob. In ordinary teleportation the resource is a plain Bell pair, and a Bell measurement relocates an unknown qubit unchanged — up to a Pauli correction — using one ebit and two cbits. In gate teleportation the resource is a Bell pair with a gate $U$ already applied to one half, prepared offline; the identical Bell measurement now delivers $U|\psi\rangle$ instead of $|\psi\rangle$ . So teleportation is "gate teleportation through the identity". The point for distributed computing is that the expensive gate is spent in advance on a generic resource state, so at runtime only a measurement and a cheap Pauli correction remain — the gate has effectively already happened before the data arrives.

Does a distributed quantum computer send qubits between the processors?

No — and that is the whole trick. At runtime nothing quantum crosses the link. The quantum channel is used only offline, to distribute generic Bell pairs, which are then stored. When a nonlocal gate is needed, it is enacted by consuming a stored Bell pair through gate teleportation while exchanging a few classical bits. Because the data never physically travels, a slow or lossy quantum channel is tolerable: you simply keep attempting entanglement generation until a pair is heralded, then store it, decoupling link speed from gate speed. Only the classical channel must be fast, since the Pauli corrections it carries cannot be deferred. This asymmetry — quantum offline, classical at runtime — is why the architecture is practical at all.

Why exactly one ebit and two cbits for a nonlocal CNOT — could it be cheaper?

It cannot. The two cbits are forced by no-signalling: the classical outcomes are what let the receiving node undo its otherwise-random Pauli byproduct, and without them the reduced state carries zero information. The one ebit is forced by entanglement monotonicity: a CNOT applied to product inputs produces an entangled output, raising the entanglement measure from zero to one ebit, and LOCC alone can never supply that increase. So the entangling power of the gate — Schmidt rank two generated from a product state — must be paid for with a pre-shared ebit. Eisert, Jacobs, Papadopoulos and Plenio proved this bundle is not just sufficient but optimal for a maximally entangling two-qubit gate.

Why must entanglement be distilled before it can fuel a gate?

Real quantum channels are lossy and noisy, so the Bell pairs a photonic link heralds are mixed states of some fidelity $F<1$ to the ideal $|\Phi^+\rangle$ . Feeding such a pair into gate teleportation propagates its noise straight into the computation. Distillation fixes this by trading quantity for quality: protocols like BBPSSW consume several low-fidelity pairs to output fewer pairs of higher fidelity, and iterating drives $F$ toward $1$ — but only when $F$ already exceeds $\tfrac12$ , the fixed point below which no purification is possible. The cost is ebits: yield falls below one output pair per two inputs. This is why the entanglement budget, not the qubit count, is often the binding constraint in a distributed design.

How is distributed computing related to measurement-based quantum computation?

They are two faces of the same resource. A cluster or graph state spread across several nodes is already a distributed quantum computer: universal computation on it proceeds entirely by single-qubit measurements and classically communicated corrections, which is exactly LOCC across whatever partition holds the qubits. The inter-node CZ edges of the graph are made by gate teleportation, and once the graph exists no further quantum communication is needed — only classical feed-forward of measurement outcomes. The measurement calculus provides the formal language for compiling an algorithm into such a measurement pattern, and the flow and gflow conditions certify that the corrections can be ordered into a deterministic schedule. In this picture, "distributing" a computation and "measuring" a cluster state are the same act.

Where do non-Clifford gates come from if a distributed network is mostly Clifford?

Gate teleportation makes Clifford gates cheap because their Pauli byproducts stay Pauli and can be tracked in software. Non-Clifford gates like $T$ break this: the conjugated byproduct $T\sigma T^\dagger$ is no longer a Pauli and may demand an extra $S$ correction conditioned on the measurement outcome. A network of Clifford operations plus measurement cannot generate this resource internally — that is the content of the Gottesman–Knill theorem, which says Clifford circuits are classically simulable. The fix is to import it: a distilled magic state is injected by gate teleportation, supplying the $T$ gate that lifts the network to universality. This is the direct bridge from distributed computing to magic-state distillation, and it is why a fault-tolerant distributed processor always includes a magic-state factory.