Superdense coding

Superdense coding is Alice and Bob’s first actual quantum protocol. The setup: Alice wants to send Bob two classical bits. She is only allowed to send one qubit through the channel. Classically, this is impossible — one bit of information per bit of channel, no exceptions.

With a shared Bell pair, Alice can do it.

The protocol

Preparation (before the game starts): Someone prepares a Bell pair $|\Phi^+\rangle = (|00\rangle + |11\rangle)/\sqrt{2}$ and gives one qubit to Alice and one to Bob. This is a free resource — Alice and Bob set it up in advance.

Encoding (Alice): Depending on the two classical bits $(b_1, b_0)$ she wants to send, Alice applies one of four gates to her qubit:

Each of the four possible bit combinations maps to a distinct Bell state.

Transmission (Alice → Bob): Alice sends her qubit to Bob via a quantum channel (fiber optic, laser pulse, etc.). Only one qubit physically crosses the wire.

Decoding (Bob): Bob now holds both qubits. He applies $CNOT$ (with Alice’s qubit as control, his as target), then $H$ to Alice’s qubit. This is the reverse of the Bell-pair-preparation circuit. Finally, he measures both qubits in the computational basis.

The result: Bob’s two measurement outcomes are exactly Alice’s two classical bits.

Walk through it

Try each of the four possible bit pairs. Each time, watch:

1. The initial Bell state $|\Phi^+\rangle$
2. Alice’s encoding — the state transitions from $|\Phi^+\rangle$ to one of the other three Bell states (or stays put for $(0,0)$)
3. Bob’s decoder — the state collapses to a single computational basis state
4. The measured bits perfectly match what Alice sent

Why this works

The deep reason superdense coding works is that the four Bell states form an orthogonal basis of the 2-qubit state space. They are distinguishable — any two distinct Bell states are orthogonal, so Bob’s measurement can always tell them apart without error.

Alice’s encoding only touches her single qubit, but because of the shared entanglement, that single operation transforms the joint state from one Bell state into another. When Bob gets Alice’s qubit and combines it with his own (which he already had), the two-qubit state contains two bits of information — even though Alice only physically sent one qubit.

The catch (there’s always a catch)

Does this mean a single qubit carries 2 bits of information? Not exactly. Superdense coding only beats classical communication if Alice and Bob already share an entangled pair. Setting up that Bell pair requires one qubit of prior communication (or a shared entanglement source). So the total communication cost is: one qubit now, plus one qubit earlier. The “free” part is that the setup can happen any time before Alice knows what message to send.

This is a common pattern in quantum information: entanglement is a resource that can be consumed later to achieve effects impossible classically. It’s like pre-sharing a one-time pad in cryptography — you can’t use the pad to send messages at the moment of sharing, but once you have it, you can communicate securely forever after.

What this does and doesn’t prove

Superdense coding is genuinely non-classical. No classical protocol can send two bits through a channel that only transmits one bit, no matter how much pre-shared randomness Alice and Bob have. This is a theorem (a simple counting argument), and superdense coding breaks it by using entanglement — which isn’t just “shared randomness.”

But superdense coding doesn’t send messages faster than light, doesn’t transmit quantum states (that’s next lesson), and doesn’t help you compute faster. It’s a specific, narrow protocol that demonstrates the resource power of entanglement.

What’s next

Superdense coding sent classical bits using a quantum channel + entanglement. The next protocol does the reverse: it sends a quantum state using a classical channel + entanglement. It’s called quantum teleportation, and it’s arguably the most famous result in quantum information.