Why do I see a key error rate in BB84 greater than 0% if I set Pol. Fidelity to one?

[luckyluke98]

Hi everyone, I'm doing some tests to run the BB84 protocol, the example found in the "examples" folder and called distance_bb84.py.

I set the Polarization fidelity of the qchannel to 1, so I shouldn't have polarization errors, but when I run the simulation I finally get that in the keys exchanged there is an average error rate of around 49%. Could anyone explain to me why?

I attach the code. As you can se I do only one experimet with distance 1000 meters.

import math

import pandas as pd
from numpy import mean
from sequence.components.optical_channel import QuantumChannel, ClassicalChannel
from sequence.kernel.event import Event
from sequence.kernel.process import Process
from sequence.kernel.timeline import Timeline
from sequence.qkd.BB84 import pair_bb84_protocols
from sequence.topology.node import QKDNode

if __name__ == "__main__":
    NUM_EXPERIMENTS = 1
    runtime = 1e12

    # open file to store experiment results
    # Path("results/sensitivity").mkdir(parents=True, exist_ok=True)
    # filename = "results/sensitivity/distance_bb84.log"
    # fh = open(filename,'w')

    dist_list = []
    tp_list = []
    error_rate_list = []
    latency_list = []

    for i in range(NUM_EXPERIMENTS):
        distance = max(1000, 10000 * int(i))

        tl = Timeline(runtime)
        tl.show_progress = True

        qc0 = QuantumChannel("qc0", tl, distance=distance, polarization_fidelity=1, attenuation=0)
        qc1 = QuantumChannel("qc1", tl, distance=distance, polarization_fidelity=1, attenuation=0)
        cc0 = ClassicalChannel("cc0", tl, distance=distance)
        cc1 = ClassicalChannel("cc1", tl, distance=distance)

        # Alice
        ls_params = {"frequency": 80e6, "mean_photon_num": 1}
        alice = QKDNode("alice", tl, stack_size=1)
        alice.set_seed(0)

        for name, param in ls_params.items():
            alice.update_lightsource_params(name, param)

        # Bob
        detector_params = [{"efficiency": 1, "dark_count": 0, "time_resolution": 1, "count_rate": 1e12},
                           {"efficiency": 1, "dark_count": 0, "time_resolution": 1, "count_rate": 1e12}]
        bob = QKDNode("bob", tl, stack_size=1)
        bob.set_seed(1)
        
        for i in range(len(detector_params)):
            for name, param in detector_params[i].items():
                bob.update_detector_params(i, name, param)

        qc0.set_ends(alice, bob.name)
        qc1.set_ends(bob, alice.name)
        cc0.set_ends(alice, bob.name)
        cc1.set_ends(bob, alice.name)

        # BB84 config
        pair_bb84_protocols(alice.protocol_stack[0], bob.protocol_stack[0])

        process = Process(alice.protocol_stack[0], "push", [128, math.inf, 1e12])
        event = Event(0, process)
        tl.schedule(event)

        tl.init()
        tl.run()

        print("completed distance {}".format(distance))

        # record metrics
        bba = alice.protocol_stack[0]

        dist_list.append(distance)
        tp_list.append(mean(bba.throughputs))
        error_rate_list.append(mean(bba.error_rates))
        latency_list.append(bba.latency)

    log = {'Distance': dist_list, "Throughput": tp_list, 'Error_rate': error_rate_list, 'Latency': latency_list}
    df = pd.DataFrame(log)
    df.to_csv('distance_bb84.csv')

By doing a bit of debugging I notice that the first keys have 0% errors, then at a certain point the keys start to accumulate errors.