def test_polarization_get():
tl = Timeline()
tl.seed(0)
detectors = [{"efficiency": 1}] * 4
bsm = make_bsm("bsm",
tl,
encoding_type="polarization",
detectors=detectors)
parent = Parent()
bsm.attach(parent)
# get 2 photons in orthogonal states (map to Psi+)
p1 = Photon("p1", location=1, quantum_state=(complex(1), complex(0)))
p2 = Photon("p2", location=2, quantum_state=(complex(0), complex(1)))
bsm.get(p1)
bsm.get(p2)
assert len(parent.results) == 1
# get 2 photons in same state (map to Phi+ / can't measure)
tl.time = 1e6
p3 = Photon("p3", location=1, quantum_state=(complex(1), complex(0)))
p4 = Photon("p4", location=2, quantum_state=(complex(1), complex(0)))
bsm.get(p3)
bsm.get(p4)
assert len(parent.results) == 1
def test_time_bin_update():
tl = Timeline()
tl.seed(0)
detectors = [{}] * 2
bsm = make_bsm("bsm", tl, encoding_type="time_bin", detectors=detectors)
parent = Parent()
bsm.attach(parent)
detector_list = bsm.detectors
# test Psi+
bsm.trigger(detector_list[0], {'time': 0})
bsm.trigger(detector_list[0], {'time': 0 + time_bin["bin_separation"]})
assert len(parent.results) == 1
assert parent.results[0] == 0
# test Psi-
bsm.trigger(detector_list[0], {'time': 1e6})
bsm.trigger(detector_list[1], {'time': 1e6 + time_bin["bin_separation"]})
assert len(parent.results) == 2
assert parent.results[1] == 1
# test invalid time separation
bsm.trigger(detector_list[0], {'time': 2e6})
bsm.trigger(detector_list[0], {'time': 2e6})
assert len(parent.results) == 2
bsm.trigger(detector_list[0], {'time': 3e6})
bsm.trigger(detector_list[0], {'time': 4e6})
assert len(parent.results) == 2
def test_base_get():
tl = Timeline()
tl.seed(0)
photon1 = Photon("", location=1)
photon2 = Photon("", location=2)
photon3 = Photon("", location=3)
photon1_2 = Photon("", location=1)
detectors = [{}] * 2
bsm = make_bsm("bsm", tl, encoding_type="time_bin", detectors=detectors)
bsm.get(photon1)
assert len(bsm.photons) == 1
# same location
bsm.get(photon1_2)
assert len(bsm.photons) == 1
# different location
bsm.get(photon2)
assert len(bsm.photons) == 2
# later time
tl.time = 1
bsm.get(photon3)
assert len(bsm.photons) == 1
def test_QSDetectorPolarization_update_detector_params():
tl = Timeline()
tl.seed(1)
qsdetector = QSDetectorPolarization("qsd", tl)
qsdetector.update_detector_params(0, "dark_count", 99)
assert qsdetector.detectors[
0].dark_count == 99 and qsdetector.detectors[1].dark_count != 99
def test_construct_func():
tl = Timeline()
tl.seed(0)
detectors2 = [{}] * 2
detectors4 = [{}] * 4
# unknown encoding scheme
with pytest.raises(Exception):
bsm = make_bsm("bsm",
tl,
encoding_type="unknown",
detectors=detectors4)
# implemented encoding schemes
polar_bsm = make_bsm("bsm",
tl,
encoding_type="polarization",
detectors=detectors4)
time_bin_bsm = make_bsm("bsm",
tl,
encoding_type="time_bin",
detectors=detectors2)
atom_bsm = make_bsm("bsm",
tl,
encoding_type="single_atom",
detectors=detectors2)
assert type(polar_bsm) == PolarizationBSM
assert type(time_bin_bsm) == TimeBinBSM
assert type(atom_bsm) == SingleAtomBSM
def test_generation_expire():
class DumbBSM():
def __init__(self):
pass
def get(self, qubit):
pass
tl = Timeline(1e12)
e0 = Node("e0", tl)
e1 = Node("e1", tl)
m0 = FakeNode("m0", tl)
qc0 = QuantumChannel("qc_e0m0", tl, 0, 1e3)
qc1 = QuantumChannel("qc_e1m0", tl, 0, 1e3)
qc0.set_ends(e0, m0)
qc1.set_ends(e1, m0)
cc0 = ClassicalChannel("cc_e0m0", tl, 1e3, delay=1e12)
cc1 = ClassicalChannel("cc_e1m0", tl, 1e3, delay=1e12)
cc2 = ClassicalChannel("cc_e0e1", tl, 2e3, delay=1e9)
cc3 = ClassicalChannel("cc_e1e0", tl, 2e3, delay=1e9)
cc0.set_ends(e0, m0)
cc1.set_ends(e1, m0)
cc2.set_ends(e0, e1)
cc3.set_ends(e1, e0)
e0.memory_array = MemoryArray("e0mem", tl, coherence_time=1)
e1.memory_array = MemoryArray("e1mem", tl, coherence_time=1)
e0.memory_array.owner = e0
e1.memory_array.owner = e1
m0.bsm = DumbBSM()
tl.init()
protocol0 = EntanglementGenerationA(e0,
"e0prot",
middle="m0",
other="e1",
memory=e0.memory_array[0])
protocol1 = EntanglementGenerationA(e1,
"e1prot",
middle="m0",
other="e0",
memory=e1.memory_array[0])
protocol0.primary = True
e0.protocols.append(protocol0)
e1.protocols.append(protocol1)
protocol0.set_others(protocol1)
protocol1.set_others(protocol0)
process = Process(protocol0, "start", [])
event = Event(0, process)
tl.schedule(event)
process = Process(protocol1, "start", [])
event = Event(0, process)
tl.schedule(event)
tl.run()
assert e0.memory_array[0].expiration_event.time > 1e12
def test_ClassicalChannel_transmit():
class FakeNode(Node):
def __init__(self, name, tl, **kwargs):
Node.__init__(self, name, tl, **kwargs)
self.msgs = []
def receive_message(self, src: str, msg: str):
self.msgs.append([tl.now(), src, msg])
tl = Timeline()
cc = ClassicalChannel("cc", tl, 1e3)
n1 = FakeNode('n1', tl)
n2 = FakeNode('n2', tl)
cc.set_ends(n1, n2)
args = [['1-1', n1, 5], ['1-2', n1, 5]]
results = [[cc.delay, 'n1', '1-1'], [1 + cc.delay, 'n1', '1-2']]
for arg in args:
cc.transmit(arg[0], arg[1], arg[2])
tl.time += 1
tl.run()
assert len(n1.msgs) == 0 and len(n2.msgs) == 2
for msg, res in zip(n2.msgs, results):
assert msg == res
def test_QSDetectorPolarization_update_splitter_params():
fidelity = 0.9
tl = Timeline()
tl.seed(1)
qsdetector = QSDetectorPolarization("qsd", tl)
qsdetector.update_splitter_params("fidelity", fidelity)
assert qsdetector.splitter.fidelity == fidelity
def test_init():
tl = Timeline()
dummys = [Dummy(str(i), tl) for i in range(100)]
for d in dummys:
assert d.flag is False
tl.init()
for d in dummys:
assert d.flag is True
def test_QSDetector_update():
tl = Timeline()
tl.seed(1)
qsdetector = QSDetectorPolarization("qsd", tl)
args = [[0, 10], [1, 20], [1, 40]]
for arg in args:
qsdetector.trigger(qsdetector.detectors[arg[0]], {'time': arg[1]})
trigger_times = qsdetector.trigger_times
assert trigger_times[arg[0]][-1] == arg[1]
def test_QSDetectorPolarization_set_basis_list():
tl = Timeline()
tl.seed(1)
qsdetector = QSDetectorPolarization("qsd", tl)
basis_list = []
start_time = 0
frequency = 1e6
qsdetector.set_basis_list(basis_list, start_time, frequency)
assert qsdetector.splitter.basis_list == basis_list and \
qsdetector.splitter.start_time == start_time and \
qsdetector.splitter.frequency == frequency
def test_MemoryWithRandomCoherenceTime__schedule_expiration():
NUM_TRIALS = 200
coherence_period_avg = 1
coherence_period_stdev = 0.15
tl = Timeline()
mem = MemoryWithRandomCoherenceTime(
"mem",
tl,
fidelity=1,
frequency=0,
efficiency=1,
coherence_time=coherence_period_avg,
coherence_time_stdev=coherence_period_stdev,
wavelength=500)
parent = DumbParent(mem)
times_of_expiration_calculated = [0]
np.random.seed(2)
for i in range(NUM_TRIALS):
times_of_expiration_calculated.append(
times_of_expiration_calculated[-1] +
int(mem.coherence_time_distribution() * 1e12))
times_of_expiration_calculated.pop(0)
np.random.seed(2)
process = Process(mem, "update_state",
[[complex(math.sqrt(1 / 2)),
complex(math.sqrt(1 / 2))]])
for i in range(NUM_TRIALS):
event = Event(tl.now(), process)
tl.schedule(event)
tl.init()
tl.run()
assert times_of_expiration_calculated[i] == tl.now()
period_sum = times_of_expiration_calculated[0]
period_squared_sum = times_of_expiration_calculated[0]**2
for i in range(1, len(times_of_expiration_calculated)):
period = times_of_expiration_calculated[
i] - times_of_expiration_calculated[i - 1]
period_sum += period
period_squared_sum += period * period
avg_simulated = period_sum / NUM_TRIALS * 1e-12
stdev_simulated = np.sqrt(
(period_squared_sum - period_sum * period_sum * 1.0 / NUM_TRIALS) /
NUM_TRIALS) * 1e-12
#check that values in series are different
assert stdev_simulated > 0.0
#probability of error below is less then 0.3%
assert abs(avg_simulated - coherence_period_avg
) < 3 * coherence_period_stdev / np.sqrt(NUM_TRIALS)
def test_expire():
tl = Timeline()
node = FakeNode("node", tl)
tl.init()
for info in node.resource_manager.memory_manager:
info.to_occupied()
rule = Rule(0, None, None)
for i in range(6):
node.memory_array[i].detach(node.memory_array)
p1 = FakeProtocol("waiting_protocol", [node.memory_array[0]])
node.memory_array[0].attach(p1)
p2 = FakeProtocol("pending_protocol", [node.memory_array[1]])
node.memory_array[1].attach(p2)
p3 = FakeProtocol("running_protocol", [node.memory_array[2]])
node.memory_array[2].attach(p3)
p4 = FakeProtocol("other_waiting_protocol", [node.memory_array[3]])
node.memory_array[3].attach(p4)
p5 = FakeProtocol("other_pending_protocol", [node.memory_array[4]])
node.memory_array[4].attach(p5)
p6 = FakeProtocol("other_running_protocol", [node.memory_array[5]])
node.memory_array[5].attach(p6)
for p in [p1, p2, p3]:
p.rule = rule
rule.protocols.append(p)
node.resource_manager.rule_manager.load(rule)
for p in [p3, p6]:
node.protocols.append(p)
for p in [p2, p5]:
node.resource_manager.pending_protocols.append(p)
for p in [p1, p4]:
node.resource_manager.waiting_protocols.append(p)
for i in range(6):
assert node.resource_manager.memory_manager[i].state == "OCCUPIED"
node.resource_manager.expire(rule)
assert p1 not in node.resource_manager.waiting_protocols and p4 in node.resource_manager.waiting_protocols
assert p2 not in node.resource_manager.pending_protocols
assert p5 in node.resource_manager.pending_protocols
assert p3 not in node.protocols and p6 in node.protocols
for i in range(3):
assert node.resource_manager.memory_manager[i].state == "RAW"
for i in range(3, 6):
assert node.resource_manager.memory_manager[i].state == "OCCUPIED"
for i, memory in enumerate(node.memory_array):
if i < 3:
assert len(memory._observers) == 1 and isinstance(
memory._observers.pop(), MemoryArray)
elif i < 6:
assert len(memory._observers) == 1 and isinstance(
memory._observers.pop(), FakeProtocol)
def create_intf(quantum_state):
class Receiver():
def __init__(self, name, timeline):
self.name = name
self.timeline = timeline
self.log = []
def get(self):
self.log.append(self.timeline.now())
tl = Timeline()
intfm = Interferometer("interferometer", tl, time_bin["bin_separation"])
d0 = Receiver("d0", tl)
d1 = Receiver("d1", tl)
intfm.set_receiver(0, d0)
intfm.set_receiver(1, d1)
tl.init()
for i in range(NUM_TRIALS):
tl.time = i * 1e6
photon = Photon(str(i), quantum_state=quantum_state)
intfm.get(photon)
tl.time = 0
tl.run()
return intfm.receivers[0].log, intfm.receivers[1].log
def test_QuantumChannel_transmit():
from sequence.components.photon import Photon
random.seed(1)
class FakeNode(Node):
def __init__(self, name, tl):
Node.__init__(self, name, tl)
self.log = []
def receive_qubit(self, src, photon):
self.log.append((src, self.timeline.now(), photon.name))
tl = Timeline()
qc = QuantumChannel("qc", tl, attenuation=0.0002, distance=1e4)
sender = FakeNode("sender", tl)
receiver = FakeNode("receiver", tl)
qc.set_ends(sender, receiver)
tl.init()
for i in range(1000):
photon = Photon(str(i))
qc.transmit(photon, sender)
tl.time = tl.time + 1
for i in range(1000):
photon = Photon(str(i))
qc.transmit(photon, receiver)
tl.time = tl.time + 1
assert len(sender.log) == len(receiver.log) == 0
tl.run()
expect_rate = 1 - qc.loss
assert abs(len(sender.log) / 1000 - expect_rate) < 0.1
assert abs(len(receiver.log) / 1000 - expect_rate) < 0.1
def test_QSDetectorTimeBin():
tl = Timeline()
tl.seed(1)
qsdetector = QSDetectorTimeBin("qsd", tl)
[qsdetector.update_detector_params(i, "efficiency", 1) for i in range(3)]
frequency = 1e5
start_time = 0
basis_list = [random.randint(2) for _ in range(1000)]
qsdetector.set_basis_list(basis_list, start_time, frequency)
for i in range(1000):
tl.time = i * 1e12 / frequency
basis = basis_list[i]
bit = random.randint(2)
photon = Photon(str(i),
encoding_type=time_bin,
quantum_state=time_bin["bases"][basis][bit])
qsdetector.get(photon)
tl.time = 0
tl.run()
trigger_times = qsdetector.get_photon_times()
length = len(trigger_times[0] + trigger_times[1] + trigger_times[2])
assert abs(length / 1000 - 7 / 8) < 0.1
def test_RandomRequestApp_get_reserve_res():
tl = Timeline()
tl.time = 6
node = FakeNode("n1", tl)
app = RandomRequestApp(node, ["n2", "n3"], 0)
app.cur_reserve = ["n3", 10, 20, 5, 0.9]
reservation = Reservation("n1", "n3", 10, 20, 5, 0.9)
for i, card in enumerate(node.network_manager.protocol_stack[1].timecards):
if i < 20:
card.add(reservation)
app.request_time = 5
app.get_reserve_res(reservation, True)
assert app.get_wait_time()[0] == 5
assert len(tl.events) == 41 and tl.events.data[0].time == 10
tl = Timeline()
tl.time = 6
node = FakeNode("n1", tl)
app = RandomRequestApp(node, ["n2", "n3"], 0)
app.cur_reserve = ["n3", 10, 20, 5, 0.9]
reservation = Reservation("n1", "n3", 10, 20, 5, 0.9)
app.request_time = 5
app.get_reserve_res(reservation, False)
tl.run()
assert len(app.get_wait_time()) == 0
assert app.cur_reserve[0] == "n3"
assert app.cur_reserve[1] != 10
assert app.cur_reserve[2] != 20
assert app.cur_reserve[3] != 5
assert app.cur_reserve[4] == 0.9
assert len(node.reserve_log) == 1
def create_switch(basis_list, photons):
class Receiver():
def __init__(self, tl):
self.timeline = tl
self.log = []
def get(self, photon=None):
self.log.append((self.timeline.now(), photon))
tl = Timeline()
sw = Switch("sw", tl)
r1 = Receiver(tl)
r2 = Receiver(tl)
sw.set_detector(r1)
sw.set_interferometer(r2)
sw.set_basis_list(basis_list, 0, FREQ)
tl.init()
for i, photon in enumerate(photons):
tl.time = 1e12 / FREQ * i
sw.get(photons[i])
tl.time = 0
tl.run()
return r1.log, r2.log
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_update_event_time():
tl = Timeline()
d1 = Dummy('1', tl)
event1 = Event(10, Process(d1, 'click', []))
d2 = Dummy('2', tl)
event2 = Event(10, Process(d2, 'click', []))
tl.schedule(event1)
tl.schedule(event2)
tl.init()
assert d1.click_time is None and d2.click_time is None
tl.update_event_time(event2, 20)
tl.run()
assert d1.click_time == 10 and d2.click_time == 20
def test_RandomRequestApp_get_other_reservation():
tl = Timeline()
node = FakeNode("fake", tl)
reservation = Reservation("initiator", "fake", 10, 100, 10, 0.9)
counter = 0
for card in node.network_manager.protocol_stack[1].timecards:
if counter >= 10:
break
card.add(reservation)
counter += 1
app = RandomRequestApp(node, [], 0)
app.get_other_reservation(reservation)
assert len(app.memo_to_reserve) == 0
tl.stop_time = 11
tl.run()
assert len(app.memo_to_reserve) == 10
info = node.resource_manager.memory_manager[0]
info.memory.entangled_memory = {"node_id": "initiator", "memo_id": "memo"}
info.memory.fidelity = 1
info.to_entangled()
app.get_memory(info)
assert info.state == "RAW" and info.memory.entangled_memory[
"node_id"] is None
info = node.resource_manager.memory_manager[10]
info.memory.entangled_memory = {"node_id": "initiator", "memo_id": "memo"}
info.memory.fidelity = 1
info.to_entangled()
app.get_memory(info)
assert info.state == "ENTANGLED"
info = node.resource_manager.memory_manager[0]
info.memory.entangled_memory = {"node_id": "initiator", "memo_id": "memo"}
info.memory.fidelity = 0.8
info.to_entangled()
app.get_memory(info)
assert info.state == "ENTANGLED"
info = node.resource_manager.memory_manager[1]
info.memory.entangled_memory = {"node_id": "x", "memo_id": "memo"}
info.memory.fidelity = 1
info.to_entangled()
app.get_memory(info)
assert info.state == "ENTANGLED"
tl.stop_time = 101
tl.run()
print(app.memo_to_reserve)
assert len(app.memo_to_reserve) == 0
info = node.resource_manager.memory_manager[0]
info.memory.entangled_memory = {"node_id": "initiator", "memo_id": "memo"}
info.memory.fidelity = 1
info.to_entangled()
app.get_memory(info)
assert info.state == "ENTANGLED"
def create_detector(efficiency=0.9, dark_count=0, count_rate=25e6, time_resolution=150):
class Parent():
def __init__(self, tl):
self.timeline = tl
self.log = []
def trigger(self, detector, msg):
self.log.append((self.timeline.now(), msg['time'], detector))
tl = Timeline()
tl.seed(1)
detector = Detector("", tl, efficiency=efficiency, dark_count=dark_count,
count_rate=count_rate, time_resolution=time_resolution)
parent = Parent(tl)
detector.attach(parent)
return detector, parent, tl
def test_MemoryArray_init():
tl = Timeline()
ma = MemoryArray("ma", tl, num_memories=10)
assert len(ma.memories) == 10
for m in ma.memories:
assert type(m) == Memory
def test_RandomRequestApp_update_last_rsvp_metrics():
tl = Timeline()
node = QuantumRouter("n1", tl)
app = RandomRequestApp(node, [], 0)
app._update_last_rsvp_metrics()
assert len(app.get_throughput()) == 0
app.cur_reserve = ["n2", 1e13, 2e13, 5, 0.9]
app.reserves.append(app.cur_reserve)
app.memory_counter = 10
tl.time = 20
assert app.request_time == 0
app._update_last_rsvp_metrics()
assert len(app.get_throughput()) == 1 and app.get_throughput()[0] == 1
assert app.cur_reserve == []
assert app.request_time == 20
assert app.memory_counter == 0
def test_log():
open(filename, 'w').close()
assert file_len(filename) == 0
tl = Timeline()
de = DumbEntity()
lg.set_logger(__name__, tl, filename)
lg.set_logger_level("DEBUG")
lg.track_module(__name__)
tl.init()
de.log()
# TODO: fix (should be 1)
assert file_len(filename) == 2
def test_add_node():
tl = Timeline()
topo = Topology("test_topo", tl)
n1 = Node("n1", tl)
topo.add_node(n1)
assert len(topo.nodes) == 1
assert topo.nodes["n1"] == n1
def test_RandomRequestApp_get_memory():
tl = Timeline(1)
node = FakeNode("n1", tl)
app = RandomRequestApp(node, ["n2", "n3"], 0)
app.cur_reserve = ["n2", 0, 100, 2, 0.85]
reservation = Reservation("n1", "n2", 0, 100, 2, 0.85)
counter = 0
for card in node.network_manager.protocol_stack[1].timecards:
card.add(reservation)
counter += 1
if counter > 2:
break
app.get_other_reservation(reservation)
tl.run()
node.memory_array[0].entangled_memory["node_id"] = "n2"
node.memory_array[0].entangled_memory["memo_id"] = "1"
node.memory_array[0].fidelity = 0.9
node.resource_manager.update(None, node.memory_array[0], "ENTANGLED")
app.get_memory(node.resource_manager.memory_manager[0])
assert node.resource_manager.memory_manager[0].state == "RAW"
assert node.memory_array[0].entangled_memory["node_id"] == None
assert node.memory_array[0].fidelity == 0
node.memory_array[1].entangled_memory["node_id"] = "n3"
node.memory_array[1].entangled_memory["memo_id"] = "1"
node.memory_array[1].fidelity = 0.9
node.resource_manager.update(None, node.memory_array[1], "ENTANGLED")
app.get_memory(node.resource_manager.memory_manager[1])
assert node.resource_manager.memory_manager[1].state == "ENTANGLED"
node.memory_array[2].entangled_memory["node_id"] = "n2"
node.memory_array[2].entangled_memory["memo_id"] = "1"
node.memory_array[2].fidelity = 0.84
node.resource_manager.update(None, node.memory_array[2], "ENTANGLED")
app.get_memory(node.resource_manager.memory_manager[2])
assert node.resource_manager.memory_manager[2].state == "ENTANGLED"
node.memory_array[3].entangled_memory["node_id"] = "n2"
node.memory_array[3].entangled_memory["memo_id"] = "1"
node.memory_array[3].fidelity = 0.9
node.resource_manager.update(None, node.memory_array[3], "ENTANGLED")
app.get_memory(node.resource_manager.memory_manager[3])
assert node.resource_manager.memory_manager[3].state == "ENTANGLED"
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_NetworkManager_push():
tl = Timeline()
node = FakeNode("node", tl)
node.send_out = False
assert len(node.send_log) == 0
node.network_manager.push(dst="dst", msg="msg")
assert len(node.send_log) == 1
assert node.send_log[0][0] == "dst" and isinstance(node.send_log[0][1],
NetworkManagerMessage)
def test_Memory_expire():
class FakeProtocol(EntanglementProtocol):
def __init__(self, name):
super().__init__(None, name)
self.is_expire = False
def set_others(self, other: "EntanglementProtocol") -> None:
pass
def start(self) -> None:
pass
def is_ready(self) -> bool:
pass
def memory_expire(self, memory) -> None:
self.is_expire = True
def received_message(self, src: str, msg: "Message"):
pass
def expire(self, memory: Memory):
self.memory_expire(memory)
tl = Timeline()
mem = Memory("mem",
tl,
fidelity=1,
frequency=0,
efficiency=1,
coherence_time=-1,
wavelength=500)
parent = DumbParent(mem)
protocol = FakeProtocol("upper_protocol")
mem.attach(protocol)
mem.update_state([math.sqrt(1 / 2), math.sqrt(1 / 2)])
entangled_memory = {"node_id": "node", "memo_id": 0}
mem.entangled_memory = entangled_memory
# expire when the protocol controls memory
mem.detach(parent)
assert len(parent.pop_log) == 0 and protocol.is_expire is False
mem.expire()
assert (tl.quantum_manager.get(mem.qstate_key).state == np.array(
[1, 0])).all # check if collapsed to |0> state
assert mem.entangled_memory == {"node_id": None, "memo_id": None}
assert len(parent.pop_log) == 0 and protocol.is_expire is True
# expire when the resource manager controls memory
mem.attach(parent)
mem.detach(protocol)
mem.update_state([math.sqrt(1 / 2), math.sqrt(1 / 2)])
entangled_memory = {"node_id": "node", "memo_id": 0}
mem.entangled_memory = entangled_memory
mem.expire()
assert len(parent.pop_log) == 1
