def test_BB84_time_bin():
tl = Timeline(1e12) # stop time is 1 s
alice = QKDNode("alice", tl, encoding=time_bin, stack_size=1)
bob = QKDNode("bob", tl, encoding=time_bin, stack_size=1)
pair_bb84_protocols(alice.protocol_stack[0], bob.protocol_stack[0])
qc = QuantumChannel("qc", tl, distance=10e3, polarization_fidelity=0.99, attenuation=0.00002)
qc.set_ends(alice, bob)
cc = ClassicalChannel("cc", tl, distance=10e3)
cc.set_ends(alice, bob)
# Parent
pa = Parent(alice, 128, "alice")
pb = Parent(bob, 128, "bob")
alice.protocol_stack[0].upper_protocols.append(pa)
pa.lower_protocols.append(alice.protocol_stack[0])
bob.protocol_stack[0].upper_protocols.append(pb)
pb.lower_protocols.append(bob.protocol_stack[0])
process = Process(pa, "push", [])
event = Event(0, process)
tl.schedule(event)
tl.init()
tl.run()
assert pa.counter == pb.counter == 10
def test_BBPSSW_success_rate():
tl = Timeline()
a1 = FakeNode("a1", tl)
a2 = FakeNode("a2", tl)
cc0 = ClassicalChannel("cc0", tl, 0, 1e5)
cc1 = ClassicalChannel("cc1", tl, 0, 1e5)
cc0.delay = ONE_MILLISECOND
cc1.delay = ONE_MILLISECOND
cc0.set_ends(a1, a2)
cc1.set_ends(a2, a1)
tl.init()
counter1 = counter2 = 0
fidelity = 0.8
for i in range(1000):
kept_memo1 = Memory("a1.kept", tl, fidelity=fidelity, frequency=0, efficiency=1, coherence_time=1,
wavelength=HALF_MICRON)
kept_memo2 = Memory("a2.kept", tl, fidelity, 0, 1, 1, HALF_MICRON)
meas_memo1 = Memory("a1.meas", tl, fidelity, 0, 1, 1, HALF_MICRON)
meas_memo2 = Memory("a2.meas", tl, fidelity, 0, 1, 1, HALF_MICRON)
kept_memo1.entangled_memory["node_id"] = "a2"
kept_memo1.entangled_memory["memo_id"] = "a2.kept"
kept_memo1.fidelity = fidelity
kept_memo2.entangled_memory["node_id"] = "a1"
kept_memo2.entangled_memory["memo_id"] = "a1.kept"
kept_memo2.fidelity = fidelity
meas_memo1.entangled_memory["node_id"] = "a2"
meas_memo1.entangled_memory["memo_id"] = "a2.meas"
meas_memo1.fidelity = fidelity
meas_memo2.entangled_memory["node_id"] = "a1"
meas_memo2.entangled_memory["memo_id"] = "a1.meas"
meas_memo2.fidelity = fidelity
pair1 = np.random.choice(range(4), 1,
p=[fidelity, (1 - fidelity) / 3, (1 - fidelity) / 3, (1 - fidelity) / 3])
pair2 = np.random.choice(range(4), 1,
p=[fidelity, (1 - fidelity) / 3, (1 - fidelity) / 3, (1 - fidelity) / 3])
tl.quantum_manager.set([kept_memo1.qstate_key, kept_memo2.qstate_key], BELL_STATES[pair1[0]])
tl.quantum_manager.set([meas_memo1.qstate_key, meas_memo2.qstate_key], BELL_STATES[pair2[0]])
ep1 = BBPSSW(a1, "a1.ep1.%d" % i, kept_memo1, meas_memo1)
ep2 = BBPSSW(a2, "a2.ep2.%d" % i, kept_memo2, meas_memo2)
a1.protocols.append(ep1)
a2.protocols.append(ep2)
ep1.set_others(ep2)
ep2.set_others(ep1)
ep1.start()
ep2.start()
if ep1.meas_res == ep2.meas_res:
counter1 += 1
else:
counter2 += 1
tl.run()
assert abs(counter1 / (counter1 + counter2) - BBPSSW.success_probability(fidelity)) < 0.1
def test_BBPSSW2():
tl = Timeline()
a1 = FakeNode("a1", tl)
a2 = FakeNode("a2", tl)
cc = ClassicalChannel("cc", tl, 0, 1e5)
cc.delay = 1e9
cc.set_ends(a1, a2)
tl.init()
counter1 = counter2 = 0
fidelity = 0.8
for i in range(1000):
kept_memo1 = Memory("a1.kept",
tl,
fidelity=fidelity,
frequency=0,
efficiency=1,
coherence_time=1,
wavelength=500)
kept_memo2 = Memory("a2.kept", tl, fidelity, 0, 1, 1, 500)
meas_memo1 = Memory("a1.meas", tl, fidelity, 0, 1, 1, 500)
meas_memo2 = Memory("a2.meas", tl, fidelity, 0, 1, 1, 500)
kept_memo1.entangled_memory["node_id"] = "a2"
kept_memo1.entangled_memory["memo_id"] = "a2.kept"
kept_memo1.fidelity = fidelity
kept_memo2.entangled_memory["node_id"] = "a1"
kept_memo2.entangled_memory["memo_id"] = "a1.kept"
kept_memo2.fidelity = fidelity
meas_memo1.entangled_memory["node_id"] = "a2"
meas_memo1.entangled_memory["memo_id"] = "a2.meas"
meas_memo1.fidelity = fidelity
meas_memo2.entangled_memory["node_id"] = "a1"
meas_memo2.entangled_memory["memo_id"] = "a1.meas"
meas_memo2.fidelity = fidelity
ep1 = BBPSSW(a1, "a1.ep1.%d" % i, kept_memo1, meas_memo1)
ep2 = BBPSSW(a2, "a2.ep2.%d" % i, kept_memo2, meas_memo2)
a1.protocols.append(ep1)
a2.protocols.append(ep2)
ep1.set_others(ep2)
ep2.set_others(ep1)
ep1.start()
ep2.start()
assert ep1.is_success == ep2.is_success
if ep1.is_success:
counter1 += 1
else:
counter2 += 1
tl.run()
assert abs(counter1 / (counter1 + counter2) -
BBPSSW.success_probability(fidelity)) < 0.1
def create_scenario(state1, state2, seed):
tl = Timeline()
tl.seed(seed)
a1 = FakeNode("a1", tl)
a2 = FakeNode("a2", tl)
a3 = FakeNode("a3", tl)
cc0 = ClassicalChannel("a2-a1", tl, 0, 1e5)
cc1 = ClassicalChannel("a2-a3", tl, 0, 1e5)
cc0.set_ends(a2, a1)
cc1.set_ends(a2, a3)
tl.init()
memo1 = Memory("a1.0", timeline=tl, fidelity=0.9, frequency=0, efficiency=1, coherence_time=1, wavelength=500)
memo2 = Memory("a2.0", tl, 0.9, 0, 1, 1, 500)
memo3 = Memory("a2.1", tl, 0.9, 0, 1, 1, 500)
memo4 = Memory("a3.0", tl, 0.9, 0, 1, 1, 500)
memo1.fidelity = memo2.fidelity = memo3.fidelity = memo4.fidelity = 1
memo1.entangled_memory = {'node_id': 'a2', 'memo_id': memo2.name}
memo2.entangled_memory = {'node_id': 'a1', 'memo_id': memo1.name}
memo3.entangled_memory = {'node_id': 'a3', 'memo_id': memo4.name}
memo4.entangled_memory = {'node_id': 'a2', 'memo_id': memo3.name}
tl.quantum_manager.set([memo1.qstate_key, memo2.qstate_key], state1)
tl.quantum_manager.set([memo3.qstate_key, memo4.qstate_key], state2)
es1 = EntanglementSwappingB(a1, "a1.ESb0", memo1)
a1.protocols.append(es1)
es2 = EntanglementSwappingA(a2, "a2.ESa0", memo2, memo3)
a2.protocols.append(es2)
es3 = EntanglementSwappingB(a3, "a3.ESb1", memo4)
a3.protocols.append(es3)
es1.set_others(es2)
es3.set_others(es2)
es2.set_others(es1)
es2.set_others(es3)
es2.start()
tl.run()
ket1, ket2, ket3, ket4 = map(tl.quantum_manager.get,
[memo1.qstate_key, memo2.qstate_key, memo3.qstate_key, memo4.qstate_key])
assert id(ket1) == id(ket4)
assert id(ket2) != id(ket3)
assert len(ket1.keys) == 2 and memo1.qstate_key in ket1.keys and memo4.qstate_key in ket1.keys
assert len(ket2.keys) == 1
assert memo2.entangled_memory == memo3.entangled_memory == {'node_id': None, 'memo_id': None}
assert memo1.entangled_memory["node_id"] == "a3" and memo4.entangled_memory["node_id"] == "a1"
assert a1.resource_manager.log[-1] == (memo1, "ENTANGLED")
assert a3.resource_manager.log[-1] == (memo4, "ENTANGLED")
return ket1, ket2, ket3, ket4, a3
def test_cascade_run():
KEYSIZE = 512
KEYNUM = 10
tl = Timeline(1e11)
alice = QKDNode("alice", tl)
bob = QKDNode("bob", tl)
pair_bb84_protocols(alice.protocol_stack[0], bob.protocol_stack[0])
pair_cascade_protocols(alice.protocol_stack[1], bob.protocol_stack[1])
qc0 = QuantumChannel("qc0",
tl,
distance=1e3,
attenuation=2e-5,
polarization_fidelity=0.97)
qc1 = QuantumChannel("qc1",
tl,
distance=1e3,
attenuation=2e-5,
polarization_fidelity=0.97)
qc0.set_ends(alice, bob)
qc1.set_ends(bob, alice)
cc0 = ClassicalChannel("cc0", tl, distance=1e3)
cc1 = ClassicalChannel("cc1", tl, distance=1e3)
cc0.set_ends(alice, bob)
cc1.set_ends(bob, alice)
# Parent
pa = Parent(alice, KEYSIZE, KEYNUM)
pb = Parent(bob, KEYSIZE, KEYNUM)
alice.protocol_stack[1].upper_protocols.append(pa)
pa.lower_protocols.append(alice.protocol_stack[1])
bob.protocol_stack[1].upper_protocols.append(pb)
pb.lower_protocols.append(bob.protocol_stack[1])
process = Process(pa, "push", [])
event = Event(0, process)
tl.schedule(event)
tl.init()
tl.run()
assert pa.counter == pb.counter == KEYNUM
for k1, k2 in zip(pa.keys, pb.keys):
assert k1 == k2
assert k1 < 2**KEYSIZE # check that key is not too large
assert alice.protocol_stack[1].error_bit_rate == 0
def test_Node_send_message():
class FakeNode(Node):
def __init__(self, name, tl):
Node.__init__(self, name, tl)
self.log = []
def receive_message(self, src, msg):
self.log.append((self.timeline.now(), src, msg))
tl = Timeline()
node1 = FakeNode("node1", tl)
node2 = FakeNode("node2", tl)
cc0 = ClassicalChannel("cc0", tl, 1e3)
cc1 = ClassicalChannel("cc1", tl, 1e3)
cc0.set_ends(node1, node2)
cc1.set_ends(node2, node1)
for i in range(10):
node1.send_message("node2", str(i))
tl.time += 1
for i in range(10):
node2.send_message("node1", str(i))
tl.time += 1
assert len(node1.log) == len(node2.log) == 0
tl.init()
tl.run()
expect_res = [(5000010, 'node2', '0'), (5000011, 'node2', '1'),
(5000012, 'node2', '2'), (5000013, 'node2', '3'),
(5000014, 'node2', '4'), (5000015, 'node2', '5'),
(5000016, 'node2', '6'), (5000017, 'node2', '7'),
(5000018, 'node2', '8'), (5000019, 'node2', '9')]
for actual, expect in zip(node1.log, expect_res):
assert actual == expect
expect_res = [(5000000, 'node1', '0'), (5000001, 'node1', '1'),
(5000002, 'node1', '2'), (5000003, 'node1', '3'),
(5000004, 'node1', '4'), (5000005, 'node1', '5'),
(5000006, 'node1', '6'), (5000007, 'node1', '7'),
(5000008, 'node1', '8'), (5000009, 'node1', '9')]
for actual, expect in zip(node2.log, expect_res):
assert actual == expect
def create_scenario(state1, state2, seed):
tl = Timeline()
tl.seed(seed)
a1 = FakeNode("a1", tl)
a2 = FakeNode("a2", tl)
cc0 = ClassicalChannel("cc0", tl, 0, 1e5)
cc1 = ClassicalChannel("cc1", tl, 0, 1e5)
cc0.delay = ONE_MILLISECOND
cc1.delay = ONE_MILLISECOND
cc0.set_ends(a1, a2)
cc1.set_ends(a2, a1)
kept1 = Memory('kept1', tl, fidelity=1, frequency=0, efficiency=1, coherence_time=1, wavelength=HALF_MICRON)
kept2 = Memory('kept2', tl, fidelity=1, frequency=0, efficiency=1, coherence_time=1, wavelength=HALF_MICRON)
meas1 = Memory('mea1', tl, fidelity=1, frequency=0, efficiency=1, coherence_time=1, wavelength=HALF_MICRON)
meas2 = Memory('mea2', tl, fidelity=1, frequency=0, efficiency=1, coherence_time=1, wavelength=HALF_MICRON)
tl.init()
tl.quantum_manager.set([kept1.qstate_key, kept2.qstate_key], state1)
tl.quantum_manager.set([meas1.qstate_key, meas2.qstate_key], state2)
kept1.entangled_memory = {'node_id': 'a2', 'memo_id': 'kept2'}
kept2.entangled_memory = {'node_id': 'a1', 'memo_id': 'kept1'}
meas1.entangled_memory = {'node_id': 'a2', 'memo_id': 'meas2'}
meas2.entangled_memory = {'node_id': 'a1', 'memo_id': 'meas1'}
kept1.fidelity = kept2.fidelity = meas1.fidelity = meas2.fidelity = 1
ep1 = BBPSSW(a1, "a1.ep1", kept1, meas1)
ep2 = BBPSSW(a2, "a2.ep2", kept2, meas2)
a1.protocols.append(ep1)
a2.protocols.append(ep2)
ep1.set_others(ep2)
ep2.set_others(ep1)
ep1.start()
ep2.start()
tl.run()
assert meas1.entangled_memory == meas2.entangled_memory == {'node_id': None, 'memo_id': None}
return tl, kept1, kept2, meas1, meas2, ep1, ep2
for name, param in ls_params.items():
alice.update_lightsource_params(name, param)
# Bob
detector_params = [{"efficiency": 0.072, "dark_count": dark_count, "time_resolution": 10},
{"efficiency": 0.072, "dark_count": dark_count, "time_resolution": 10},
{"efficiency": 0.072, "dark_count": dark_count, "time_resolution": 10}]
bob = QKDNode("bob", tl, encoding=time_bin)
for i in range(len(detector_params)):
for name, param in detector_params[i].items():
bob.update_detector_params(i, name, param)
qc.set_ends(alice, bob)
cc.set_ends(alice, bob)
# BB84 and cascade config
pair_bb84_protocols(alice.protocol_stack[0], bob.protocol_stack[0])
pair_cascade_protocols(alice.protocol_stack[1], bob.protocol_stack[1])
# Parent
pa = Parent(alice, KEYSIZE, KEYNUM)
pb = Parent(bob, KEYSIZE, KEYNUM)
alice.protocol_stack[1].upper_protocols.append(pa)
pa.lower_protocols.append(alice.protocol_stack[1])
bob.protocol_stack[1].upper_protocols.append(pb)
pb.lower_protocols.append(bob.protocol_stack[1])
process = Process(pa, "push", [])
event = Event(0, process)
memo1.fidelity = memo2.fidelity = fidelity
def pair_protocol(p1: EntanglementProtocol, p2: EntanglementProtocol):
p1.set_others(p2)
p2.set_others(p1)
tl = Timeline()
node1 = PurifyNode('node1', tl)
node2 = PurifyNode('node2', tl)
cc = ClassicalChannel('cc', tl, 1000, 1e9)
cc.set_ends(node1, node2)
for i in range(10):
entangle_memory(node1.kept_memo, node2.kept_memo, 0.9)
entangle_memory(node1.meas_memo, node2.meas_memo, 0.9)
node1.create_protocol()
node2.create_protocol()
pair_protocol(node1.protocols[0], node2.protocols[0])
node1.protocols[0].start()
node2.protocols[0].start()
tl.init()
tl.run()
def test_NetworkManager():
tl = Timeline(1e10)
n1 = FakeNode("n1", tl, 50)
n2 = FakeNode("n2", tl, 50)
n3 = FakeNode("n3", tl, 20)
m1 = BSMNode("m1", tl, ["n1", "n2"])
m2 = BSMNode("m2", tl, ["n2", "n3"])
cc = ClassicalChannel("cc_n1_n2", tl, 10, delay=1e5)
cc.set_ends(n1, n2)
cc = ClassicalChannel("cc_n1_m1", tl, 10, delay=1e5)
cc.set_ends(n1, m1)
cc = ClassicalChannel("cc_n2_m1", tl, 10, delay=1e5)
cc.set_ends(n2, m1)
cc = ClassicalChannel("cc_n2_n3", tl, 10, delay=1e5)
cc.set_ends(n2, n3)
cc = ClassicalChannel("cc_n2_m2", tl, 10, delay=1e5)
cc.set_ends(n2, m2)
cc = ClassicalChannel("cc_n3_m2", tl, 10, delay=1e5)
cc.set_ends(n3, m2)
qc = QuantumChannel("qc_n1_m1", tl, 0, 10)
qc.set_ends(n1, m1)
qc = QuantumChannel("qc_n2_m1", tl, 0, 10)
qc.set_ends(n2, m1)
qc = QuantumChannel("qc_n2_m2", tl, 0, 10)
qc.set_ends(n2, m2)
qc = QuantumChannel("qc_n3_m2", tl, 0, 10)
qc.set_ends(n3, m2)
n1.network_manager.protocol_stack[0].add_forwarding_rule("n2", "n2")
n1.network_manager.protocol_stack[0].add_forwarding_rule("n3", "n2")
n2.network_manager.protocol_stack[0].add_forwarding_rule("n1", "n1")
n2.network_manager.protocol_stack[0].add_forwarding_rule("n3", "n3")
n3.network_manager.protocol_stack[0].add_forwarding_rule("n1", "n2")
n3.network_manager.protocol_stack[0].add_forwarding_rule("n2", "n2")
tl.init()
# approved request
n1.network_manager.request("n3", 1e12, 2e12, 20, 0.9)
tl.run()
assert len(n1.send_log) == len(n1.receive_log) == 1
assert n1.send_log[0][0] == "n2" and n1.receive_log[0][0] == "n2"
assert n1.send_log[0][1].payload.payload.msg_type == RSVPMsgType.REQUEST
assert n1.receive_log[0][1].payload.payload.msg_type == RSVPMsgType.APPROVE
assert len(n2.send_log) == len(n2.receive_log) == 2
assert n2.send_log[0][0] == "n3" and n2.receive_log[0][0] == "n1"
assert n2.send_log[1][0] == "n1" and n2.receive_log[1][0] == "n3"
assert len(n3.send_log) == len(n3.receive_log) == 1
assert n3.send_log[0][0] == "n2" and n3.receive_log[0][0] == "n2"
n1.reset()
n2.reset()
n3.reset()
# rejected request
n1.network_manager.request("n3", 3e12, 4e12, 50, 0.9)
tl.run()
assert len(n1.send_log) == len(n1.receive_log) == 1
assert n1.send_log[0][0] == "n2" and n1.receive_log[0][0] == "n2"
assert n1.send_log[0][1].payload.payload.msg_type == RSVPMsgType.REQUEST
assert n1.receive_log[0][1].payload.payload.msg_type == RSVPMsgType.REJECT
assert len(n2.send_log) == len(n2.receive_log) == 1
assert n2.send_log[0][0] == "n1" and n2.receive_log[0][0] == "n1"
n1.reset()
n2.reset()
n3.reset()
n1.network_manager.request("n3", 5e12, 6e12, 25, 0.9)
tl.run()
assert len(n1.send_log) == len(n1.receive_log) == 1
assert n1.send_log[0][0] == "n2" and n1.receive_log[0][0] == "n2"
assert n1.send_log[0][1].payload.payload.msg_type == RSVPMsgType.REQUEST
assert n1.receive_log[0][1].payload.payload.msg_type == RSVPMsgType.REJECT
assert len(n2.send_log) == len(n2.receive_log) == 2
assert n2.send_log[0][0] == "n3" and n2.receive_log[0][0] == "n1"
assert n2.send_log[1][0] == "n1" and n2.receive_log[1][0] == "n3"
assert len(n3.send_log) == len(n3.receive_log) == 1
assert n3.send_log[0][0] == "n2" and n3.receive_log[0][0] == "n2"
def test_ResourceReservationProtocol_set_es_params():
class TestNode(FakeNode):
def __init__(self, name, tl):
super().__init__(name, tl, memo_size=20)
self.counter = 0
def receive_message(self, src: str, msg: "Message") -> None:
for protocol in self.resource_manager.pending_protocols:
if isinstance(protocol, EntanglementSwappingA):
assert protocol.success_prob == 0.8 and protocol.degradation == 0.7
self.counter += 1
super().receive_message(src, msg)
tl = Timeline()
routers = []
mids = []
for i in range(5):
router = TestNode("r%d" % i, tl)
router.rsvp.set_swapping_success_rate(0.8)
router.rsvp.set_swapping_degradation(0.7)
routers.append(router)
for i in range(4):
mid = BSMNode("mid%d" % i, tl, [routers[i].name, routers[i + 1].name])
mids.append(mid)
for i in range(4):
qc = QuantumChannel("qc_l_%d" % i, tl, 0, 100)
qc.set_ends(routers[i], mids[i])
qc = QuantumChannel("qc_r_%d" % i, tl, 0, 100)
qc.set_ends(routers[i + 1], mids[i])
for i, n1 in enumerate(routers + mids):
for j, n2 in enumerate(routers + mids):
if i >= j:
continue
cc = ClassicalChannel("cc_%s_%s" % (n1.name, n2.name),
tl,
10,
delay=100000)
cc.set_ends(n1, n2)
tl.init()
path = [r.name for r in routers]
reservation = Reservation("r0", "r4", 1, 9000000, 10, 0.9)
for node in [routers[0], routers[-1]]:
for i, card in enumerate(node.rsvp.timecards):
if i >= 10:
break
card.add(reservation)
rules = node.rsvp.create_rules(path, reservation)
assert len(rules) == 3
node.rsvp.load_rules(rules, reservation)
for node in routers[1:-1]:
for i, card in enumerate(node.rsvp.timecards):
card.add(reservation)
rules = node.rsvp.create_rules(path, reservation)
assert len(rules) == 6
node.rsvp.load_rules(rules, reservation)
tl.run()
counter = 0
for node in routers:
counter += node.counter
assert counter > 0
def test_ResourceReservationProtocol_create_rules():
tl = Timeline()
routers = []
mids = []
for i in range(5):
router = FakeNode("r%d" % i, tl, memo_size=20)
routers.append(router)
for i in range(4):
mid = BSMNode("mid%d" % i, tl, [routers[i].name, routers[i + 1].name])
mids.append(mid)
for i in range(4):
qc = QuantumChannel("qc_l_%d" % i, tl, 0, 100)
qc.set_ends(routers[i], mids[i])
qc = QuantumChannel("qc_r_%d" % i, tl, 0, 100)
qc.set_ends(routers[i + 1], mids[i])
for i, n1 in enumerate(routers + mids):
for j, n2 in enumerate(routers + mids):
if i >= j:
continue
cc = ClassicalChannel("cc_%s_%s" % (n1.name, n2.name),
tl,
10,
delay=100000)
cc.set_ends(n1, n2)
tl.init()
path = [r.name for r in routers]
reservation = Reservation("r0", "r4", 1, 1000000000, 10, 0.9)
for node in [routers[0], routers[-1]]:
for i, card in enumerate(node.rsvp.timecards):
if i >= 10:
break
card.add(reservation)
rules = node.rsvp.create_rules(path, reservation)
assert len(rules) == 3
node.rsvp.load_rules(rules, reservation)
for node in routers[1:-1]:
for i, card in enumerate(node.rsvp.timecards):
card.add(reservation)
rules = node.rsvp.create_rules(path, reservation)
assert len(rules) == 6
node.rsvp.load_rules(rules, reservation)
tl.run()
for node in routers:
assert len(node.resource_manager.rule_manager) == 0
counter = 0
for memory in routers[0].memory_array:
if memory.entangled_memory[
"node_id"] == "r4" and memory.fidelity >= 0.9:
counter += 1
assert counter >= 0
for info in routers[0].resource_manager.memory_manager:
if info.state == "ENTANGLED" and info.remote_node == "r4" and info.fidelity >= 0.9:
counter -= 1
assert counter == 0
def test_ResourceManager2():
from sequence.kernel.process import Process
from sequence.kernel.event import Event
from sequence.components.optical_channel import ClassicalChannel, QuantumChannel
from sequence.topology.node import BSMNode
from sequence.entanglement_management.generation import EntanglementGenerationA
class TestNode(Node):
def __init__(self, name, tl):
Node.__init__(self, name, tl)
self.memory_array = MemoryArray(name + ".MemoryArray",
tl,
num_memories=50)
self.memory_array.owner = self
self.resource_manager = ResourceManager(self)
def receive_message(self, src: str, msg: "Message") -> None:
if msg.receiver == "resource_manager":
self.resource_manager.received_message(src, msg)
else:
if msg.receiver is None:
matching = [
p for p in self.protocols
if type(p) == msg.protocol_type
]
for p in matching:
p.received_message(src, msg)
else:
for protocol in self.protocols:
if protocol.name == msg.receiver:
protocol.received_message(src, msg)
break
def get_idle_memory(self, info):
pass
def eg_rule_condition(memory_info, manager):
if memory_info.state == "RAW":
return [memory_info]
else:
return []
def eg_rule_action1(memories_info):
def eg_req_func(protocols):
for protocol in protocols:
if isinstance(protocol, EntanglementGenerationA):
return protocol
memories = [info.memory for info in memories_info]
memory = memories[0]
protocol = EntanglementGenerationA(None, "EGA." + memory.name,
"mid_node", "node2", memory)
protocol.primary = True
return [protocol, ["node2"], [eg_req_func]]
def eg_rule_action2(memories_info):
memories = [info.memory for info in memories_info]
memory = memories[0]
protocol = EntanglementGenerationA(None, "EGA." + memory.name,
"mid_node", "node1", memory)
return [protocol, [None], [None]]
tl = Timeline()
node1, node2 = TestNode("node1", tl), TestNode("node2", tl)
mid_node = BSMNode("mid_node", tl, [node1.name, node2.name])
mid_node.bsm.detectors[0].efficiency = 1
mid_node.bsm.detectors[1].efficiency = 1
cc0 = ClassicalChannel("cc_n1_n2", tl, 0, 1e3)
cc1 = ClassicalChannel("cc_n2_n1", tl, 0, 1e3)
cc2 = ClassicalChannel("cc_n1_m", tl, 0, 1e3)
cc3 = ClassicalChannel("cc_m_n1", tl, 0, 1e3)
cc4 = ClassicalChannel("cc_n2_m", tl, 0, 1e3)
cc5 = ClassicalChannel("cc_m_n2", tl, 0, 1e3)
cc0.set_ends(node1, node2)
cc1.set_ends(node2, node1)
cc2.set_ends(node1, mid_node)
cc3.set_ends(mid_node, node1)
cc4.set_ends(node2, mid_node)
cc5.set_ends(mid_node, node2)
qc0 = QuantumChannel("qc_n1_m", tl, 0, 1e3, frequency=8e7)
qc1 = QuantumChannel("qc_n2_m", tl, 0, 1e3, frequency=8e7)
qc0.set_ends(node1, mid_node)
qc1.set_ends(node2, mid_node)
tl.init()
rule1 = Rule(10, eg_rule_action1, eg_rule_condition)
node1.resource_manager.load(rule1)
rule2 = Rule(10, eg_rule_action2, eg_rule_condition)
node2.resource_manager.load(rule2)
process = Process(node1.resource_manager, "expire", [rule1])
event = Event(10, process)
tl.schedule(event)
process = Process(node2.resource_manager, "expire", [rule2])
event = Event(10, process)
tl.schedule(event)
tl.run()
# for info in node1.resource_manager.memory_manager:
# print(info.memory.name, info.state, info.remote_memo)
#
# for info in node2.resource_manager.memory_manager:
# print(info.memory.name, info.state, info.remote_memo)
for info in node1.resource_manager.memory_manager:
assert info.state == "RAW"
for info in node2.resource_manager.memory_manager:
assert info.state == "RAW"
assert len(node1.protocols) == len(node2.protocols) == 0
assert len(node1.resource_manager.pending_protocols) == len(
node2.resource_manager.pending_protocols) == 0
assert len(node1.resource_manager.waiting_protocols) == len(
node2.resource_manager.waiting_protocols) == 0
def test_BBPSSW_fidelity():
tl = Timeline()
a1 = FakeNode("a1", tl)
a2 = FakeNode("a2", tl)
cc0 = ClassicalChannel("cc0", tl, 0, 1e5)
cc1 = ClassicalChannel("cc1", tl, 0, 1e5)
cc0.delay = ONE_MILLISECOND
cc1.delay = ONE_MILLISECOND
cc0.set_ends(a1, a2)
cc1.set_ends(a2, a1)
tl.init()
for i in range(1000):
fidelity = np.random.uniform(0.5, 1)
kept_memo1 = Memory("a1.kept", tl, fidelity=fidelity, frequency=0, efficiency=1, coherence_time=1,
wavelength=HALF_MICRON)
kept_memo2 = Memory("a2.kept", tl, fidelity, 0, 1, 1, HALF_MICRON)
meas_memo1 = Memory("a1.meas", tl, fidelity, 0, 1, 1, HALF_MICRON)
meas_memo2 = Memory("a2.meas", tl, fidelity, 0, 1, 1, HALF_MICRON)
kept_memo1.entangled_memory["node_id"] = "a2"
kept_memo1.entangled_memory["memo_id"] = "a2.kept"
kept_memo1.fidelity = fidelity
kept_memo2.entangled_memory["node_id"] = "a1"
kept_memo2.entangled_memory["memo_id"] = "a1.kept"
kept_memo2.fidelity = fidelity
meas_memo1.entangled_memory["node_id"] = "a2"
meas_memo1.entangled_memory["memo_id"] = "a2.meas"
meas_memo1.fidelity = fidelity
meas_memo2.entangled_memory["node_id"] = "a1"
meas_memo2.entangled_memory["memo_id"] = "a1.meas"
meas_memo2.fidelity = fidelity
pair1 = np.random.choice(range(4), 1,
p=[fidelity, (1 - fidelity) / 3, (1 - fidelity) / 3, (1 - fidelity) / 3])
pair2 = np.random.choice(range(4), 1,
p=[fidelity, (1 - fidelity) / 3, (1 - fidelity) / 3, (1 - fidelity) / 3])
tl.quantum_manager.set([kept_memo1.qstate_key, kept_memo2.qstate_key], BELL_STATES[pair1[0]])
tl.quantum_manager.set([meas_memo1.qstate_key, meas_memo2.qstate_key], BELL_STATES[pair2[0]])
ep1 = BBPSSW(a1, "a1.ep1.%d" % i, kept_memo1, meas_memo1)
ep2 = BBPSSW(a2, "a2.ep2.%d" % i, kept_memo2, meas_memo2)
a1.protocols.append(ep1)
a2.protocols.append(ep2)
ep1.set_others(ep2)
ep2.set_others(ep1)
ep1.start()
ep2.start()
tl.run()
assert a1.resource_manager.log[-2] == (meas_memo1, RAW)
assert a2.resource_manager.log[-2] == (meas_memo2, RAW)
assert meas_memo1.fidelity == meas_memo2.fidelity == 0
if ep1.meas_res == ep2.meas_res:
assert kept_memo1.fidelity == kept_memo2.fidelity == BBPSSW.improved_fidelity(fidelity)
assert kept_memo1.entangled_memory["node_id"] == "a2" and kept_memo2.entangled_memory["node_id"] == "a1"
assert a1.resource_manager.log[-1] == (kept_memo1, ENTANGLED)
assert a2.resource_manager.log[-1] == (kept_memo2, ENTANGLED)
else:
assert kept_memo1.fidelity == kept_memo2.fidelity == 0
assert kept_memo1.entangled_memory["node_id"] == kept_memo2.entangled_memory["node_id"] == None
assert a1.resource_manager.log[-1] == (kept_memo1, RAW)
assert a2.resource_manager.log[-1] == (kept_memo2, RAW)
def test_EntanglementSwapping():
tl = Timeline()
a1 = FakeNode("a1", tl)
a2 = FakeNode("a2", tl)
a3 = FakeNode("a3", tl)
cc0 = ClassicalChannel("a2-a1", tl, 0, 1e5)
cc1 = ClassicalChannel("a2-a3", tl, 0, 1e5)
cc0.set_ends(a2, a1)
cc1.set_ends(a2, a3)
tl.init()
counter1 = counter2 = 0
for i in range(1000):
memo1 = Memory("a1.%d" % i, timeline=tl, fidelity=0.9, frequency=0, efficiency=1, coherence_time=1,
wavelength=500)
memo2 = Memory("a2.%d" % i, tl, 0.9, 0, 1, 1, 500)
memo3 = Memory("a2.%d" % i, tl, 0.9, 0, 1, 1, 500)
memo4 = Memory("a3.%d" % i, tl, 0.9, 0, 1, 1, 500)
memo1.entangled_memory["node_id"] = "a2"
memo1.entangled_memory["memo_id"] = memo2.name
memo1.fidelity = 0.9
memo2.entangled_memory["node_id"] = "a1"
memo2.entangled_memory["memo_id"] = memo1.name
memo2.fidelity = 0.9
memo3.entangled_memory["node_id"] = "a3"
memo3.entangled_memory["memo_id"] = memo4.name
memo3.fidelity = 0.9
memo4.entangled_memory["node_id"] = "a2"
memo4.entangled_memory["memo_id"] = memo3.name
memo4.fidelity = 0.9
es1 = EntanglementSwappingB(a1, "a1.ESb%d" % i, memo1)
a1.protocols.append(es1)
es2 = EntanglementSwappingA(a2, "a2.ESa%d" % i, memo2, memo3, success_prob=0.2)
a2.protocols.append(es2)
es3 = EntanglementSwappingB(a3, "a3.ESb%d" % i, memo4)
a3.protocols.append(es3)
es1.set_others(es2)
es3.set_others(es2)
es2.set_others(es1)
es2.set_others(es3)
es2.start()
assert memo2.fidelity == memo3.fidelity == 0
assert memo1.entangled_memory["node_id"] == memo4.entangled_memory["node_id"] == "a2"
assert memo2.entangled_memory["node_id"] == memo3.entangled_memory["node_id"] == None
assert memo2.entangled_memory["memo_id"] == memo3.entangled_memory["memo_id"] == None
assert a2.resource_manager.log[-2] == (memo2, "RAW")
assert a2.resource_manager.log[-1] == (memo3, "RAW")
tl.run()
if es2.is_success:
counter1 += 1
assert memo1.entangled_memory["node_id"] == "a3" and memo4.entangled_memory["node_id"] == "a1"
assert memo1.fidelity == memo4.fidelity <= memo1.raw_fidelity
assert a1.resource_manager.log[-1] == (memo1, "ENTANGLED")
assert a3.resource_manager.log[-1] == (memo4, "ENTANGLED")
else:
counter2 += 1
assert memo1.entangled_memory["node_id"] == memo4.entangled_memory["node_id"] == None
assert memo1.fidelity == memo4.fidelity == 0
assert a1.resource_manager.log[-1] == (memo1, "RAW")
assert a3.resource_manager.log[-1] == (memo4, "RAW")
assert abs((counter1 / (counter1 + counter2)) - 0.2) < 0.1
def test_BBPSSW1():
tl = Timeline()
a1 = FakeNode("a1", tl)
a2 = FakeNode("a2", tl)
cc = ClassicalChannel("cc", tl, 0, 1e5)
cc.delay = 1e9
cc.set_ends(a1, a2)
tl.init()
for i in range(1000):
fidelity = numpy.random.uniform(0.5, 1)
kept_memo1 = Memory("a1.kept",
tl,
fidelity=fidelity,
frequency=0,
efficiency=1,
coherence_time=1,
wavelength=500)
kept_memo2 = Memory("a2.kept", tl, fidelity, 0, 1, 1, 500)
meas_memo1 = Memory("a1.meas", tl, fidelity, 0, 1, 1, 500)
meas_memo2 = Memory("a2.meas", tl, fidelity, 0, 1, 1, 500)
kept_memo1.entangled_memory["node_id"] = "a2"
kept_memo1.entangled_memory["memo_id"] = "a2.kept"
kept_memo1.fidelity = fidelity
kept_memo2.entangled_memory["node_id"] = "a1"
kept_memo2.entangled_memory["memo_id"] = "a1.kept"
kept_memo2.fidelity = fidelity
meas_memo1.entangled_memory["node_id"] = "a2"
meas_memo1.entangled_memory["memo_id"] = "a2.meas"
meas_memo1.fidelity = fidelity
meas_memo2.entangled_memory["node_id"] = "a1"
meas_memo2.entangled_memory["memo_id"] = "a1.meas"
meas_memo2.fidelity = fidelity
ep1 = BBPSSW(a1, "a1.ep1.%d" % i, kept_memo1, meas_memo1)
ep2 = BBPSSW(a2, "a2.ep2.%d" % i, kept_memo2, meas_memo2)
a1.protocols.append(ep1)
a2.protocols.append(ep2)
ep1.set_others(ep2)
ep2.set_others(ep1)
ep1.start()
ep2.start()
assert ep1.is_success == ep2.is_success
tl.run()
assert a1.resource_manager.log[-2] == (meas_memo1, "RAW")
assert a2.resource_manager.log[-2] == (meas_memo2, "RAW")
assert meas_memo1.fidelity == meas_memo2.fidelity == 0
if ep1.is_success:
assert kept_memo1.fidelity == kept_memo2.fidelity == BBPSSW.improved_fidelity(
fidelity)
assert kept_memo1.entangled_memory[
"node_id"] == "a2" and kept_memo2.entangled_memory[
"node_id"] == "a1"
assert a1.resource_manager.log[-1] == (kept_memo1, "ENTANGLED")
assert a2.resource_manager.log[-1] == (kept_memo2, "ENTANGLED")
else:
assert kept_memo1.fidelity == kept_memo2.fidelity == 0
assert kept_memo1.entangled_memory[
"node_id"] == kept_memo2.entangled_memory["node_id"] == None
assert a1.resource_manager.log[-1] == (kept_memo1, "RAW")
assert a2.resource_manager.log[-1] == (kept_memo2, "RAW")
tl = Timeline()
left_node = SwapNodeB('left', tl)
right_node = SwapNodeB('right', tl)
mid_node = SwapNodeA('mid', tl)
nodes = [left_node, right_node, mid_node]
for i in range(3):
for j in range(3):
if i >= j:
continue
cc = ClassicalChannel('cc_%s_%s' % (nodes[i].name, nodes[j].name), tl,
1000, 1e9)
cc.set_ends(nodes[i], nodes[j])
entangle_memory(left_node.memo, mid_node.left_memo, 0.9)
entangle_memory(right_node.memo, mid_node.right_memo, 0.9)
for node in nodes:
node.create_protocol()
pair_protocol(left_node.protocols[0], mid_node.protocols[0])
pair_protocol(right_node.protocols[0], mid_node.protocols[0])
for node in nodes:
node.protocols[0].start()
tl.init()
tl.run()
"time_resolution": 10,
"count_rate": 50e6
}, {
"efficiency": 0.8,
"dark_count": 10,
"time_resolution": 10,
"count_rate": 50e6
}]
bob = QKDNode("bob", tl)
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)
qc1.set_ends(bob, alice)
cc0.set_ends(alice, bob)
cc1.set_ends(bob, alice)
# BB84 config
pair_bb84_protocols(alice.protocol_stack[0], bob.protocol_stack[0])
# cascade config
pair_cascade_protocols(alice.protocol_stack[1], bob.protocol_stack[1])
process = Process(alice.protocol_stack[1], 'push',
[256, math.inf, 12e12])
tl.schedule(Event(0, process))
tl.init()
tl.run()
print("completed distance {}".format(distance))
pass
def received_message(self, src: str, message: Message):
assert message.msg_type == MsgType.PING
print("node {} received ping message at time {}".format(
self.own.name, self.own.timeline.now()))
new_msg = Message(MsgType.PONG, self.other_name)
self.own.send_message(self.other_node, new_msg)
if __name__ == "__main__":
tl = Timeline(1e12)
node1 = Node("node1", tl)
node2 = Node("node2", tl)
cc0 = ClassicalChannel("cc0", tl, 1e3, 1e9)
cc1 = ClassicalChannel("cc1", tl, 1e3, 1e9)
cc0.set_ends(node1, node2)
cc1.set_ends(node2, node1)
pingp = PingProtocol(node1, "pingp", "pongp", "node2")
pongp = PongProtocol(node2, "pongp", "pingp", "node1")
process = Process(pingp, "start", [])
event = Event(0, process)
tl.schedule(event)
tl.init()
tl.run()
