QKD key-rate

This page contains advanced examples for the tno.quantum.communication.qkd_key_rate package. Examples of basic usage can be found in the module documentation.

The package provides python code to compute optimal protocol parameters for different quantum key distribution (QKD) protocols.

Requirements

Install the following dependencies to run the examples below:

pip install tno.quantum.communication.qkd_key_rate~=2.0
pip install matplotlib
pip install tqdm

Examples

Example 1: Compute secure key-rate for various BB84 protocols as function of the loss.

"""Example that shows how to plot optimal key-rate versus attenuation"""

import matplotlib.pyplot as plt
import numpy as np

from tno.quantum.communication.qkd_key_rate.quantum.bb84 import (
    BB84AsymptoticKeyRateEstimate,
    BB84FiniteKeyRateEstimate,
    BB84FullyAsymptoticKeyRateEstimate,
)
from tno.quantum.communication.qkd_key_rate.quantum.bb84_single_photon import (
    BB84SingleAsymptoticKeyRateEstimate,
)
from tno.quantum.communication.qkd_key_rate.quantum import standard_detector
from tno.quantum.communication.qkd_key_rate.quantum import KeyRate
from tqdm import tqdm

# Create a custom detector
detector = standard_detector.customise(
    dark_count_rate=6e-7,
    polarization_drift=0.0707,
    error_detector=5e-3,
    efficiency_detector=0.1,
)

distance = np.arange(0, 40)
attenuation_factor = 1
attenuation = attenuation_factor * distance
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))

protocols: dict[str, KeyRate] = {
    "Fully Asymptotic BB84": BB84FullyAsymptoticKeyRateEstimate(
        detector=detector,
    ),
    "Asymptotic BB84": BB84AsymptoticKeyRateEstimate(
        detector=detector, number_of_decoy=2
    ),
    "Single photon Asymptotic BB84": BB84SingleAsymptoticKeyRateEstimate(
        detector=detector,
    ),
    "Finite BB84": BB84FiniteKeyRateEstimate(detector=detector, number_of_pulses=1e12),
}

for label, protocol in protocols.items():
    key_rate, intensity = [], []
    for att in tqdm(attenuation, desc=f"Processing {label}"):
        x, rate = protocol.optimize_rate(attenuation=att)
        key_rate.append(rate)
        intensity.append(x["mu"][0])

    ax1.semilogy(attenuation, key_rate, label=label)
    ax2.semilogy(attenuation, intensity, label=label)

# Labels/axis
ax1.set_xlabel("Loss (dB)", fontsize=14)
ax1.set_ylabel("Key-rate", fontsize=14)
ax1.set_title("Secure key-rate", fontsize=16)
ax1.legend()

ax2.set_xlabel("Loss (dB)", fontsize=14)
ax2.set_ylabel("Laser intensity", fontsize=14)
ax2.set_title("Intensity settings", fontsize=16)
ax2.legend()

fig.suptitle("BB84 Protocol", fontsize=16)
plt.show()

Processing Fully Asymptotic BB84: 100%|███████████████████████████████████████████████████████████████████████████████████| 40/40 [00:01<00:00, 30.07it/s]
Processing Asymptotic BB84: 100%|█████████████████████████████████████████████████████████████████████████████████████████| 40/40 [00:23<00:00,  1.72it/s]
Processing Single photon Asymptotic BB84: 100%|███████████████████████████████████████████████████████████████████████████| 40/40 [00:00<00:00, 42.25it/s]
Processing Finite BB84: 100%|█████████████████████████████████████████████████████████████████████████████████████████████| 40/40 [12:27<00:00, 18.68s/it]

Example 2: Compute secure key-rate as a function of the number of pulses for the BB84 finite key-rate protocol.

"""Example BB84 FiniteKeyRate estimate for various number of pulses."""

import matplotlib.pyplot as plt
import numpy as np

from tno.quantum.communication.qkd_key_rate.quantum.bb84 import (
    BB84FiniteKeyRateEstimate,
)
from tno.quantum.communication.qkd_key_rate.quantum import standard_detector
from tqdm import tqdm

# Create a custom detector
detector = standard_detector.customise(
    dark_count_rate=6e-7,
    polarization_drift=0.0707,
    error_detector=5e-3,
    efficiency_detector=0.1,
)

distance = np.arange(0, 40, 2)
attenuation_factor = 1
attenuation = attenuation_factor * distance
fig, ax = plt.subplots()


power_number_of_pulses = [7, 8, 9, 10]
for power in power_number_of_pulses:
    label = rf"N=$10^{{{power}}}$"
    protocol = BB84FiniteKeyRateEstimate(detector=detector, number_of_pulses=10**power)
    key_rate = []
    for att in tqdm(attenuation, desc=f"Processing N=10^{power}"):
        try:
            _, rate = protocol.optimize_rate(attenuation=att)
            key_rate.append(rate)
        except:
            break

    ax.semilogy(attenuation[:len(key_rate)], key_rate, label=label)

# Labels/axis
ax.set_xlabel("Loss (dB)", fontsize=12)
ax.set_ylabel("Key-rate", fontsize=12)
ax.set_title("Secure key-rate", fontsize=14)
ax.legend()

plt.show()