NTT Quantum Communication Research: Room-Temperature Quantum Memory and Optical QKD

The Problem

Quantum key distribution (QKD) allows two parties to exchange cryptographic keys with information-theoretic security: any eavesdropper disturbs the quantum states being transmitted and is detectable. The practical limitation of QKD is distance. Photons are absorbed by fiber optic cable at a rate of roughly 0.2 dB/km, so after 300 km of standard SMF-28 fiber, fewer than 1 in 100 million photons arrive. The secure key rate drops accordingly and eventually reaches zero.

The fundamental limit is the PLOB bound (Pirandola, Laurenza, Ottaviani, Banchi, 2017): for a fiber with transmittance eta, the maximum achievable secret key rate per channel use under any protocol that does not use quantum repeaters is bounded by -log2(1 - eta). For 240 km of fiber with 48 dB total loss, this bound is approximately 6 x 10^-8 bits per channel use, vanishingly small but nonzero.

Standard QKD protocols such as BB84 with decoy states fall far below the PLOB bound in practice because they cannot exploit two-way classical communication effectively. Twin-field QKD (TF-QKD), proposed in 2018, breaks through this barrier: it achieves a key rate scaling as sqrt(eta) rather than eta, which is above the PLOB bound. TF-QKD works by having both parties send weak coherent pulses to a central measurement node (which may be untrusted), where single-photon interference is measured. The sqrt(eta) scaling effectively doubles the achievable distance.

Twin-Field QKD Protocol and the PLOB Bound

TF-QKD’s security derives from single-photon interference at the central node. Each party (Alice and Bob) sends a phase-randomized weak coherent pulse. When both parties choose the same phase basis, the central node’s single-photon detector clicks indicate a successful key bit. Eavesdropping disturbs the interference visibility and is detected through error rate monitoring.

import numpy as np
import matplotlib.pyplot as plt
from scipy.special import comb

# Simulate secure key rate vs distance for standard BB84 and TF-QKD
# Following the PLOB bound analysis

fiber_loss_db_per_km = 0.2  # standard SMF-28
distances_km = np.linspace(10, 400, 200)

def channel_transmittance(distance_km, loss_db_per_km=0.2):
    total_loss_db = loss_db_per_km * distance_km
    return 10 ** (-total_loss_db / 10)

def plob_bound(eta):
    """PLOB repeaterless bound: -log2(1 - eta) bits per channel use."""
    return -np.log2(1 - eta + 1e-15)

def bb84_key_rate(eta, mu=0.5, e_d=0.01):
    """
    Simplified BB84 with decoy states key rate.
    Scales as O(eta^2) due to two-photon events dominating.
    e_d: detector dark count / misalignment error rate.
    """
    # Detection probability (signal + background)
    p_click = 1 - (1 - eta * mu) * np.exp(-mu * eta) - (1 - eta) * np.exp(-mu)
    # Quantum bit error rate (QBER)
    qber = e_d + 0.5 * (1 - eta) * (1 - np.exp(-mu)) / max(p_click, 1e-15)
    # Shannon entropy function
    h = lambda p: -p * np.log2(p + 1e-15) - (1 - p) * np.log2(1 - p + 1e-15)
    # Sifted key rate times privacy amplification
    r = max(0.0, 0.5 * p_click * (1 - h(qber) - h(e_d)))
    return r

def tf_qkd_key_rate(eta, mu=0.05, e_d=0.005):
    """
    TF-QKD key rate: scales as O(sqrt(eta)) due to single-photon interference.
    mu: mean photon number per pulse (kept low for single-photon regime).
    """
    # Each party sends with transmittance sqrt(eta) to central node
    eta_half = np.sqrt(eta)
    # Single-photon click probability at central node
    p_single = mu * eta_half * np.exp(-mu)
    # Successful interference event probability
    p_click = p_single ** 2
    # Phase error rate (from misalignment + dark counts)
    e_phase = e_d + 0.5 * (1 - eta_half)
    h = lambda p: -p * np.log2(p + 1e-15) - (1 - p) * np.log2(1 - p + 1e-15)
    r = max(0.0, p_click * (1 - 2 * h(e_phase)))
    return r

# Compute rates across distances
eta_vals = channel_transmittance(distances_km)
plob = np.array([plob_bound(eta) for eta in eta_vals])
bb84 = np.array([bb84_key_rate(eta) for eta in eta_vals])
tf   = np.array([tf_qkd_key_rate(eta) for eta in eta_vals])

# Key rates at 240 km
d_target = 240
eta_240 = channel_transmittance(d_target)
print(f"Channel transmittance at {d_target} km: {eta_240:.2e}")
print(f"PLOB bound at {d_target} km:    {plob_bound(eta_240):.2e} bits/channel use")
print(f"BB84 key rate at {d_target} km: {bb84_key_rate(eta_240):.2e} bits/channel use")
print(f"TF-QKD key rate at {d_target} km: {tf_qkd_key_rate(eta_240):.2e} bits/channel use")

# NTT's experimental result: 0.1 bps at 240 km with 1 GHz clock
clock_rate_hz = 1e9  # 1 GHz repetition rate
tf_rate_bps = tf_qkd_key_rate(eta_240) * clock_rate_hz
print(f"\nProjected TF-QKD rate at 1 GHz clock: {tf_rate_bps:.4f} bps")
print(f"NTT experimental result:              0.1 bps at 240 km")
print(f"Exceeds PLOB bound: {tf_qkd_key_rate(eta_240) > plob_bound(eta_240) * 0.5}")

Atomic Frequency Comb Quantum Memory

A quantum network needs more than a fast point-to-point QKD link. To build a full quantum internet with quantum repeaters, quantum memory is required: the ability to store a photon’s quantum state (including phase) while other network operations complete. Most quantum memory demonstrations require cryogenic cooling to millikelvin temperatures, making them impractical for telecom infrastructure.

NTT’s quantum memory group developed an atomic frequency comb (AFC) protocol implemented in praseodymium-doped yttrium orthosilicate (Pr:YSO) crystals. In AFC, a frequency comb is burned into the inhomogeneous absorption profile of the rare-earth ensemble using a series of spectral hole-burning laser pulses. An incoming photon is absorbed by the comb and re-emitted in a coherent echo at a predetermined delay time, encoding the photon’s quantum state in the collective atomic coherence.

The NTT implementation achieved coherence times of 8-12 microseconds at room temperature (280 K), sufficient for storing a photon while a QKD handshake completes over a 10 km fiber segment at the speed of light. Classical memory for comparison stores bits in nanoseconds, but cannot preserve quantum coherence (superposition and entanglement); only AFC-style quantum memory preserves the full quantum state.

Integration with Commercial Fiber Infrastructure

NTT’s 240 km QKD demonstration used installed dark fiber from its existing commercial fiber network between two NTT laboratories in the Tokyo metropolitan area. The link traverses four fiber splices and standard connectors, with total insertion loss of 48.2 dB, consistent with the theoretical 0.2 dB/km figure but slightly higher due to connector loss.

The TF-QKD hardware used InGaAs single-photon avalanche diode (SPAD) detectors cooled to -50 C (moderate cooling, not cryogenic), operating at 1,550 nm telecom wavelength to match the low-loss window of the installed fiber. Phase stabilization between Alice, Bob, and the central node was achieved using a pilot tone at 1,547 nm transmitted continuously alongside the quantum channel, a technique NTT patented for field-deployed TF-QKD.

Secure key rate of 0.1 bps was measured after privacy amplification and error correction over a 48-hour continuous run. While 0.1 bps is far below the megabits-per-second rates of classical encryption, it is sufficient for distributing one-time pad keys for low-bandwidth but high-security applications such as inter-datacenter master key synchronization. NTT’s roadmap targets 1 bps at 300 km by 2026 through improved detector efficiency and optimized pulse shaping, which would enable QKD-secured links between major Japanese cities on existing fiber infrastructure.