Superdense Coding

Teleportation’s mirror image: send two classical bits by physically shipping just one qubit — because a shared entangled pair did half the work in advance.

Quantum Computing · Lesson 28 · 10 min read

Teleportation spent an entangled pair plus two classical bits to move one qubit’s state. Now flip the question around, and you get its beautiful mirror image. Suppose Alice wants to send Bob two classical bits of information, but she’s only allowed to physically send him one qubit. Impossible? A single qubit, when you measure it, gives just one bit. Yet with a resource shared in advance, Alice can pack two classical bits into that one qubit. This is superdense coding. Hold the question: how can one qubit deliver two bits — and why isn’t that a free doubling of every channel?

The setup mirrors teleportation

Just like last lesson, it starts with Alice and Bob sharing an entangled pair — one qubit each, arranged in advance. That shared pair is again the pre-laid resource. The difference is what flows and what’s counted: in teleportation, a physical qubit’s state moved and the cost was two classical bits. In superdense coding, two classical bits move and the cost is sending one physical qubit (plus the pre-shared pair). They are two sides of one coin — trading a qubit against two bits, using entanglement as the exchange rate.

How one qubit carries two bits

Alice wants to send one of four messages: 00, 01, 10, or 11. She applies one of four operations to her own half of the entangled pair — each operation nudges the pair into a distinct, perfectly-distinguishable joint state. Then she physically sends her single qubit to Bob. Now Bob holds both qubits of the pair, and because the four joint states are fully distinguishable, a joint measurement on the two together tells him exactly which of the four — recovering both classical bits. The magic is that Alice’s local nudge, thanks to the pre-existing entanglement, steered the whole pair — so one qubit’s worth of transmission unlocked two bits’ worth of message.

Sending “10” with one qubit:
1. Alice & Bob pre-share an entangled pair (one qubit each).
2. To encode “10,” Alice applies the third of four operations to her qubit.
3. She ships that single qubit to Bob.
4. Bob now has both qubits; a joint measurement reads out “10” with certainty. One qubit sent, two bits delivered — the entangled pair pre-paid the difference.

The honest accounting: no free lunch

Why isn’t this a free doubling of every channel? Because the entangled pair had to be distributed beforehand — and getting Bob his half meant sending a qubit earlier. Count the whole ledger and it balances: to later send two bits with one qubit, you had to pre-send one qubit to set up the pair. Entanglement is a resource that’s spent, not a loophole: each shared pair is consumed by one round of superdense coding and must be replenished. What it really buys is timing — you can lay in the entangled pairs during quiet periods and then transmit dense messages later — not something for nothing. This “entanglement is a consumable resource” idea is the beating heart of the whole module: no-cloning, teleportation, and superdense coding are all about spending and respecting that resource.

The full ledger, so you see it balances:
1. Quiet period: Alice sends Bob his half of an entangled pair — that’s one qubit transmitted, in advance.
2. Busy period: Alice encodes two classical bits by operating on her half, then sends that one qubit.
3. Bob jointly measures both halves and recovers the two bits.
4. Tally: two qubits transmitted in total (one early, one late) to move two classical bits — no magic doubling. The win is that the expensive step happened earlier, freeing the busy channel to look twice as dense when it counts.