Quantum Reverse Shannon Theorem
Claude Shannon's 1948 coding theorem is famously one-directional: it fixes the capacity at which a noisy channel carries information, and quantum Shannon theory spent two decades extending that forward story to quantum channels. But every coding theorem hides a dual question — running the arrow backwards, at what rate of noiseless communication can you simulate a given noisy channel? This is channel simulation, the mirror image of channel coding, and the Quantum Reverse Shannon Theorem (QRST) is where the quantum version of that mirror finally became exact. Its punchline is startlingly clean: with unlimited pre-shared entanglement, the noiseless classical communication cost of simulating a quantum channel is exactly its entanglement-assisted classical capacity , the maximized quantum mutual information — the very same number that governs how much information the channel can send. Put the forward theorem (Bennett, Shor, Smolin and Thapliyal) beside the reverse one and the two arrows close into a loop: noiseless bits plus free entanglement build the channel, and the channel plus free entanglement resells for noiseless bits — nothing leaks either way. Channels and classical bits become reversibly interconvertible at a single exchange rate , with entanglement as a free catalyst — the information-theoretic analogue of a reversible thermodynamic engine. No other capacity (unassisted , quantum , private ) has this, because for those the forward and reverse rates disagree. The delicate part, and the reason the theorem resisted proof from 2002 until 2014, is the demand that the simulation stay faithful even when the channel acts on one half of an entanglement with an inaccessible reference — the strong, entangled-input criterion that pins the price at rather than a cheaper Holevo-like quantity.
- The Quantum Reverse Shannon Theorem says that with unlimited shared entanglement a sender can simulate any noisy channel — on any input, even one entangled with a reference — using forward classical communication at rate equal to the channel's entanglement-assisted classical capacity .
- Together with the entanglement-assisted capacity theorem it makes channel coding and channel simulation cost the same number , so the entanglement-assisted world is asymptotically reversible in a way unassisted quantum Shannon theory never is.
- The strong version demands accuracy on inputs entangled with a reference ; this fully quantum fidelity condition forces the cost up to the entanglement-maximized and is the source of the proof's difficulty.
- The modern proof runs through one-shot decoupling and quantum state splitting: a random covering makes the environment independent of the reference, and only the -correlated part of the output — exactly bits per use — need be transmitted.
- is the unique capacity that is exactly additive and never superactivates, which is why the reverse theorem matches the forward one and gives quantum mutual information a second operational meaning as a simulation cost.
- Conjectured by Bennett, Shor, Smolin and Thapliyal in 2002, the strong theorem was completed in 2014 by Bennett, Devetak, Harrow, Shor and Winter, and independently via one-shot methods by Berta, Christandl and Renner.
- Key idea: With free shared entanglement, the cost of simulating a quantum channel in noiseless classical bits equals the cost of using it for communication — both are . The entanglement-assisted world is asymptotically reversible, and quantum mutual information is the universal exchange rate.
Where this lives today
The reverse Shannon theorem is the load-bearing tool in the modern theory of strong converses and channel simulation. Its most active descendant is one-shot and finite-block-length quantum information: the decoupling and quantum-state-splitting primitives that prove QRST also compute exact resource costs for state redistribution, quantum state merging, and the "mother/father" protocol family, and they underpin the second-order refinements needed for realistic, non-asymptotic communication. More broadly, reverse Shannon simulations bound the capacities that don't single-letterize: if a code for the unassisted classical, quantum, or private capacity can be simulated cheaply, it cannot carry more than those resources allow — yielding some of the strongest known strong-converse bounds. And the conceptual payoff endures: QRST pins an operational quantity, quantum mutual information, with a matched pair of tasks — coding and simulation — giving it the status reversible-engine arguments give entropy in thermodynamics.
The physical picture
Think of a quantum channel as a commodity bought and sold on an open market. The direct entanglement-assisted theorem is the "buy" side: spend noiseless bits (with free entangled pairs, or ebits) and you manufacture one channel's worth of communication. The reverse theorem is the "sell" side: hand over a physical channel and, with free entanglement, resell it for noiseless bits. Because the buy and sell prices coincide the market is frictionless: channels and bits are reversibly interconvertible at the single price . The first figure draws that closed loop, anchored by the one instance you can compute by hand — the noiseless qubit, whose price is exactly 2 bits, read as teleportation one way and superdense coding the other.
Why entanglement is the load-bearing ingredient: a maximally entangled resource lets the sender teleport the action of the channel rather than physically build it. She applies a random unitary to her half of an entangled pair, arranges for the channel's effect to happen, and classically tells the receiver which unitary occurred — but only after using the entanglement to decouple the leftover, uncorrelated information so the classical description shrinks from a wasteful bits to bits. That decoupling is the whole trick. The strong, entangled-input requirement is what makes the price exactly and not less: a channel that reproduces only the right average output is cheap, but one that must preserve every correlation with a reference, behaving correctly even on half of a Bell state, is expensive — its worst case is the maximally entangled input, whose fingerprint is the channel's Choi state. The second figure makes the price concrete: the qubit erasure channel, whose cost slides linearly from 2 to 0 as the erasure probability climbs.
The core equations
The theorem lives at the meeting point of two operational quantities — a capacity and a simulation cost — that turn out to be one number. First, the definition of that number: the entanglement-assisted classical capacity, an optimization of quantum mutual information over pure inputs shared with a reference.
where: — the channel being characterized and simulated; — a pure bipartite input, with a reference held fixed; — quantum mutual information of the output; — both the forward capacity and, by QRST, the reverse simulation cost. Reading: feed the channel half of a pure state and ask how much correlation with the untouched half survives; the best input sets . The reverse theorem states that this same is the asymptotic classical-bit cost of simulating the channel with free entanglement — an equality of rates, not an inequality.
where: — a protocol using free entanglement plus forward classical communication; — parallel channel uses; the limit is over vanishing simulation error. Reading: no simulation beats per use (converse), and one achieves it (direct part). "Simulate" has to be defined carefully, and the strong criterion is the whole difficulty of the theorem: the simulation must be indistinguishable from the true channel even on inputs entangled with an arbitrary reference , measured in trace distance.
where: — an arbitrary pure input, possibly maximally entangled with ; — trace norm, so is trace distance; — error vanishing in block length. Reading: correctness is demanded uniformly over all inputs at once, which is why the price is the entanglement-maximized . The simplest nontrivial instance, the noiseless qubit channel, exposes the reversibility directly as a chain of resource inequalities that close on themselves.
where: — "can asymptotically simulate / is at least as powerful as"; cbit — one noiseless classical bit; ebit — one maximally entangled pair (free here); qubit — one noiseless qubit channel use. Reading: the left inequality is teleportation, the right is superdense coding; together they make one qubit reversibly worth two cbits, so . Behind the capacity sits a single entropic object: quantum mutual information is a relative entropy, , a distance from the uncorrelated product . Because relative entropy obeys strong subadditivity, is exactly additive — it single-letterizes, unlike the unassisted capacities, and this is the structural fact that lets the reverse rate match the forward rate.
where: — quantum relative entropy; — parallel channel use; — unassisted (regularized Holevo) classical capacity; — entanglement-assisted quantum capacity, exactly half of by teleportation and superdense coding. Reading: is the well-behaved, additive capacity, and the anchor from which the assisted quantum rate follows by a factor of two.
The strong criterion (3) quantifies over an infinite family of inputs , which looks intractable; the goal here is to collapse that quantification to a single canonical state and explain why the cost is an entanglement-maximized quantity. We show that the supremum of the channel-difference over all inputs is attained on the maximally entangled state, whose image is the channel's Choi state, so "faithful on the worst case" means "reproduces the Choi state" and the cost is rather than an average-case quantity.
Step 1. The diamond-norm distance is the maximum output trace-distance over all inputs including a reference, and by convexity of the trace norm this maximum is attained on a pure input. Why: mixed inputs are convex mixtures of pure ones, and trace distance is maximized at an extreme point.
Step 2. For a pure input it suffices to take the reference at least as large as , since all purifications are related by an isometry on that commutes with the channel (which acts only on ). Why: the channel difference cannot see that isometry, so full-rank captures the hardest case.
Step 3. The extremal, most-entangled full-rank input is , and maps it to the Choi state ; matching the true channel there means reproducing one fixed bipartite state. Why: Choi–Jamiołkowski turns "simulate on the worst input" into "prepare one particular state", the cleanest target.
Step 4. Since the worst case is maximally entangled, the correlation that must be reproduced is — not the smaller Holevo-like quantity of a fixed product source. Why: this is the step that fixes the price at and separates the strong theorem from easy average-case simulation. *Verified: diamond norm attained on pure maximally entangled input; ; worst-case correlation . Wilde Ch. 24, Watrous Ch. 8.*
Go deeper · Derivation B · 1 minConverse — no protocol beats the entanglement-assisted rate
The goal is the lower-bound half of (2): any entanglement-assisted protocol that -simulates on the optimizing input must spend at least classical bits, so nothing undercuts rate . The argument is one clean use of the data-processing inequality on the reference–output correlation the protocol must create, plus the fact that a classical message carries only its own entropy in correlation. Let the protocol use a classical message of bits plus pre-shared entanglement independent of the input, and feed the input achieving .
Step 1. A faithful simulation reproduces the true output , whose correlation is by additivity (equation 5). This is the target the protocol must build. Why: the whole converse is an accounting of where that correlation can come from.
Step 2. Before any message, Bob's share is uncorrelated with , since was prepared independently of the input. All – correlation must be created by and Bob's local processing. Why: free entanglement is a catalyst — on its own it establishes zero correlation with an external reference.
Step 3. Bob produces from , so data processing gives , the last step because . Why: post-processing cannot raise mutual information.
Step 4. Because is a classical register of values, — no factor-of-two superdense bonus, since that would require sending a quantum system. Why: this is the crux — a classical message buys correlation one-for-one, which is why the noiseless qubit costs two bits, not one.
Step 5. By continuity of mutual information (Alicki–Fannes–Winter), the -approximation costs only . Chaining, ; dividing by and taking gives . Why: this meets the achievability rate exactly, making the true cost. *Verified: for id₂ the bound gives , i.e. rate 2 = teleportation cost, confirming the factor-1 classical-register bound (factor-2 would wrongly permit rate 1). Wilde Ch. 24, BSST (2002).*
Go deeper · Derivation C · 2 minAchievability by decoupling and quantum state splitting
The direct part must exhibit a protocol meeting rate ; the goal is to build one from a Stinespring dilation plus one one-shot primitive — quantum state splitting driven by decoupling — and verify the surviving classical message compresses to exactly bits per use. Strategy: dilate the channel so the output purification sits in Alice's lab; deliver to Bob by state splitting, whose cost is set by decoupling the discarded environment from ; then convert the quantum communication to classical bits with free entanglement. Dilate with isometry on the worst-case input, giving pure .
Step 1. Alice applies , holding and with at the reference. Her task reduces to transferring to Bob while preserving purity with — quantum state splitting. Why: once dilated, simulating the channel is exactly moving the output register to the receiver coherently.
Step 2. Apply a Haar-random unitary (or unitary 2-design) on Alice's side; the decoupling inequality makes the discarded independent of the reference,
A positive exponent drives to decouple from . Why: if carries no information about it need never be sent — only the -correlated part of the output travels.
Step 3. With decoupled, state splitting delivers to Bob using qubits of quantum communication per use (plus free entanglement). Why: the coherent cost of relocating a subsystem while keeping its reference purity is half its mutual information with that reference — the mother-protocol rate.
Step 4. Teleportation converts each transmitted qubit into 2 classical bits, so the classical cost is
using for pure . Why: this is the surviving-message identity — after decoupling, the residual classical description is exactly bits, matching the converse.
Step 5. Because covering and decoupling ran against the worst-case reference (first derivation), the simulation is faithful on all inputs at once, meeting criterion (3); one-shot smoothing then gives asymptotic rate with . Why: solving the hardest input solves them all, and smoothing closes the gap with the converse. *Verified: state-splitting cost qubits → cbits via teleportation; surviving rate checked numerically on a random Stinespring dilation (the base-migration form instead equals and is corrected here). Berta–Christandl–Renner (2011), BDHSW (2014).*
Limiting cases
How the simulation cost specializes for representative channels — all rates in bits per channel use, with entanglement free:
| Case | Result | Meaning |
|---|---|---|
| Noiseless qubit channel | Simulating a perfect qubit costs 2 cbits given free entanglement — this is quantum teleportation, the canonical QRST instance. | |
| Noiseless classical bit channel | A perfect cbit needs exactly 1 cbit to simulate; entanglement gives no leverage on a classical-to-classical map. | |
| Completely depolarizing | Output independent of input, so ; Bob simply prepares with zero communication. | |
| Qubit erasure channel, erasure prob. | Linear in survival probability: 2 at , 1.5 at , 0 at , matching the known entanglement-assisted capacity. | |
| Strong vs. weak simulation | Simulation accurate only on a fixed product source can cost strictly less; the entangled-input criterion fixes the price at . |
Worked examples
1 · The noiseless qubit costs exactly two bits (the teleportation instance)
Compute the simulation cost of a perfect one-qubit channel from equation (1), and identify the protocol that achieves it.
Step 1. Feed the channel one half of the maximally entangled input . Since does nothing, the output is itself a maximally entangled two-qubit (Bell) state. Its marginals are maximally mixed, bit, and the joint state is pure, .
Step 2. Mutual information: . No input does better (the maximally mixed marginal already saturates each term), so .
Step 3. The achieving protocol is teleportation read as a simulation: with one shared ebit, sending 2 classical bits reproduces a perfect qubit channel. Superdense coding gives the reverse inequality ( qubit ebit cbits), so the noiseless qubit is reversibly worth two cbits — equation (4) with both arrows. The converse confirms it: , i.e. rate 2, is exactly teleportation's cost and cannot be beaten. C_E(id₂) = 2 bits, achieved by teleportation, optimal by the classical-register converse.
2 · The qubit erasure channel (fully worked)
The qubit erasure channel maps , flagging "erased" with probability on an orthogonal flag . Find its simulation cost, evaluate it at , and interpret the endpoints.
Step 1. Feed half of . With probability the receiver holds the intact qubit, maximally entangled with (the full 2 bits, as in Example 1); with probability he holds the flag , orthogonal to and uncorrelated with (0 bits). The flag is classically distinguishable from the qubit subspace, so the branches do not interfere and the reference–output mutual information is the weighted average.
Step 2. Hence , the value plotted in the second figure and the known entanglement-assisted capacity of the erasure channel (Bennett–DiVincenzo–Smolin).
Step 3. At : . So simulating uses of the -erasure channel on entangled inputs costs asymptotically noiseless classical bits, with free entanglement. Endpoints: recovers and cost 2 (Example 1); gives cost 0, because the output is always the fixed flag , carries nothing about the input, and Bob prepares it locally — a sanity check that the strong criterion charges only for correlation the channel genuinely preserves. C_E = 2(1−p); at p = 0.25 the cost is 1.5 bits/use.
Physics of the portrait
The reverse Shannon theorem is inseparable from the person who framed both its question and much of the machinery that answered it: channel simulation as the dual of coding, the resource-inequality bookkeeping that makes ebits and cbits fungible, and the two protocols — teleportation and superdense coding — that anchor the loop all trace to one research program.
Origins · 1 minCharles H. Bennett and how this was discovered
Charles Bennett is, more than any single figure, the architect of the resource view of quantum information in which the reverse Shannon theorem is stated. Trained as a physical chemist, he joined IBM Research and in 1973 proved that computation can be made logically reversible, later tying its thermodynamic cost to erasure — the germ of treating information as a physical, tradeable currency. With Gilles Brassard he invented the BB84 key-distribution protocol (1984); with Stephen Wiesner, superdense coding (1992, 2 cbits from 1 qubit plus 1 ebit); and with Brassard, Crépeau, Jozsa, Peres and Wootters, quantum teleportation (1993, 1 qubit from 2 cbits plus 1 ebit) — the two half-arrows that make a noiseless qubit reversibly worth two classical bits. Through the late 1990s and 2000s he and collaborators built entanglement into a quantifiable resource, including the entanglement-assisted capacity (with Shor, Smolin and Thapliyal, 1999–2002) and, in that same 2002 paper, the conjecture of QRST — which he returned to complete in 2014 (with Devetak, Harrow, Shor and Winter). The through-line of his career is exactly the picture QRST formalizes: information and entanglement are physical resources with exchange rates, and the deepest theorems make those rates reversible.
Going further
References. M. A. Nielsen and I. L. Chuang, Quantum Computation and Quantum Information (10th Anniv. ed.), Ch. 11–12 · M. M. Wilde, Quantum Information Theory (2nd ed.), Ch. 20–21 (entanglement-assisted capacity) and Ch. 24 (reverse Shannon) · J. Preskill, Lecture Notes on Quantum Computation, Ch. 10 · J. Watrous, The Theory of Quantum Information, Ch. 8 · A. Kitaev, A. Shen, M. Vyalyi, Classical and Quantum Computation (background on channels and entropy) · C. H. Bennett, P. W. Shor, J. A. Smolin, A. V. Thapliyal, "Entanglement-Assisted Capacity of a Quantum Channel and the Reverse Shannon Theorem," IEEE Trans. Inf. Theory 48 (2002) 2637 · C. H. Bennett, I. Devetak, A. W. Harrow, P. W. Shor, A. Winter, "The Quantum Reverse Shannon Theorem and Resource Tradeoffs for Simulating Quantum Channels," IEEE Trans. Inf. Theory 60 (2014) 2926 · M. Berta, M. Christandl, R. Renner, "The Quantum Reverse Shannon Theorem Based on One-Shot Information Theory," Commun. Math. Phys. 306 (2011) 579.
Provenance. Capacity formula and its additivity: BSST (2002), Wilde Ch. 20–21. Strong QRST and its proof structure (decoupling, quantum state splitting, one-shot smoothing): BDHSW (2014) and Berta–Christandl–Renner (2011). A verifier should recompute: (i) , depolarizing , erasure from equation (1); (ii) additivity of from strong subadditivity; (iii) the surviving-rate identity using the purity of the Stinespring dilation — note this corrects the migrated draft's , which instead equals ; (iv) the converse from data processing plus the classical-register bound (factor 1, checked against the teleportation cost 2 for id₂). Cross-references: Nielsen & Chuang Ch. 11–12, Preskill Ch. 10, Watrous Ch. 8.
Prerequisites. Quantum Channels and CPTP Maps · Stinespring Dilation Theorem · Quantum Conditional Entropy and Mutual Information · Von Neumann Entropy · Strong Subadditivity of Quantum Entropy · Data-Processing Inequality. Leads to. Holevo Bound · Complementary Channels and Degradability · Choi–Jamiołkowski Isomorphism.
Ask the tutor: Ask me to walk through why simulating a perfect qubit costs exactly two classical bits — and how teleportation and superdense coding close that into a reversible loop.
What is channel simulation, and how is it the "reverse" of channel coding?
Channel coding asks: given a fixed noisy channel, how many noiseless bits can I reliably send through it? Channel simulation runs the arrow the other way: given a supply of noiseless bits (and here, free entanglement), how few do I need to reproduce a target noisy channel so that no user can tell my imitation from the real thing? Coding turns a noisy resource into a noiseless one; simulation does the reverse, and the reverse Shannon theorem is its tight cost. The beauty is that in the entanglement-assisted setting the two costs coincide at , so coding and simulation are inverse processes at the same exchange rate — the channel and bits are interconvertible without loss.
Why does entanglement have to be free for the clean C_E answer?
Because reversibility is exactly what free entanglement buys. If you had to pay for the entangled pairs, the accounting would split into a two-dimensional trade-off between classical bits and ebits, and no single number would govern both coding and simulation. Making entanglement a free catalyst collapses that trade-off: the theory linearizes, becomes additive, and forward and reverse rates land on the same value — the direct analogue of idealizing a heat reservoir so a reversible cycle has one well-defined efficiency. Charge for entanglement and you recover a richer but messier region of rates; give it away and you get the crisp reversible statement.
Why did the quantum theorem take twelve years when the classical one was easy?
The obstacle is entangled inputs. Classically, a channel acts on a message from a known source, and simulating its output statistics is comparatively direct. Quantum mechanically, the channel might be handed one half of a state entangled with an inaccessible reference, and the simulation must reproduce not just the output but all its correlations with that reference — faithfully and simultaneously for every input. A protocol that reproduces average outputs can fail badly on maximally entangled ones. Guaranteeing correctness against the worst-case reference required one-shot tools — decoupling, convex-split, quantum state splitting — that did not exist in 2002. Assembling them into a proof valid on all inputs at once took until 2014.
How can a classical message carry only log L bits of correlation when superdense coding doubles it?
The two situations differ in what is transmitted. Superdense coding sends a quantum system: one qubit plus a shared ebit delivers 2 classical bits. In the reverse Shannon converse the message is classical — a register of values — and a classical register shares at most its own entropy, bits, of mutual information with anything, entanglement or not. There is no doubling because you never send a superdense-codeable qubit. This factor of one, not two, is exactly why simulating a noiseless qubit costs the full 2 classical bits (teleportation): the converse with demands it.
What exactly does "decoupling" accomplish in the achievability proof?
After dilating the channel, the output purification has three parts: the reference , the output headed for Bob, and the environment the channel discards. Decoupling applies a random unitary so that becomes statistically independent of — a product . Once carries no information about the reference, it never has to be communicated; only the part of correlated with is worth sending. Counting that residue — via quantum state splitting, then teleporting the qubits into cbits — gives exactly classical bits per use. Decoupling is the scalpel that separates what you must transmit from what you can throw away.
Is C_E really both a capacity and a simulation cost, and why does that matter?
Yes, and the double identity is the whole point. The forward theorem (BSST) says is the rate at which the channel sends classical information with entanglement assistance; the reverse theorem (QRST) says the identical number is the rate at which noiseless bits simulate the channel. A quantity nailed down by a matched pair of tasks — one building the resource, one consuming it — is singled out uniquely, exactly as entropy is in thermodynamics by appearing on both sides of a reversible cycle. That is why quantum mutual information, once "just" an entropic formula, becomes a physical exchange rate: the price at which channels and classical communication trade when entanglement is free.