Quantum Networking: Entanglement Swapping and Quantum Repeaters

The Distance Problem in Quantum Communication

Quantum key distribution (QKD) is theoretically unbreakable. But there is a catch: photons get absorbed. In standard single-mode optical fiber, roughly half the photons are lost for every 15 km of cable. Transmit over 150 km and you lose more than 99.9% of your signal. Classical networks solve this with amplifiers: devices that read a signal and retransmit it louder. Quantum mechanics forbids this. The no-cloning theorem means you cannot copy an unknown quantum state, so classical amplification is off the table.

The solution is the quantum repeater, and the mechanism that makes repeaters possible is entanglement swapping.

Entanglement Swapping: Extending Correlations Without Transmission

Consider three parties: Alice, Bob, and Charlie. Alice and Bob share an entangled Bell pair. Bob and Charlie independently share a second Bell pair. Neither pair has any direct quantum connection to the other.

Now Bob performs a Bell state measurement (BSM) on his two qubits, one from each pair. This joint measurement entangles Alice’s qubit with Charlie’s qubit, even though they never interacted. The entanglement has been “swapped” through Bob.

The four Bell states are:

|Phi+> = (|00> + |11>) / sqrt(2)
|Phi-> = (|00> - |11>) / sqrt(2)
|Psi+> = (|01> + |10>) / sqrt(2)
|Psi-> = (|01> - |10>) / sqrt(2)

When Bob measures and obtains one of these four outcomes, Alice and Charlie’s qubits collapse into one of four corresponding entangled states. Bob classically communicates his result to Alice or Charlie, who applies a Pauli correction if needed. The resulting state is a maximally entangled pair between Alice and Charlie.

This is remarkable: Bob never touches Alice’s or Charlie’s final qubits. He only measures his own two qubits. The entanglement propagates via classical communication of the BSM result.

Quantum Repeaters: The Architecture

A quantum repeater network divides a long link into shorter segments. Each adjacent pair of nodes shares entanglement independently. A chain of entanglement swapping operations then stitches these local links into end-to-end entanglement.

The three core requirements for a quantum repeater are:

Quantum memory. Each node must hold a qubit long enough to wait for neighboring nodes to establish their entanglement. Current memory coherence times range from microseconds (superconducting circuits) to seconds (trapped ions and NV centers in diamond). The longer the link segment, the longer the memory must hold.

Heralded entanglement generation. Nodes generate entangled photon pairs and send one photon toward a neighboring node. A measurement at the midpoint confirms whether the entanglement succeeded. This herald signal travels back classically. Only successful attempts are retained.

Entanglement purification. Noise degrades entanglement with each swap. Purification protocols take two noisy copies of a Bell pair and distill one higher-fidelity pair, at the cost of consuming the extra copy.

Fiber vs Satellite: Two Regimes of Loss

Loss in fiber follows an exponential law. For standard telecom fiber at 1550 nm wavelength, the attenuation is roughly 0.2 dB per km. The probability of a photon surviving a distance L km is:

P_survive = 10^(-alpha * L / 10)

where alpha = 0.2 dB/km. At 100 km this gives P_survive of about 1 in 100,000.

Free-space links between satellites follow a different loss profile. Beam diffraction causes loss that grows as the square of the distance rather than exponentially. For a 1000 km satellite-to-ground link, the total loss can be 40 to 50 dB, comparable to a few hundred km of fiber, but crucially, satellite links can cover intercontinental distances that fiber repeater chains would take decades to build.

China’s Micius satellite demonstrated satellite-based entanglement distribution between ground stations 1200 km apart in 2017. It remains the longest entanglement distribution link ever demonstrated.

Current Repeater Projects

QuEra / MIT. QuEra’s neutral atom platform uses rubidium arrays with long coherence times. MIT researchers are exploring atom-photon entanglement links between adjacent nodes as a path toward a metropolitan-scale repeater network.

Delft / QuTech. The QuTech group in Delft pioneered repeater demonstrations using nitrogen-vacancy (NV) centers in diamond. In 2021 they demonstrated entanglement between three nodes: Delft, Leiden, and The Hague, over a 35 km fiber loop, achieving the first multi-node quantum network with memory.

UK Quantum Network. The National Quantum Computing Centre and BT are building testbed links between Cambridge and London using existing dark fiber, targeting metropolitan QKD with repeater nodes.

US DOE Quantum Internet Blueprint. The US Department of Energy identified repeater technology as the central challenge for a nationwide quantum internet. Argonne, Brookhaven, and Fermilab are building testbed links and exploring different qubit memory platforms.

Python Simulation: Fidelity Degradation with Distance

The following simulation shows how entanglement fidelity degrades along a fiber link as a function of distance, and demonstrates the improvement that a single intermediate repeater node provides.

import numpy as np
import matplotlib.pyplot as plt

# Physical parameters
ALPHA_DB_PER_KM = 0.2          # fiber attenuation (telecom C-band)
DETECTOR_EFFICIENCY = 0.9      # photon detector efficiency
SOURCE_FIDELITY = 0.99         # fidelity of entangled photon source
MEMORY_DECOHERENCE_RATE = 0.01 # fidelity loss per memory storage cycle
SWAP_FIDELITY = 0.97           # BSM gate fidelity

def db_to_linear(db):
    return 10 ** (-db / 10)

def fiber_transmission(distance_km):
    """Probability that a photon survives distance_km of fiber."""
    loss_db = ALPHA_DB_PER_KM * distance_km
    return db_to_linear(loss_db) * DETECTOR_EFFICIENCY

def direct_link_fidelity(distance_km, n_trials=10000):
    """
    Simulate direct entanglement distribution over fiber.
    Returns (success_rate, average_fidelity).
    """
    p_success = fiber_transmission(distance_km) ** 2  # both photons must arrive
    successes = np.random.binomial(1, min(p_success, 1.0), n_trials)
    
    # Fidelity degrades from noise accumulated during transmission wait
    # Model: each failed attempt adds decoherence before we retry
    expected_attempts = 1.0 / max(p_success, 1e-12)
    fidelity = SOURCE_FIDELITY * (1 - MEMORY_DECOHERENCE_RATE) ** min(expected_attempts, 1000)
    
    return p_success, max(fidelity, 0.25)  # 0.25 is fully mixed state bound

def repeater_link_fidelity(total_distance_km, n_segments=1):
    """
    Simulate entanglement distribution with n_segments intermediate repeater nodes.
    Each segment is total_distance / (n_segments + 1) km long.
    """
    segment_length = total_distance_km / (n_segments + 1)
    
    # Each segment establishes entanglement independently
    p_segment = fiber_transmission(segment_length) ** 2
    
    # Expected attempts per segment
    expected_attempts_per_segment = 1.0 / max(p_segment, 1e-12)
    
    # Fidelity per segment
    fidelity_per_segment = SOURCE_FIDELITY * (1 - MEMORY_DECOHERENCE_RATE) ** min(
        expected_attempts_per_segment, 500
    )
    
    # Each swap (BSM) degrades fidelity
    # With n_segments repeaters, we need n_segments swaps
    combined_fidelity = fidelity_per_segment ** (n_segments + 1) * SWAP_FIDELITY ** n_segments
    
    # Total success rate: all segments must succeed (simplified model)
    # In practice, segments run in parallel with memory buffering
    p_total = p_segment  # bottleneck is the slowest segment (similar lengths here)
    
    return p_total, max(combined_fidelity, 0.25)

# Compute fidelity vs distance
distances = np.linspace(10, 500, 100)

direct_fidelities = []
repeater1_fidelities = []
repeater3_fidelities = []

for d in distances:
    _, f0 = direct_link_fidelity(d)
    _, f1 = repeater_link_fidelity(d, n_segments=1)
    _, f3 = repeater_link_fidelity(d, n_segments=3)
    direct_fidelities.append(f0)
    repeater1_fidelities.append(f1)
    repeater3_fidelities.append(f3)

# Plot results
plt.figure(figsize=(10, 6))
plt.plot(distances, direct_fidelities, 'r-', linewidth=2, label='Direct link (no repeaters)')
plt.plot(distances, repeater1_fidelities, 'b--', linewidth=2, label='1 repeater node (2 segments)')
plt.plot(distances, repeater3_fidelities, 'g:', linewidth=2, label='3 repeater nodes (4 segments)')
plt.axhline(y=0.5, color='gray', linestyle='-.', alpha=0.7, label='Entanglement threshold (F=0.5)')
plt.xlabel('Total Distance (km)')
plt.ylabel('Entanglement Fidelity')
plt.title('Fidelity Degradation vs Distance: Direct Link vs Quantum Repeaters')
plt.legend()
plt.grid(True, alpha=0.3)
plt.ylim(0.2, 1.0)
plt.tight_layout()
plt.savefig('repeater_fidelity.png', dpi=150)
plt.show()

# Print summary table
print(f"{'Distance (km)':<18} {'Direct F':<14} {'1-Repeater F':<16} {'3-Repeater F':<14}")
print("-" * 62)
for d in [50, 100, 200, 300, 500]:
    _, f0 = direct_link_fidelity(d)
    _, f1 = repeater_link_fidelity(d, n_segments=1)
    _, f3 = repeater_link_fidelity(d, n_segments=3)
    print(f"{d:<18} {f0:<14.4f} {f1:<16.4f} {f3:<14.4f}")

Running this code reveals a critical insight: without repeaters, fidelity collapses below the entanglement threshold (F = 0.5) around 200 to 300 km in fiber due to accumulated memory decoherence while waiting for photons to arrive. A single intermediate node cuts the per-segment distance in half, dramatically reducing the expected wait time and preserving fidelity. Three nodes push usable fidelity out to 400 km and beyond.

Qubit Memory Requirements and Timing

The timing bottleneck is often underappreciated. Light travels through fiber at roughly 200,000 km/s (slower than vacuum due to the refractive index). A 100 km link has a one-way propagation time of 0.5 ms. If the photon is lost (which happens most of the time), the node must wait for the herald signal before retrying.

For a segment with success probability p, the expected number of attempts before success is 1/p. With p = 0.001 (realistic for 100 km of fiber), the expected number of attempts is 1000. Each round trip takes 1 ms. So the memory must hold a qubit for up to a second while waiting for all segments to succeed simultaneously.

This is why quantum memory coherence time is the key hardware specification for repeater nodes. Trapped ion systems achieve coherence times of minutes to hours but are slow and bulky. NV centers in diamond have coherence times of milliseconds to seconds at room temperature and can be networked via optical fiber. Rare-earth doped crystals (europium, praseodymium) have shown storage times of hours, making them attractive for long-distance links.

The Path to a Quantum Internet

A full quantum internet requires solving three layered problems: physical layer (low-loss photon transmission and detection), link layer (heralded entanglement generation with memory), and network layer (routing and entanglement swapping across arbitrary topologies).

The quantum internet is not a replacement for classical networks. It is a complementary layer that enables capabilities that are classically impossible: unconditionally secure key distribution, distributed quantum computing across separated processors, and clock synchronization at the Heisenberg limit. Each of these applications has different fidelity and rate requirements that drive different engineering tradeoffs.

The field is moving fast. What took a decade of laboratory work to demonstrate in 2021 (the Delft three-node network) will likely become a commercial product by the early 2030s for metropolitan-scale QKD. Intercontinental quantum networking via satellite is closer to 2040, pending advances in quantum memory and satellite optical terminals.

Entanglement swapping is the key primitive that makes all of this possible. Understanding the protocol and its engineering constraints is essential for anyone designing or evaluating quantum network architectures.