DEV Community

Malcolm Low
Malcolm Low

Posted on Originally published at malcolmlow.com

Superdense Coding Explained: Transmitting 2 Classical Bits in 1 Qubit with Qiskit 2.x

#quantum #python #qiskit #physics

Module 3b in the Quantum Computing: A Complete Learning Path series. Following directly from Two-Qubit Entanglement & The 4 Bell States (Module 3) and bridging the transition to Quantum Teleportation (Module 9).

In classical information theory, transmitting two bits of information (such as 00, 01, 10, or 11) strictly requires sending two physical signals. If you have only a single physical wire or send a single classical pulse, the laws of physics dictate that you can transmit at most one bit of data. In quantum information theory, a celebrated theorem known as Holevo's Bound (1973) proved that an isolated single qubit can likewise communicate at most one bit of classical information.

Yet, in 1992, physicists Charles Bennett and Stephen Wiesner discovered a startling loophole: if the sender and receiver share an entangled pair of qubits beforehand, the sender can physically transmit just one single qubit and deliver two full classical bits with 100% deterministic accuracy. This protocol is called Superdense Coding (or Dense Coding).

In this guide, we break down the mechanics of superdense coding, demonstrate how Alice transforms the shared Bell pair using local Pauli gates, analyze Bob's deterministic Bell decoder, and verify the protocol using Qiskit 2.x with circuit diagrams.

1. The Communication Limit: Holevo’s Bound vs. Entanglement

To appreciate why superdense coding is remarkable, we must first understand the fundamental limit on quantum communication:

Holevo's Bound (Without Entanglement):
1 Transmitted Qubit → At most 1 Accessible Classical Bit

Superdense Coding (With 1 Pre-Shared Bell Pair):
1 Transmitted Qubit → Exactly 2 Accessible Classical Bits
Enter fullscreen mode Exit fullscreen mode

Even though a single qubit pure state $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$ contains continuous complex amplitudes $\alpha$ and $\beta$ (an infinite amount of theoretical mathematical parameters), any measurement causes the qubit to collapse into either $|0\rangle$ or $|1\rangle$. Therefore, a receiver without prior entanglement can never extract more than 1 classical bit of information from a single qubit.

How does superdense coding bypass this? It does not violate Holevo’s bound because entanglement acts as a physical communication resource. The two classical bits are not crammed into the single transmitted qubit alone. Instead, the transmitted qubit acts as an address key that unlocks the correlation already stored in the shared two-qubit entangled system.

2. The 4-Step Protocol: Alice, Bob, and Charlie

The superdense coding protocol unfolds across four sequential stages between three actors: a source (Charlie), the sender (Alice), and the receiver (Bob):

  1. Step 1 — Entanglement Distribution: Charlie prepares an entangled Bell pair $|\Phi^+\rangle = (|00\rangle + |11\rangle) / \sqrt{2}$. He sends qubit 0 ($q_0$) to Alice and qubit 1 ($q_1$) to Bob. Alice and Bob can now be arbitrarily far apart.
  2. Step 2 — Alice’s Local Encoding: Alice wants to send a 2-bit message $m \in {00, 01, 10, 11}$. She applies a single local Pauli gate ($I$, $Z$, $X$, or $ZX$) to her qubit $q_0$ only. She never touches Bob’s qubit.
  3. Step 3 — Physical Transmission: Alice sends her single physical qubit $q_0$ over a quantum communication channel (such as an optical fiber) to Bob.
  4. Step 4 — Bob’s Bell Basis Decoding: Bob now holds both qubits ($q_0$ and $q_1$). He runs the Bell Basis Decoder (a CNOT gate followed by a Hadamard on $q_0$) and measures both qubits in the computational basis, reading Alice’s 2-bit message with 100% deterministic certainty.

Superdense Coding Protocol Overview Circuit
Circuit 1: The complete Superdense Coding protocol showing Entanglement Preparation, Alice’s Local Encoding, and Bob’s Bell Basis Decoder.

3. The 4 Encoding Operations: From Bits to Bell States

In Module 3 (The 4 Bell States), we discovered that the 4 Bell states form an orthonormal basis for two qubits. Alice's brilliance in superdense coding is that by applying only local single-qubit gates to her half of $|\Phi^+\rangle$, she can steer the joint two-qubit state into any one of the four orthogonal Bell states:

Case 1: Message 00 — Identity Gate $I$

Alice leaves her qubit untouched (applies Identity $I$). The joint state remains the original Bell state $|\Phi^+\rangle$:

(I ⊗ I) |Φ+⟩ = ( |00⟩ + |11⟩ ) / √2 = |Φ+⟩
Enter fullscreen mode Exit fullscreen mode

SDC Message 00 Circuit
Circuit 2: Superdense coding for message 00 (Identity gate on q0 → Bob measures 00).

Case 2: Message 01 — Pauli-Z Gate $Z$ (Phase-Flip)

Alice applies a $Z$ gate to $q_0$. Since $Z|0\rangle = |0\rangle$ and $Z|1\rangle = -|1\rangle$, the relative phase flips from $+$ to $-$, converting the state to $|\Phi^-\rangle$:

(Z ⊗ I) |Φ+⟩ = ( |00⟩ - |11⟩ ) / √2 = |Phi-⟩
Enter fullscreen mode Exit fullscreen mode

SDC Message 01 Circuit
Circuit 3: Superdense coding for message 01 (Z gate on q0 → Bob measures 01).

Case 3: Message 10 — Pauli-X Gate $X$ (Bit-Flip)

Alice applies an $X$ gate to $q_0$. Since $X|0\rangle = |1\rangle$ and $X|1\rangle = |0\rangle$, the bit correlations flip from equal parity to anti-correlated, converting the state to $|\Psi^+\rangle$:

(X ⊗ I) |Φ+⟩ = ( |10⟩ + |01⟩ ) / √2 = |Ψ+⟩
Enter fullscreen mode Exit fullscreen mode

SDC Message 10 Circuit
Circuit 4: Superdense coding for message 10 (X gate on q0 → Bob measures 10).

Case 4: Message 11 — Both Gates $ZX$ (Bit & Phase Flip)

Alice applies both $Z$ and $X$ gates (or $iY$). This flips both the bit values and the relative sign, transforming the state into the Singlet state $|\Psi^-\rangle$ (up to global phase):

(ZX ⊗ I) |Φ+⟩ = ( -|01⟩ + |10⟩ ) / √2 = -|Ψ-⟩ ≡ |Ψ-⟩
Enter fullscreen mode Exit fullscreen mode

SDC Message 11 Circuit
Circuit 5: Superdense coding for message 11 (Z followed by X on q0 → Bob measures 11).

Superdense Coding Protocol Truth Table

Target Message Alice's Local Gate Encoded Bell State Bob's Decoder ($CX \to H$) Measured Classical Bits
00 $I$ (None) $\ \Phi^+\rangle$ $\
01 $Z$ (Phase-Flip) $\ \Phi^-\rangle$ $\
10 $X$ (Bit-Flip) $\ \Psi^+\rangle$ $\
11 $ZX$ (Bit & Phase) $\ \Psi^-\rangle$ $\

4. Why Superdense Coding Cannot Transmit Faster Than Light

A natural question arises: If Alice applies her encoding gate immediately on qubit 0, does Bob instantly receive her message across the universe?

Can Bob read Alice's message before receiving her qubit?
Answer: NO. Bob's qubit in isolation is in a Maximally Mixed State (|r| = 0).
Enter fullscreen mode Exit fullscreen mode

As we established in Module 3, as long as Bob holds only qubit $q_1$ in isolation, his reduced density matrix is identical regardless of which gate Alice applied:

  • If Alice applies $I$: Bob's local state is 50% $|0\rangle$, 50% $|1\rangle$ (pure noise)
  • If Alice applies $Z$: Bob's local state is 50% $|0\rangle$, 50% $|1\rangle$ (pure noise)
  • If Alice applies $X$: Bob's local state is 50% $|0\rangle$, 50% $|1\rangle$ (pure noise)
  • If Alice applies $ZX$: Bob's local state is 50% $|0\rangle$, 50% $|1\rangle$ (pure noise)

No measurement Bob performs on his own qubit alone can reveal any information about which gate Alice selected! Zero information is transmitted until Alice physically transports qubit $q_0$ across space to Bob. Because the physical transmission of a qubit is bounded by the speed of light $c$, Einstein's causality is rigorously preserved.

5. The Quantum Resource Duality: Superdense Coding vs. Teleportation

Superdense coding and Quantum Teleportation (Module 9) form the fundamental dual pillars of quantum communication. They represent the exact reciprocal exchange rate between quantum and classical channels:

Feature Superdense Coding (Module 3b) Quantum Teleportation (Module 9)
Objective Transmit 2 classical bits Transmit 1 unknown quantum state
Pre-Shared Resource 1 shared Bell pair ($|\Phi^+\rangle$) 1 shared Bell pair ($|\Phi^+\rangle$)
Channel Transmitted 1 physical qubit (quantum channel) 2 classical bits (classical radio/fiber)
Information Exchange 1 e-bit + 1 qubit $\to$ 2 classical bits 1 e-bit + 2 classical bits $\to$ 1 qubit

In both protocols, 1 Bell pair (1 e-bit of entanglement) acts as a currency that doubles the power of the transmitted channel!

6. Complete Qiskit 2.x Python Implementation 

import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

def build_superdense_circuit(message: str) -> QuantumCircuit:
    """
    Builds an end-to-end Superdense Coding circuit in Qiskit 2.x.
    """
    qc = QuantumCircuit(2, 2)

    # --- PHASE 1: PRE-SHARED ENTANGLEMENT (Charlie) ---
    qc.h(0)
    qc.cx(0, 1)
    qc.barrier(label="Bell Pair")

    # --- PHASE 2: ALICE'S LOCAL ENCODING (on qubit 0) ---
    if message == "00":
        qc.id(0)          # Identity: do nothing
    elif message == "01":
        qc.z(0)           # Phase-flip: |Phi+> -> |Phi->
    elif message == "10":
        qc.x(0)           # Bit-flip:   |Phi+> -> |Psi+>
    elif message == "11":
        qc.z(0)
        qc.x(0)           # Bit & Phase: |Phi+> -> -|Psi->
    else:
        raise ValueError("Message must be '00', '01', '10', or '11'")

    qc.barrier(label="Alice Transmits q0")

    # --- PHASE 3: BOB'S BELL BASIS DECODER ---
    qc.cx(0, 1)
    qc.h(0)
    qc.barrier(label="Bob Decodes")

    # Measure both qubits into classical register
    qc.measure([0, 1], [0, 1])
    return qc

# --- SIMULATION & VERIFICATION OF ALL 4 MESSAGES ---
print("=== Superdense Coding Simulation (Qiskit 2.x) ===\n")

test_messages = ["00", "01", "10", "11"]

for msg in test_messages:
    qc = build_superdense_circuit(msg)
    qc_no_meas = qc.remove_final_measurements(inplace=False)

    sv = Statevector(qc_no_meas)
    probs = sv.probabilities_dict()
    formatted_probs = {k: round(float(v), 2) for k, v in probs.items() if v > 1e-6}

    print(f"Target Message Sent : '{msg}'")
    print(f"Bob's Decoded State : {formatted_probs}")
    print(f"Verification Status : {'PASS (100% Certainty)' if msg in formatted_probs and formatted_probs[msg] == 1.0 else 'FAIL'}")
    print("-" * 45)
Enter fullscreen mode Exit fullscreen mode

Execution Output: 

=== Superdense Coding Simulation (Qiskit 2.x) ===

Target Message Sent : '00'
Bob's Decoded State : {'00': 1.0}
Verification Status : PASS (100% Certainty)
---------------------------------------------
Target Message Sent : '01'
Bob's Decoded State : {'01': 1.0}
Verification Status : PASS (100% Certainty)
---------------------------------------------
Target Message Sent : '10'
Bob's Decoded State : {'10': 1.0}
Verification Status : PASS (100% Certainty)
---------------------------------------------
Target Message Sent : '11'
Bob's Decoded State : {'11': 1.0}
Verification Status : PASS (100% Certainty)
---------------------------------------------
Enter fullscreen mode Exit fullscreen mode

Key Insights & Takeaways

  1. Entanglement Doubles Classical Capacity: With one pre-shared Bell pair, transmitting 1 physical qubit transfers 2 classical bits deterministically.
  2. Local Gates Steer Global States: Alice applies local Pauli operations ($I$, $Z$, $X$, $ZX$) to her qubit alone, yet changes the joint entanglement basis into one of the 4 orthogonal Bell states.
  3. No FTL Communication: Bob gains zero bits of information until Alice’s physical qubit arrives through space. Causality is strictly maintained.
  4. The Teleportation Duality: Superdense coding trades 1 qubit for 2 classical bits; quantum teleportation trades 2 classical bits for 1 qubit.

Continue the Quantum Series:

Top comments (0)