Quantum Entanglement: Teleportation, Superdense Coding, and Bell States

Quantum entanglement is a phenomenon where two or more particles become correlated in such a way that the state of one particle instantly influences the state of the other, no matter how far apart they are. This 'spooky action at a distance,' as Einstein called it, is not just a theoretical curiosity—it's the foundation of many quantum technologies. In this tutorial, we'll dive into two key applications: quantum teleportation and superdense coding. Quantum teleportation allows us to transfer an unknown quantum state from one location to another using entanglement and classical communication. Superdense coding, on the other hand, lets us send two classical bits of information by physically transmitting only one qubit. Both protocols rely on Bell states, which are specific maximally entangled two-qubit states. We'll implement these protocols using Python with Qiskit, a popular quantum computing framework. By the end, you'll understand how to create Bell states, perform teleportation, and achieve superdense coding, along with debugging insights from real-world quantum experiments.

Bell States: The Building Blocks

Bell states are a set of four maximally entangled two-qubit states. They form an orthonormal basis for the two-qubit Hilbert space. The four Bell states are:

These states are created using a Hadamard gate followed by a CNOT gate. The Hadamard puts the first qubit into a superposition, and the CNOT entangles it with the second qubit. Let's implement the creation of the |Φ⁺⟩ Bell state using Qiskit.

from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_bloch_multivector

# Create a quantum circuit with 2 qubits
qc = QuantumCircuit(2)

# Apply Hadamard on qubit 0
qc.h(0)
# Apply CNOT with control qubit 0 and target qubit 1
qc.cx(0, 1)

# Visualize the circuit
print(qc.draw())

# Simulate the circuit
backend = Aer.get_backend('statevector_simulator')
job = execute(qc, backend)
result = job.result()
statevector = result.get_statevector()
print(statevector)

# Plot the Bloch sphere
plot_bloch_multivector(statevector)

Quantum Teleportation Protocol

Quantum teleportation allows transferring an unknown quantum state from one qubit (the 'data' qubit) to another qubit (the 'target' qubit) using an entangled pair and classical communication. The protocol involves three qubits: the data qubit (q0), Alice's half of the entangled pair (q1), and Bob's half (q2). Steps:

1. Create a Bell state between q1 and q2.
2. Apply a CNOT from q0 to q1, then a Hadamard on q0.
3. Measure q0 and q1 in the computational basis, yielding two classical bits.
4. Based on the measurement outcomes, apply corrective gates (X and/or Z) to q2 to recover the original state.

Let's implement this in Qiskit.

from qiskit import QuantumCircuit, Aer, execute
from qiskit.quantum_info import random_statevector

# Create random state to teleport
psi = random_statevector(2)
print('State to teleport:', psi)

# Create circuit with 3 qubits and 2 classical bits
qc = QuantumCircuit(3, 2)

# Initialize q0 to the random state
qc.initialize(psi, 0)

# Create Bell state between q1 and q2
qc.h(1)
qc.cx(1, 2)

# Alice's operations
qc.cx(0, 1)
qc.h(0)

# Measure q0 and q1
qc.measure([0, 1], [0, 1])

# Bob's corrective gates based on measurement
qc.cx(1, 2)  # if q1 is 1, apply X
qc.cz(0, 2)  # if q0 is 1, apply Z

# Simulate
backend = Aer.get_backend('statevector_simulator')
job = execute(qc, backend)
result = job.result()
statevector = result.get_statevector()
print('Teleported state:', statevector)

# Check fidelity
from qiskit.quantum_info import state_fidelity
fidelity = state_fidelity(psi, statevector)
print('Fidelity:', fidelity)

Superdense Coding Protocol

Superdense coding allows sending two classical bits of information by transmitting only one qubit, provided the sender and receiver share an entangled pair. The protocol:

1. Alice and Bob share a Bell state (e.g., |Φ⁺⟩).
2. Alice applies one of four gates to her qubit depending on the two classical bits she wants to send:
3. - 00: I (identity)
4. - 01: X (bit flip)
5. - 10: Z (phase flip)
6. - 11: XZ (both)
7. Alice sends her qubit to Bob.
8. Bob performs a Bell state measurement (CNOT then Hadamard, then measure both qubits) to decode the two bits.

Let's implement this.

from qiskit import QuantumCircuit, Aer, execute
import random

# Random two classical bits
bits = [random.randint(0,1) for _ in range(2)]
print('Bits to send:', bits)

# Create circuit with 2 qubits and 2 classical bits
qc = QuantumCircuit(2, 2)

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

# Alice encodes her bits
if bits[0] == 1:
    qc.z(0)  # first bit: Z gate
if bits[1] == 1:
    qc.x(0)  # second bit: X gate

# Bob decodes: CNOT then Hadamard
qc.cx(0, 1)
qc.h(0)

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

# Simulate
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1)
result = job.result()
counts = result.get_counts()
measured_bits = list(counts.keys())[0]
print('Measured bits:', measured_bits)
print('Success:', bits == [int(b) for b in measured_bits])

Implementing Bell State Measurement

Bell state measurement is the process of projecting two qubits onto one of the four Bell states. It is essential for both teleportation and superdense coding. The standard circuit for Bell state measurement is the inverse of the Bell state creation: apply a CNOT followed by a Hadamard, then measure both qubits. The measurement outcomes correspond to the Bell states as follows:

• 00: |Φ⁺⟩
• 01: |Φ⁻⟩
• 10: |Ψ⁺⟩
• 11: |Ψ⁻⟩

Let's verify this by creating each Bell state and measuring.

from qiskit import QuantumCircuit, Aer, execute

# Function to create Bell state

def create_bell_state(qc, state):
    qc.h(0)
    qc.cx(0, 1)
    if state == 'phi+':
        pass
    elif state == 'phi-':
        qc.z(0)
    elif state == 'psi+':
        qc.x(0)
    elif state == 'psi-':
        qc.z(0)
        qc.x(0)

# Test each Bell state
for state in ['phi+', 'phi-', 'psi+', 'psi-']:
    qc = QuantumCircuit(2, 2)
    create_bell_state(qc, state)
    # Bell measurement
    qc.cx(0, 1)
    qc.h(0)
    qc.measure([0, 1], [0, 1])
    backend = Aer.get_backend('qasm_simulator')
    job = execute(qc, backend, shots=1000)
    counts = job.result().get_counts()
    print(f'{state}: {counts}')

Error Mitigation in Entanglement Protocols

Real quantum devices suffer from noise, gate errors, and decoherence. To make entanglement protocols practical, we need error mitigation techniques. Common methods include:

• Measurement error mitigation: Corrects for readout errors by characterizing the measurement noise matrix.
• Gate error mitigation: Uses techniques like randomized compiling or zero-noise extrapolation.
• Entanglement purification: Distills high-fidelity entangled pairs from multiple noisy pairs.

Let's implement measurement error mitigation for a Bell state measurement.

from qiskit import QuantumCircuit, Aer, execute
from qiskit.ignis.mitigation.measurement import (complete_meas_cal, CompleteMeasFitter)

# Create a simple Bell state circuit
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])

# Run on a noisy simulator (or real device)
from qiskit.providers.aer import QasmSimulator
from qiskit.providers.aer.noise import NoiseModel
from qiskit.test.mock import FakeVigo

# Use a fake backend for noise model
backend = FakeVigo()
noise_model = NoiseModel.from_backend(backend)

# Execute with noise
job = execute(qc, backend, shots=1000, noise_model=noise_model)
raw_counts = job.result().get_counts()
print('Raw counts:', raw_counts)

# Measurement error mitigation
meas_calibs, state_labels = complete_meas_cal(qubit_list=[0,1], circlabel='mcal')
job_cal = execute(meas_calibs, backend, shots=1000, noise_model=noise_model)
cal_results = job_cal.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels)
mitigated_counts = meas_fitter.filter.apply(raw_counts)
print('Mitigated counts:', mitigated_counts)

Real-World Applications and Challenges

Quantum entanglement protocols are not just theoretical; they are being used in real-world quantum networks. For example, the Chinese Micius satellite demonstrated quantum teleportation over 1,200 km. Superdense coding has been implemented in fiber-optic networks. However, challenges remain:

• Distance: Entanglement distribution over long distances suffers from loss and decoherence. Quantum repeaters are being developed to overcome this.
• Fidelity: Gate errors and noise limit the fidelity of teleportation and superdense coding. Error correction codes are needed.
• Scalability: Current experiments use few qubits. Scaling to many qubits is a major engineering challenge.

Despite these challenges, entanglement-based protocols are a key part of the quantum internet vision. As a developer, understanding these protocols gives you a foundation for building quantum applications.