Information Theory

Superdense Coding

Sending Two Classical Bits with One Qubit

Superdense coding is a quantum communication protocol that allows Alice to send two classical bits to Bob by transmitting only one qubit, provided they share a maximally entangled Bell pair beforehand. It is the conceptual inverse of quantum teleportation and demonstrates how entanglement can double the classical capacity of a quantum channel.

The Protocol

Alice and Bob begin by sharing a Bell pair |Φ⁺⟩ = (|00⟩ + |11⟩)/√2, with Alice holding the first qubit and Bob holding the second. Alice wants to send two classical bits, b1 and b2, to Bob. She does this by applying one of four Pauli operations to her qubit: I (identity), X, Z, or ZX, depending on the bits she wishes to send.

Specifically, if Alice wants to send 00, she does nothing (applies I). For 01, she applies X, which maps |Φ⁺⟩ to |Ψ⁺⟩ = (|01⟩ + |10⟩)/√2. For 10, she applies Z, producing |Φ⁻⟩ = (|00⟩ - |11⟩)/√2. For 11, she applies ZX, yielding |Ψ⁻⟩ = (|01⟩ - |10⟩)/√2. These four states are the four Bell states, which form an orthonormal basis for the two-qubit Hilbert space.

Alice then sends her single qubit to Bob through a quantum channel. Bob now holds both qubits. He performs a Bell state measurement by applying a CNOT followed by a Hadamard on Alice's qubit, then measuring both qubits in the computational basis. The measurement outcome directly reveals the two bits Alice encoded.

|\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}}

Initial Bell pair

\begin{aligned} 00 &\rightarrow |\Phi^+\rangle \\ 01 &\rightarrow |\Psi^+\rangle = \frac{|01\rangle + |10\rangle}{\sqrt{2}} \\ 10 &\rightarrow |\Phi^-\rangle = \frac{|00\rangle - |11\rangle}{\sqrt{2}} \\ 11 &\rightarrow |\Psi^-\rangle = \frac{|01\rangle - |10\rangle}{\sqrt{2}} \end{aligned}

Encoded states

•Shared Entanglement: Alice and Bob must share a Bell pair before communication begins.
•Encoding: Alice applies one of {I, X, Z, ZX} to her qubit to encode two classical bits.
•Transmission: Only one qubit is sent from Alice to Bob through the quantum channel.
•Decoding: Bob performs a Bell measurement to perfectly distinguish the four encoded states.

Quantum Advantage

Without shared entanglement, sending two classical bits requires transmitting two qubits (or two classical bits). With superdense coding, the same information is conveyed using only one transmitted qubit plus the prior shared entanglement. This effectively doubles the classical capacity of the quantum channel, though the entanglement itself is consumed in the process and cannot be reused.

The protocol is optimal: it is impossible to send more than two classical bits with one qubit even with unlimited shared entanglement, as proven by the Holevo bound. Superdense coding therefore achieves the theoretical maximum for this setting. It also demonstrates a fundamental asymmetry in quantum information: one ebit (one Bell pair) plus one qubit can communicate two classical bits, while quantum teleportation shows that one ebit plus two classical bits can communicate one qubit.

1 \text{ ebit} + 1 \text{ qubit} \rightarrow 2 \text{ classical bits}

Resource trade-off

(H \otimes I) \cdot \text{CNOT} \cdot |\text{Bell}\rangle = |b_1 b_2\rangle

Bob decoding

•Channel Capacity: Superdense coding doubles the classical information capacity of a noiseless quantum channel.
•Optimality: The Holevo bound proves that two bits is the maximum that can be sent with one qubit.
•Entanglement Cost: One ebit (Bell pair) is consumed per use of the protocol.

Relationship with Teleportation

Superdense coding and quantum teleportation are dual protocols that together form a complete picture of quantum communication. Teleportation uses one ebit plus two classical bits to send one qubit. Superdense coding uses one ebit plus one qubit to send two classical bits. If Alice teleports a qubit to Bob, and Bob then uses superdense coding to send two bits back, the net resource exchange is symmetric: two classical bits and one ebit are swapped for one qubit and one ebit.

Both protocols rely on the same ingredients — entanglement, local operations, and classical communication — and both are limited by the no-signaling principle. Neither protocol allows faster-than-light communication because each requires a classical channel to complete the information transfer. Together, they demonstrate that entanglement is a fungible resource in quantum information theory, interconvertible between quantum and classical communication tasks.

•Teleportation: 1 ebit + 2 classical bits → 1 qubit.
•Superdense Coding: 1 ebit + 1 qubit → 2 classical bits.
•LOCC: Both protocols are examples of Local Operations and Classical Communication (LOCC).

Code in Action

Runnable implementations you can copy and experiment with.

Superdense Coding with Qiskit

A complete superdense coding circuit where Alice encodes the bits '11' and Bob decodes them using a Bell measurement.

superdense_coding_qiskit.py

from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

bits = '11'
qc = QuantumCircuit(2, 2)

# Create Bell pair
qc.h(0)
qc.cx(0, 1)

# Alice encodes her two classical bits
if bits[1] == '1':
    qc.x(0)
if bits[0] == '1':
    qc.z(0)

# Bob decodes with Bell measurement
qc.cx(0, 1)
qc.h(0)

# Measure both qubits
qc.measure([0, 1], [0, 1])

# Execute
simulator = AerSimulator()
job = simulator.run(qc, shots=1024)
counts = job.result().get_counts()
received = max(counts, key=counts.get)
print(f"Sent: {bits}, Received: {received}")
# Expected: Sent: 11, Received: 11

Superdense Coding with PennyLane

PennyLane implementation of superdense coding encoding and decoding two classical bits.

superdense_coding_pennylane.py

import pennylane as qml

dev = qml.device("default.qubit", wires=2)

@qml.qnode(dev)
def superdense_coding(bits):
    # Create Bell pair
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])
    
    # Alice encodes two classical bits
    if bits[1] == 1:
        qml.PauliX(wires=0)
    if bits[0] == 1:
        qml.PauliZ(wires=0)
    
    # Bob decodes
    qml.CNOT(wires=[0, 1])
    qml.Hadamard(wires=0)
    
    return qml.counts(wires=[0, 1])

bits = [1, 1]
counts = superdense_coding(bits)
received = max(counts, key=counts.get)
print(f"Sent: {bits}, Received: {received}")
# Expected: Sent: [1, 1], Received: 11

Explore next

Quantum Teleportation

Explore next

Quantum Machine Learning

from qiskit import QuantumCircuit from qiskit_aer import AerSimulator bits = '11' qc = QuantumCircuit(2, 2) # Create Bell pair qc.h(0) qc.cx(0, 1) # Alice encodes her two classical bits if bits[1] == '1': qc.x(0) if bits[0] == '1': qc.z(0) # Bob decodes with Bell measurement qc.cx(0, 1) qc.h(0) # Measure both qubits qc.measure([0, 1], [0, 1]) # Execute simulator = AerSimulator() job = simulator.run(qc, shots=1024) counts = job.result().get_counts() received = max(counts, key=counts.get) print(f"Sent: {bits}, Received: {received}") # Expected: Sent: 11, Received: 11

import pennylane as qml dev = qml.device("default.qubit", wires=2) @qml.qnode(dev) def superdense_coding(bits): # Create Bell pair qml.Hadamard(wires=0) qml.CNOT(wires=[0, 1]) # Alice encodes two classical bits if bits[1] == 1: qml.PauliX(wires=0) if bits[0] == 1: qml.PauliZ(wires=0) # Bob decodes qml.CNOT(wires=[0, 1]) qml.Hadamard(wires=0) return qml.counts(wires=[0, 1]) bits = [1, 1] counts = superdense_coding(bits) received = max(counts, key=counts.get) print(f"Sent: {bits}, Received: {received}") # Expected: Sent: [1, 1], Received: 11