Superdense Coding Protocol

The Goal: Doubling the Information Capacity

Imagine Alice wants to send a two-bit classical message—00, 01, 10, or 11—to Bob. Conventionally, she would need to send two classical bits. If she were to use quantum bits without any special resources, she would still need to send two qubits to guarantee the transmission of two bits of information.

Superdense coding provides a more efficient method. The setup is:

1. Alice and Bob each possess one qubit from an entangled pair. Let's assume they share the Bell state $|{\Phi }^{+}⟩=\frac{1}{\sqrt{2}}(|00⟩+|11⟩)$.
2. Alice wants to send Bob her two classical bits, let's call them $b_1{b}_2$.
3. The only communication channel she can use is a quantum one: she is only allowed to physically send her single qubit to Bob.

This counter-intuitive ability to send two classical bits via one qubit is why the protocol is called "superdense." It effectively doubles the classical information capacity of a quantum channel, but it comes at the cost of consuming one pre-shared entangled pair (often called an "e-bit").

This is a powerful demonstration of entanglement's value. A famous result in quantum information theory, Holevo's theorem, proves that it's impossible to reliably transmit more than one classical bit by sending a single qubit without entanglement. Superdense coding is a beautiful example of how entanglement provides a genuine advantage.

The Superdense Coding Protocol

The protocol can be broken down into three main stages: preparation, encoding (by Alice), and decoding (by Bob).

The circuit diagram below illustrates the entire process. We'll walk through each part.

Let's watch a video that outlines these steps clearly.

Now let's break down Alice's encoding and Bob's decoding steps in more detail.

Step 1: Alice's Encoding

The core of the protocol lies in how Alice uses her two classical bits to manipulate the shared entangled state. She starts with her qubit (let's call it $q_A$) and Bob with his ($q_B$), which together are in the state $|{\Phi }^{+}⟩$. By applying a specific gate only to her qubit, she can transform the shared state into one of four distinct, orthogonal Bell states.

The encoding scheme is as follows:

• To send 00, Alice does nothing (applies the Identity gate, $I$).
• To send 01, Alice applies a bit-flip (Pauli-X gate, $X$).
• To send 10, Alice applies a phase-flip (Pauli-Z gate, $Z$).
• To send 11, Alice applies a Z gate followed by an X gate ($XZ$).

Let's see the effect this has on the shared state $|{\Phi }^{+}⟩=\frac{1}{\sqrt{2}}(|00{⟩}_{AB}+|11{⟩}_{AB})$.

After performing her chosen operation, Alice sends her qubit, $q_A$, to Bob.

This process is explained very clearly in the following video from the Qiskit team.

Step 2: Bob's Decoding

Bob now possesses both qubits, $q_A$ and $q_B$. They are in one of the four possible Bell states, and his task is to perform a measurement that unambiguously tells him which one it is.

To do this, he applies a decoding circuit which is simply the inverse of the Bell state creation circuit.

1. He applies a CNOT gate, using Alice's qubit ($q_A$) as the control and his qubit ($q_B$) as the target.
2. He then applies a Hadamard gate to Alice's qubit ($q_A$).

This set of operations transforms the Bell basis back into the computational basis, as shown below:

• If the state was $|{\Phi }^{+}⟩$, it becomes $|00⟩$.
• If the state was $|{\Psi }^{+}⟩$, it becomes $|01⟩$.
• If the state was $|{\Phi }^{-}⟩$, it becomes $|10⟩$.
• If the state was $|{\Psi }^{-}⟩$, it becomes $|11⟩$.

All Bob has to do now is measure both qubits. The measurement outcome directly corresponds to the two-bit message Alice intended to send.

The following reading from IBM provides a concise summary of this entire process, from Alice's encoding to Bob's decoding and final measurement.

And with that, the protocol is complete! Alice has successfully transmitted two classical bits to Bob by physically sending only one qubit, all thanks to the power of a shared entangled pair.

Conclusion

In this lesson, we have explored the superdense coding protocol, a cornerstone of quantum communication. We've seen how it cleverly uses the properties of entanglement to achieve a surprising result.

Key Takeaways:

• Goal: Superdense coding transmits two classical bits of information from a sender (Alice) to a receiver (Bob).
• Resources: It requires a pre-shared entangled qubit pair (an e-bit) and the ability for Alice to send one qubit to Bob through a quantum channel.
• Alice's Role (Encoding): Alice encodes her two classical bits ($b_1{b}_2$) by applying one of four specific operations ($I,X,Z,\text{or }ZX$) to her qubit. This transforms the shared Bell state into one of four distinct, orthogonal Bell states.
• Bob's Role (Decoding): After receiving Alice's qubit, Bob applies an inverse Bell circuit (CNOT followed by H) to the pair. This maps the Bell state back to a computational basis state ($|00⟩,|01⟩,|10⟩,\text{or }|11⟩$).
• Measurement: A final measurement by Bob reveals the computational basis state, which directly corresponds to the two classical bits Alice sent.

This protocol provides a beautiful symmetry with quantum teleportation.

• Teleportation: 1 e-bit + 2 classical bits $\to$ 1 qubit of communication.
• Superdense Coding: 1 e-bit + 1 qubit $\to$ 2 classical bits of communication.

Together, they show that entanglement can act as a bridge, allowing for the conversion between quantum and classical communication resources.

Preview of the Next Lesson:
We've now covered the theory and step-by-step process of superdense coding. In our next lesson, we will put this knowledge into practice by implementing and verifying the superdense coding circuit in Qiskit. You'll build the circuit, simulate it for each of the four possible messages, and confirm that Bob always receives the correct information.