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 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
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) cc = ClassicalChannel("cc", tl, 1e3) cc.set_ends(node1, node2) 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 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]) qc = QuantumChannel("qc", tl, distance=1e3, attenuation=2e-5, polarization_fidelity=0.97) qc.set_ends(alice, bob) cc = ClassicalChannel("cc", tl, distance=1e3) cc.set_ends(alice, bob) # 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_assign_cchannel(): tl = Timeline() node = Node("node1", tl) cc = ClassicalChannel("cc", tl, 1e3) node.assign_cchannel(cc, "node2") assert "node2" in node.cchannels and node.cchannels["node2"] == cc
memo2.entangled_memory['memo_id'] = memo1.name 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()
KEYNUM = 10 errors = [] # store error rates throughputs = [] # store throughputs # open file to store experiment results # Path("results/timebin").mkdir(parents=True, exist_ok=True) # filename = "results/timebin/distance_cascade.log" # fh = open(filename, 'w') for distance in distances: tl = Timeline(runtime) tl.seed(1) tl.show_progress = True qc = QuantumChannel("qc", tl, distance=distance * 1e3, attenuation=0.0002) cc = ClassicalChannel("cc", tl, distance=distance * 1e3) # Alice ls_params = {"frequency": 2e6, "mean_photon_num": 0.1} alice = QKDNode("alice", tl, encoding=time_bin) 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)):
# nodes r1 = RouterNode("r1", tl, memo_size=20) r2 = RouterNode("r2", tl, memo_size=30) r3 = RouterNode("r3", tl, memo_size=10) m12 = BSMNode("m12", tl, ["r1", "r2"]) m23 = BSMNode("m23", tl, ["r2", "r3"]) # create all-to-all classical connections cc_delay = 1e9 node_list = [r1, r2, r3, m12, m23] for node1 in node_list: for node2 in node_list: cc = ClassicalChannel("cc_%s_%s" % (node1.name, node2.name), tl, 1e3, delay=cc_delay) cc.set_ends(node1, node2) # create quantum channels linking r1 and r2 to m1 qc_atten = 0 qc_dist = 1e3 qc1 = QuantumChannel("qc_r1_m12", tl, qc_atten, qc_dist) qc1.set_ends(r1, m12) qc2 = QuantumChannel("qc_r2_m12", tl, qc_atten, qc_dist) qc2.set_ends(r2, m12) # create quantum channels linking r2 and r3 to m2 qc3 = QuantumChannel("qc_r2_m23", tl, qc_atten, qc_dist) qc3.set_ends(r2, m23) qc4 = QuantumChannel("qc_r3_m23", tl, qc_atten, qc_dist) qc4.set_ends(r3, m23)
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_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_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
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()
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_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
p2.set_others(p1) 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()
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_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")
def init(self): 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) cc = ClassicalChannel("cc", tl, 1e3, 1e9) cc.set_ends(node1, node2) 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()
tl = Timeline(runtime) tl.seed(2) tl.show_progress = True qc0 = QuantumChannel("qc0", tl, distance=distance, polarization_fidelity=0.97, attenuation=0.0002) qc1 = QuantumChannel("qc1", tl, distance=distance, polarization_fidelity=0.97, attenuation=0.0002) cc0 = ClassicalChannel("cc0", tl, distance=distance) cc1 = ClassicalChannel("cc1", tl, distance=distance) cc0.delay += 10e9 cc1.delay += 10e9 # Alice ls_params = {"frequency": 80e6, "mean_photon_num": 0.1} alice = QKDNode("alice", tl) for name, param in ls_params.items(): alice.update_lightsource_params(name, param) # Bob detector_params = [{ "efficiency": 0.8, "dark_count": 10, "time_resolution": 10,
memo2.entangled_memory['memo_id'] = memo1.name 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) cc0 = ClassicalChannel('cc0', tl, 1000, 1e9) cc1 = ClassicalChannel('cc1', tl, 1000, 1e9) cc0.set_ends(node1, node2) cc1.set_ends(node2, node1) 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()