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

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

Even though a single qubit pure state |ψ⟩ = α|0⟩ + β|1⟩ contains continuous complex amplitudes α and β (an infinite amount of theoretical mathematical parameters), any measurement causes the qubit to collapse into either |0⟩ or |1⟩. 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.

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 |Φ+⟩ = ( |00⟩ + |11⟩ ) / √2. He sends qubit 0 (q₀) to Alice and qubit 1 (q₁) 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 ∈ {00, 01, 10, 11}. She applies a single local Pauli gate (I, Z, X, or ZX) to her qubit q₀ only. She never touches Bob’s qubit.
3. Step 3 — Physical Transmission: Alice sends her single physical qubit q₀ 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₀ and q₁). He runs the Bell Basis Decoder (a CNOT gate followed by a Hadamard on q₀) and measures both qubits in the computational basis, reading Alice’s 2-bit message with 100% deterministic certainty.

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

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 |Φ+⟩, 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 |Φ+⟩:

(I ⊗ I) |Φ+⟩ = ( |00⟩ + |11⟩ ) / √2 = |Φ+⟩

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₀. Since Z|0⟩ = |0⟩ and Z|1⟩ = −|1⟩, the relative phase flips from + to −, converting the state to |Φ−⟩:

(Z ⊗ I) |Φ+⟩ = ( |00⟩ − |11⟩ ) / √2 = |Φ−⟩

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₀. Since X|0⟩ = |1⟩ and X|1⟩ = |0⟩, the bit correlations flip from equal parity to anti-correlated, converting the state to |Ψ+⟩:

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

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 |Ψ−⟩ (up to global phase):

(ZX ⊗ I) |Φ+⟩ = ( −|01⟩ + |10⟩ ) / √2 = −|Ψ−⟩ ≡ |Ψ−⟩

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

Superdense Coding Protocol Truth Table

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).

As we established in Module 3, as long as Bob holds only qubit q₁ 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⟩, 50% |1⟩ (pure noise)
• If Alice applies Z: Bob’s local state is 50% |0⟩, 50% |1⟩ (pure noise)
• If Alice applies X: Bob’s local state is 50% |0⟩, 50% |1⟩ (pure noise)
• If Alice applies ZX: Bob’s local state is 50% |0⟩, 50% |1⟩ (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₀ 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.

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:

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

Below is the complete, self-contained Python script implementing Superdense Coding in Qiskit 2.x. The script defines the parameterized circuit for any 2-bit string and verifies that all four messages decode with 100% deterministic fidelity using statevector simulation:

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.
    
    Parameters:
        message (str): A 2-bit string, one of '00', '01', '10', '11'.
    
    Returns:
        QuantumCircuit: The full 2-qubit circuit with encoding and decoding.
    """
    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) ===
")

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

for msg in test_messages:
    # Build circuit without measurement for exact statevector analysis
    qc = build_superdense_circuit(msg)
    qc_no_meas = qc.remove_final_measurements(inplace=False)
    
    sv = Statevector(qc_no_meas)
    probs = sv.probabilities_dict()
    
    # Format non-zero probabilities
    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)

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)
---------------------------------------------