Part IV. Protocols and Algorithms · Chapter 24

Superdense Coding

One transmitted qubit, two classical bits delivered — but the Bell pair was spent in advance. This chapter traces superdense coding gate by gate and keeps the resource ledger visible the whole way through.

Steven GellerPublished July 25, 2026Revised August 14, 2026

Lab

In this chapter 8 sections

Reader question. How can one transmitted qubit convey one of four classical messages when sender and receiver share entanglement beforehand?

The shared Bell pair supplies a two-qubit code space: the sender applies one of four local Pauli encodings, transmits her qubit, and the receiver performs a Bell-basis decode; the resource account is one transmitted qubit, one pre-shared ebit, and a classical two-bit output.

Scope and non-goals.

This chapter does not claim one isolated qubit stores two readable classical bits.
It does not ignore entanglement distribution, Bell measurement, channel noise, or resource accounting.

Figure 24.1. Notice what crosses the channel: exactly one qubit. The second bit of capacity was spent earlier, when the Bell pair was distributed.

Write the communication contract first

List message, pre-shared state, transmitted system, and receiver output.

Superdense coding delivers two classical bits by transmitting one qubit; after sender and receiver have already shared an entangled pair. The setup: a Bell pair is prepared and split between Alice and Bob. The message: Alice applies one of four gates to her half and physically sends that qubit to Bob. The decoding: Bob runs the Bell preparation circuit in reverse and measures, recovering two bits.

The ledger is the whole story:

shared before the message: one Bell pair;
transmitted during the message: one qubit;
recovered at the end: two classical bits.

Remove the pre-shared pair and the headline is simply false; a lone qubit's measurement does not hand over two freely chosen classical bits.

Evidence boundary. Superdense coding transmits two classical bits using one qubit sent after an entangled pair is shared. [Charles H. Bennett] [Michael A. Nielsen]

Four local operations label four Bell states

Derive the encoding table.

Alice and Bob each hold one qubit of:

\lvert\Phi^+\rangle=(\lvert00\rangle+\lvert11\rangle)/\sqrt2

Alice encodes her two bits by applying one of four operations to her half alone:

00 → I (do nothing)
01 → X
10 → Z
11 → XZ

Each choice maps $\lvert\Phi^+\rangle$ to a different Bell state, and the four Bell states are orthogonal; perfectly distinguishable in principle. Alice's qubit then travels to Bob, who now holds both qubits and decodes: CNOT with her qubit as control, then H on that same qubit, then measure. The CNOT basis action does the heavy lifting:

\operatorname{CNOT}\lvert c,t\rangle=\lvert c,t\oplus c\rangle

The decode step is exactly the Bell preparation circuit run backwards, converting Bell-basis information into computational-basis bits.

Evidence boundary. The four Pauli encodings map a Bell pair to four orthogonal Bell states. [Charles H. Bennett] [John Preskill]

The inverse preparation circuit decodes

Trace CNOT and H to computational outcomes.

"One qubit carries two bits" is the sentence that launches a thousand bad slides. Without pre-shared entanglement it is wrong: one transmitted qubit yields at most one classical bit of accessible information, a limit known as Holevo's bound. Superdense coding does not break that bound; it pre-pays it, shifting half the communication cost into the earlier distribution of the Bell pair.

The second omission is the physical transmission. Alice's qubit must survive the trip to Bob; the protocol is not remote action, and the channel's loss and noise belong in any honest accounting.

Evidence boundary. Decoding requires a joint Bell-basis measurement and the entanglement resource must be counted. [Michael A. Nielsen] [John Watrous]

(m_1,m_0)\in\{0,1\}^2,\qquad \lvert\Phi^+\rangle=(\lvert00\rangle+\lvert11\rangle)/\sqrt2

A complete trace for message 10

Show state after every operation and transfer boundary.

Read superdense coding the way you would read any network protocol; phases, plus a resource ledger:

Prepare a Bell pair.
Distribute one half to Alice and one half to Bob; possibly long before the message exists.
Alice applies one of four local gates.
Alice's qubit travels the quantum channel.
Bob applies the inverse Bell-preparation circuit.
Bob measures and recovers two bits.

This style of accounting generalizes to every protocol in the book: name the setup cost before celebrating the per-message cost. A communication advantage that depends on resources prepared elsewhere is real, but it is a systems claim, not a magic trick.

Count the ebit and the Bell measurement

Compare resources with a classical channel honestly.

If a pitch invokes superdense coding, walk the chain: where does the entanglement come from, how is it distributed and stored, how long does it survive, what do channel loss and gate errors do to decoding, and does the end-to-end system beat the classical alternative after all of that?

The protocol itself is valid, demonstrated physics. The product claim stands or falls on the resource chain around it; and on whether doubling classical capacity on an expensive quantum channel is worth anything against cheap classical bandwidth.

Superdense coding protocol harness

Acceptance contract for Superdense coding protocol harness
Field	Reader-visible record
Format	Two-qubit circuit suite and four-message truth table
Verification	Tests every message maps to a unique decoded bit pair, rejects runs without the shared Bell pair, and reports transmitted-qubit plus ebit resources.
Availability	Source-embedded acceptance record; no separate download is claimed

{
  "artifact": "Superdense coding protocol harness",
  "format": "Two-qubit circuit suite and four-message truth table",
  "acceptance_test": "Tests every message maps to a unique decoded bit pair, rejects runs without the shared Bell pair, and reports transmitted-qubit plus ebit resources.",
  "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

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

def pauli(state, qubit, name):
    mask = 1 << (1 - qubit)
    output = [0j] * 4
    for basis, amplitude in enumerate(state):
        if name == "X":
            output[basis ^ mask] += amplitude
        elif name == "Z":
            output[basis] += -amplitude if basis & mask else amplitude
        else:
            raise ValueError("only Pauli X and Z are supported")
    return output

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

def prepare(shared_entanglement):
    state = [1.0, 0j, 0j, 0j]
    if shared_entanglement:
        state = cnot(h(state, 0), 0, 1)
    return state

def encode(state, message):
    first, second = message
    if second:
        state = pauli(state, 0, "X")
    if first:
        state = pauli(state, 0, "Z")
    return state

def decode(state, reversed_order=False):
    state = h(state, 0) if reversed_order else cnot(state, 0, 1)
    state = cnot(state, 0, 1) if reversed_order else h(state, 0)
    return state

def distribution(state):
    return {format(index, "02b"): round(abs(amplitude) ** 2, 12)
            for index, amplitude in enumerate(state) if abs(amplitude) > 1e-12}

def inner(left, right):
    return sum(a.conjugate() * b for a, b in zip(left, right))

messages = [(0, 0), (0, 1), (1, 0), (1, 1)]
bell = prepare(True)
assert all(abs(a - b) < 1e-12 for a, b in zip(bell, [math.sqrt(0.5), 0, 0, math.sqrt(0.5)]))
codewords = {message: encode(bell, message) for message in messages}
for left in messages:
    for right in messages:
        overlap = abs(inner(codewords[left], codewords[right]))
        assert abs(overlap - (1.0 if left == right else 0.0)) < 1e-12

traces = {}
for message in messages:
    encoded = codewords[message]
    decoded = decode(encoded)
    observed = distribution(decoded)
    expected = {"".join(str(bit) for bit in message): 1.0}
    assert observed == expected
    traces[message] = (bell, encoded, decoded, observed)
assert len({next(iter(trace[3])) for trace in traces.values()}) == 4

without_ebit = {message: distribution(decode(encode(prepare(False), message))) for message in messages}
assert without_ebit[(0, 0)] == without_ebit[(1, 0)]
assert without_ebit[(0, 1)] == without_ebit[(1, 1)]
assert len({tuple(sorted(value.items())) for value in without_ebit.values()}) == 2

wrong_decode = {message: distribution(decode(codewords[message], True)) for message in messages}
assert any(wrong_decode[message] != {"".join(str(bit) for bit in message): 1.0} for message in messages)
resources = {"transmitted_qubits": 1, "shared_ebits_consumed": 1, "decoded_classical_bits": 2}
assert resources == {"transmitted_qubits": 1, "shared_ebits_consumed": 1, "decoded_classical_bits": 2}
print(f"PASS: 24 superdense circuit codewords={len(codewords)} decoded={len(traces)} no_ebit_outputs={len({tuple(sorted(value.items())) for value in without_ebit.values()})}")

Scope boundary

This chapter does not claim one isolated qubit stores two readable classical bits.
It does not ignore entanglement distribution, Bell measurement, channel noise, or resource accounting.

Depth commitment. One contract, one encoding table, one full trace, and one negative control.

Practice problem

Trace all four messages through encoding and decoding, then repeat one message after replacing the Bell pair with |00>.

Deliverable: Five state traces, decoded outputs, and a resource/failure comparison.
Pass condition: The circuit tests verify the four-message bijection and demonstrate loss of two-bit capacity in the no-entanglement control.

Verification record

Expected solution form. Four-row symbolic protocol table plus negative-control simulation.

Model answer. With a shared |Phi+>, I, X, Z, and ZX on the sender's half decode bijectively to 00, 01, 10, and 11 under the stated bit convention. Replacing the pair by |00> removes the four orthogonal Bell codewords, so one transmitted qubit no longer carries two recoverable classical bits.

Model result and check. CI simulates every row and checks the declared communication resources.

Acceptance test. The circuit tests verify the four-message bijection and demonstrate loss of two-bit capacity in the no-entanglement control.

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
Superdense coding protocol harness
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

Superdense Coding

Write the communication contract first

Four local operations label four Bell states

The inverse preparation circuit decodes

A complete trace for message 10

Count the ebit and the Bell measurement

Superdense coding protocol harness

Artifacts for this chapter

Superdense coding protocol harness

Sources and review

Cite this chapter

Write the communication contract first#

Four local operations label four Bell states#

The inverse preparation circuit decodes#

A complete trace for message 10#

Count the ebit and the Bell measurement#

Superdense coding protocol harness#

Artifacts for this chapter

Superdense coding protocol harness

Sources and review

Prerequisites for this chapter

Next concepts from this chapter

Write the communication contract first

Four local operations label four Bell states

The inverse preparation circuit decodes

A complete trace for message 10

Count the ebit and the Bell measurement

Superdense coding protocol harness