def main():
network = Network.get_instance()
network.start()
host_alice = Host('Alice')
host_bob = Host('Bob')
host_eve = Host('Eve')
host_alice.add_connection('Bob')
host_bob.add_connections(['Alice', 'Eve'])
host_eve.add_connection('Bob')
host_alice.start()
host_bob.start()
host_eve.start()
network.add_hosts([host_alice, host_bob, host_eve])
q = Qubit(host_alice)
print(q.id)
q.X()
host_alice.send_epr('Eve', await_ack=True)
print('done')
host_alice.send_teleport('Eve', q, await_ack=True)
q_eve = host_eve.get_data_qubit(host_alice.host_id, q.id, wait=5)
assert q_eve is not None
print(q.id)
print('Eve measures: %d' % q_eve.measure())
network.stop(True)
def main():
# initialize network
network = Network.get_instance()
network.delay = 0
network.start()
clock = Clock()
controller_host = ControllerHost(
host_id="host_1",
clock=clock,
)
computing_hosts, q_map = controller_host.create_distributed_network(
num_computing_hosts=2, num_qubits_per_host=3)
controller_host.start()
network.add_hosts(computing_hosts + [controller_host])
print('starting...')
# For phase = 1/8
# client_input_gate = np.array([[1, 0], [0, np.exp(1j * np.pi / 4)]])
# For phase = 1/3
client_input_gate = np.array([[1, 0], [0, np.exp(1j * 2 * np.pi / 3)]])
t1 = controller_host.run_protocol(controller_host_protocol,
(q_map, client_input_gate))
t2 = computing_hosts[0].run_protocol(computing_host_protocol)
t3 = computing_hosts[1].run_protocol(computing_host_protocol)
t1.join()
t2.join()
t3.join()
network.stop(True)
exit()
def main():
network = Network.get_instance()
nodes = ["Alice", "Bob", "Eve"]
network.start(nodes)
network.delay = 0.1
host_alice = Host('Alice')
host_alice.add_connection('Bob')
host_alice.start()
host_bob = Host('Bob')
host_bob.add_connections(['Alice', 'Eve'])
host_bob.start()
host_eve = Host('Eve')
host_eve.add_connection('Bob')
host_eve.start()
network.add_hosts([host_alice, host_bob, host_eve])
host_bob.q_relay_sniffing = True
host_bob.q_relay_sniffing_fn = bob_sniffing_quantum
host_bob.c_relay_sniffing = True
host_bob.c_relay_sniffing_fn = bob_sniffing_classical
t1 = host_alice.run_protocol(alice)
t2 = host_eve.run_protocol(eve)
t1.join()
t2.join()
network.stop(True)
exit()
def main():
# initialize network
network = Network.get_instance()
network.delay = 0
network.start()
controller_host = ControllerHost(host_id="host_1", )
computing_hosts, q_map = controller_host.create_distributed_network(
num_computing_hosts=2, num_qubits_per_host=2)
controller_host.start()
network.add_host(controller_host)
for host in computing_hosts:
network.add_host(host)
print('starting...')
t = controller_host.run_protocol(controller_host_protocol, (q_map, ))
threads = [t]
for host in computing_hosts:
t = host.run_protocol(computing_host_protocol)
threads.append(t)
for thread in threads:
thread.join()
network.stop(True)
exit()
def main():
# Initialize a network
network = Network.get_instance()
nodes = ['Alice', 'Bob', 'Eve']
network.delay = 0.0
network.start(nodes)
host_alice = Host('Alice')
host_alice.add_connection('Bob')
host_alice.start()
host_bob = Host('Bob')
host_bob.add_connection('Alice')
host_bob.add_connection('Eve')
host_bob.start()
host_eve = Host('Eve')
host_eve.add_connection('Bob')
host_eve.start()
network.add_host(host_alice)
network.add_host(host_bob)
network.add_host(host_eve)
print('Starting transfer')
t1 = host_alice.run_protocol(banker_protocol, (host_eve.host_id,))
t2 = host_eve.run_protocol(customer_protocol, (host_alice.host_id,))
t1.join()
t2.join()
network.stop(True)
def main():
network = Network.get_instance()
nodes = ["Alice", "Bob"]
network.x_error_rate = 0
network.delay = 0.5
network.start(nodes)
host_alice = Host('Alice')
host_alice.add_connection('Bob')
host_alice.max_ack_wait = 10
host_alice.delay = 0.2
host_alice.start()
host_bob = Host('Bob')
host_bob.max_ack_wait = 10
host_bob.delay = 0.2
host_bob.add_connection('Alice')
host_bob.start()
network.add_host(host_alice)
network.add_host(host_bob)
q_size = 6
host_alice.run_protocol(qudp_sender, (q_size, host_bob.host_id))
host_bob.run_protocol(qudp_receiver, (q_size, host_alice.host_id))
start_time = time.time()
while time.time() - start_time < 50:
pass
network.stop(stop_hosts=True)
def main():
network = Network.get_instance()
nodes = ['A', 'B', 'C', 'D', 'E']
network.start(nodes)
host_A = Host('A')
host_A.add_connections(['B', 'C', 'D', 'E'])
host_A.start()
host_B = Host('B')
host_B.add_c_connections(['C', 'D', 'E'])
host_B.start()
host_C = Host('C')
host_C.add_c_connections(['B', 'D', 'E'])
host_C.start()
host_D = Host('D')
host_D.add_c_connections(['B', 'C', 'E'])
host_D.start()
host_E = Host('E')
host_E.add_c_connections(['B', 'C', 'D'])
host_E.start()
network.add_hosts([host_A, host_B, host_C, host_D, host_E])
for i in range(10):
# The ID of the generated secret EPR pair has to be agreed upon in advance
epr_id = '123'
host_A.run_protocol(distribute, ([host_B.host_id, host_C.host_id, host_D.host_id, host_E.host_id],))
host_B.run_protocol(node, (host_A.host_id,))
host_C.run_protocol(node, (host_A.host_id,))
host_D.run_protocol(sender, (host_A.host_id, host_E.host_id, epr_id))
host_E.run_protocol(receiver, (host_A.host_id, host_D.host_id, epr_id), blocking=True)
time.sleep(0.5)
network.stop(True)
def main():
network = Network.get_instance()
network.delay = 0.1
nodes = ["Alice", "Bob", "Eve"]
network.start(nodes)
host_alice = Host('Alice')
host_alice.add_connection('Bob')
host_alice.start()
host_bob = Host('Bob')
host_bob.add_connection('Alice')
host_bob.add_connection('Eve')
host_bob.start()
host_eve = Host('Eve')
host_eve.add_connection('Bob')
host_eve.start()
network.add_host(host_alice)
network.add_host(host_bob)
network.add_host(host_eve)
host_alice.send_superdense('Eve', '11', await_ack=True)
host_alice.send_superdense('Eve', '10', await_ack=True)
host_alice.send_superdense('Eve', '00', await_ack=True)
messages = host_eve.get_classical('Alice')
for m in messages:
print('----')
print(m)
print('----')
network.stop(True)
def main():
network = Network.get_instance()
nodes = ["Alice", "Bob", "Eve", "Dean"]
backend = CQCBackend()
network.start(nodes, backend)
network.delay = 0.7
hosts = {'alice': Host('Alice', backend), 'bob': Host('Bob', backend)}
network.delay = 0
# A <-> B
hosts['alice'].add_connection('Bob')
hosts['bob'].add_connection('Alice')
hosts['alice'].start()
hosts['bob'].start()
for h in hosts.values():
network.add_host(h)
q1 = Qubit(hosts['alice'])
hosts['alice'].send_qubit('Bob', q1, await_ack=True)
q1 = Qubit(hosts['alice'])
hosts['alice'].send_qubit('Bob', q1, await_ack=True)
q1 = Qubit(hosts['alice'])
hosts['alice'].send_qubit('Bob', q1, await_ack=True)
q1 = Qubit(hosts['bob'])
hosts['bob'].send_qubit('Alice', q1, await_ack=True)
network.stop(True)
exit()
def setup_network():
network = Network.get_instance()
network.start()
network.delay = 0.0
host_A = Host('A')
host_A.add_connection('B')
host_A.delay = 0
host_A.start()
host_B = Host('B')
host_B.add_connection('C')
host_B.add_connection('A')
host_B.delay = 0
host_B.start()
host_C = Host('C')
host_C.add_connection('B')
host_C.delay = 0
host_C.start()
network.add_host(host_A)
network.add_host(host_B)
network.add_host(host_C)
return network, host_A, host_B, host_C
def main():
network = Network.get_instance()
# backend = ProjectQBackend()
backend = CQCBackend()
nodes = ['A', 'B', 'C']
network.start(nodes, backend)
network.delay = 0.1
host_A = Host('A', backend)
host_A.add_connection('B')
host_A.delay = 0
host_A.start()
host_B = Host('B', backend)
host_B.add_connections(['A', 'C'])
host_B.delay = 0
host_B.start()
host_C = Host('C', backend)
host_C.add_connection('B')
host_C.delay = 0
host_C.start()
network.add_host(host_A)
network.add_host(host_B)
network.add_host(host_C)
t1 = host_A.run_protocol(protocol_1, (host_C.host_id, ))
t2 = host_C.run_protocol(protocol_2, (host_A.host_id, ))
t1.join()
t2.join()
network.stop(True)
def main():
network = Network.get_instance()
network.start()
host_alice = Host('Alice')
host_bob = Host('Bob')
host_eve = Host('Eve')
host_alice.add_connection('Bob')
host_bob.add_connections(['Alice', 'Eve'])
host_eve.add_connection('Bob')
host_alice.start()
host_bob.start()
host_eve.start()
network.add_host(host_alice)
network.add_host(host_bob)
network.add_host(host_eve)
t1 = host_alice.run_protocol(sender_protocol, ('Eve',))
t2 = host_eve.run_protocol(receiver_protocol, ('Alice',))
t1.join()
t2.join()
network.stop(True)
def main():
network = Network.get_instance()
backend = EQSNBackend()
number_of_entanglement_pairs = 50
nodes = ['A', 'B']
network.start(nodes, backend)
network.delay = 0.1
host_A = Host('A', backend)
host_A.add_connection('B')
host_A.delay = 0
host_A.start()
host_B = Host('B', backend)
host_B.add_connection('A')
host_B.delay = 0
host_B.start()
network.add_host(host_A)
network.add_host(host_B)
t1 = host_A.run_protocol(alice,
(host_B.host_id, number_of_entanglement_pairs))
t2 = host_B.run_protocol(bob,
(host_A.host_id, number_of_entanglement_pairs))
t1.join()
t2.join()
network.stop(True)
def build_network_b92(eve_interception):
network = Network.get_instance()
nodes = ['Alice', 'Bob', 'Eve']
network.start(nodes)
host_alice = Host('Alice')
host_bob = Host('Bob')
host_eve = Host('Eve')
host_alice.add_connection('Eve')
host_eve.add_connections(['Alice', 'Bob'])
host_bob.add_connection('Eve')
# adding the connections - Alice wants to transfer an encrypted message to Bob
# The network looks like this: Alice---Eve---Bob
host_alice.delay = 0.3
host_bob.delay = 0.3
# starting
host_alice.start()
host_bob.start()
host_eve.start()
network.add_hosts([host_alice, host_bob, host_eve])
if eve_interception == True:
host_eve.q_relay_sniffing = True
host_eve.q_relay_sniffing_fn = eve_sniffing_quantum
hosts = [host_alice, host_bob, host_eve]
print('Made a network!')
return network, hosts
def main():
network = Network.get_instance()
nodes = ["Alice", "Bob", "Eve", "Dean"]
back = ProjectQBackend()
network.start(nodes, back)
network.delay = 0.1
host_alice = Host('Alice', back)
host_alice.add_connection('Bob')
host_alice.add_connection('Eve')
host_alice.start()
host_bob = Host('Bob', back)
host_bob.add_connection('Alice')
host_bob.add_connection('Eve')
host_bob.start()
host_eve = Host('Eve', back)
host_eve.add_connection('Bob')
host_eve.add_connection('Dean')
host_eve.add_connection('Alice')
host_eve.start()
host_dean = Host('Dean', back)
host_dean.add_connection('Eve')
host_dean.start()
network.add_host(host_alice)
network.add_host(host_bob)
network.add_host(host_eve)
network.add_host(host_dean)
share_list = ["Bob", "Eve", "Dean"]
q_id1 = host_alice.send_ghz(share_list, no_ack=True)
q1 = host_alice.get_ghz('Alice', q_id1, wait=10)
q2 = host_bob.get_ghz('Alice', q_id1, wait=10)
q3 = host_eve.get_ghz('Alice', q_id1, wait=10)
q4 = host_dean.get_ghz('Alice', q_id1, wait=10)
if q1 is None:
raise ValueError("Q1 is none")
if q2 is None:
raise ValueError("Q2 is none")
if q3 is None:
raise ValueError("Q3 is none")
if q4 is None:
raise ValueError("Q4 is none")
m1 = q1.measure()
m2 = q2.measure()
m3 = q3.measure()
m4 = q4.measure()
print("results of measurements are %d, %d, %d, and %d." % (m1, m2, m3, m4))
network.stop(True)
exit()
def main():
# Initialize a network
network = Network.get_instance()
backend = EQSNBackend()
# Define the host IDs in the network
nodes = ['Alice', 'Bob']
network.delay = 0.0
# Start the network with the defined hosts
network.start(nodes, backend)
# Initialize the host Alice
host_alice = Host('Alice', backend)
# Add a one-way connection (classical and quantum) to Bob
host_alice.add_connection('Bob')
host_alice.delay = 0.0
# Start listening
host_alice.start()
host_bob = Host('Bob', backend)
# Bob adds his own one-way connection to Alice
host_bob.add_connection('Alice')
host_bob.delay = 0.0
host_bob.start()
# Add the hosts to the network
# The network is: Alice <--> Bob
network.add_host(host_alice)
network.add_host(host_bob)
# Generate random key
key_size = 20 # the size of the key in bit
secret_key = np.random.randint(2, size=key_size)
# Concatentate functions
def alice_func(alice):
msg_buff = []
alice_qkd(alice, msg_buff, secret_key, host_bob.host_id)
alice_send_message(alice, secret_key, host_bob.host_id)
def bob_func(eve):
msg_buff = []
eve_key = eve_qkd(eve, msg_buff, key_size, host_alice.host_id)
eve_receive_message(eve, msg_buff, eve_key, host_alice.host_id)
# Run Bob and Alice
t1 = host_alice.run_protocol(alice_func, ())
t2 = host_bob.run_protocol(bob_func, ())
t1.join()
t2.join()
network.stop(True)
def main():
network = Network.get_instance()
nodes = ["Alice", "Bob", "Eve", "Dean"]
back = EQSNBackend()
network.start(nodes, back)
network.delay = 0.1
host_alice = Host('Alice', back)
host_alice.add_connection('Bob')
host_alice.add_connection('Eve')
host_alice.start()
host_bob = Host('Bob', back)
host_bob.add_connection('Alice')
host_bob.add_connection('Eve')
host_bob.start()
host_eve = Host('Eve', back)
host_eve.add_connection('Bob')
host_eve.add_connection('Dean')
host_eve.add_connection('Alice')
host_eve.start()
host_dean = Host('Dean', back)
host_dean.add_connection('Eve')
host_dean.start()
network.add_host(host_alice)
network.add_host(host_bob)
network.add_host(host_eve)
network.add_host(host_dean)
share_list = ["Bob", "Eve", "Dean"]
q_id1, ack_received = host_alice.send_w(share_list, await_ack=True)
print("Alice received ACK from all? " + str(ack_received))
q1 = host_alice.get_w('Alice', q_id1, wait=10)
q2 = host_bob.get_w('Alice', q_id1, wait=10)
q3 = host_eve.get_w('Alice', q_id1, wait=10)
q4 = host_dean.get_w('Alice', q_id1, wait=10)
print("System density matrix:")
print(q1._qubit[0].data)
m1 = q1.measure()
m2 = q2.measure()
m3 = q3.measure()
m4 = q4.measure()
print("\nResults of measurements are %d, %d, %d, %d." % (m1, m2, m3, m4))
network.stop(True)
exit()
def test_add_hosts(self):
network = Network.get_instance()
a = Host('A')
b = Host('B')
c = Host('C')
network.add_hosts([a, b])
self.assertEqual(network.num_hosts, 2)
network.add_host(c)
self.assertEqual(network.num_hosts, 3)
network.stop(True)
def main():
network = Network.get_instance()
nodes = ["Alice", "Bob", "Eve", "Dean"]
network.start(nodes)
network.delay = 0.5
host_alice = Host('Alice')
host_alice.add_connection('Bob')
host_alice.max_ack_wait = 30
host_alice.delay = 0.2
host_alice.start()
host_bob = Host('Bob')
host_bob.max_ack_wait = 30
host_bob.delay = 0.2
host_bob.add_connection('Alice')
host_bob.add_connection('Eve')
host_bob.start()
host_eve = Host('Eve')
host_eve.max_ack_wait = 30
host_eve.delay = 0.2
host_eve.add_connection('Bob')
host_eve.add_connection('Dean')
host_eve.start()
host_dean = Host('Dean')
host_dean.max_ack_wait = 30
host_dean.delay = 0.2
host_dean.add_connection('Eve')
host_dean.start()
network.add_host(host_alice)
network.add_host(host_bob)
network.add_host(host_eve)
network.add_host(host_dean)
network.x_error_rate = 0
network.packet_drop_rate = 0
q_size = 6
checksum_per_qubit = 2
host_alice.run_protocol(checksum_sender, (q_size, host_dean.host_id, checksum_per_qubit))
host_dean.run_protocol(checksum_receiver, (q_size, host_alice.host_id, checksum_per_qubit))
start_time = time.time()
while time.time() - start_time < 150:
pass
network.stop(stop_hosts=True)
exit()
def main():
global thread_1_return
global thread_2_return
network = Network.get_instance()
nodes = ["Alice", "Bob", "Eve", "Dean"]
network.start(nodes)
network.delay = 0.5
host_alice = Host('alice')
host_alice.add_connection('bob')
host_alice.max_ack_wait = 30
host_alice.delay = 0.2
host_alice.start()
host_bob = Host('bob')
host_bob.max_ack_wait = 30
host_bob.delay = 0.2
host_bob.add_connection('alice')
host_bob.add_connection('eve')
host_bob.start()
host_eve = Host('eve')
host_eve.max_ack_wait = 30
host_eve.delay = 0.2
host_eve.add_connection('bob')
host_eve.add_connection('dean')
host_eve.start()
host_dean = Host('dean')
host_dean.max_ack_wait = 30
host_dean.delay = 0.2
host_dean.add_connection('eve')
host_dean.start()
network.add_host(host_alice)
network.add_host(host_bob)
network.add_host(host_eve)
network.add_host(host_dean)
host_alice.run_protocol(retransmission_sender,
(host_dean.host_id, MAX_TRIAL_NUM))
host_dean.run_protocol(retransmission_receiver,
(host_alice.host_id, MAX_TRIAL_NUM))
start_time = time.time()
while time.time() - start_time < 150:
pass
network.stop(stop_hosts=True)
exit()
def main():
# Initialize a network
network = Network.get_instance()
# Define the host IDs in the network
nodes = ['Alice', 'Bob', 'Eve']
network.delay = 0.0
# Start the network with the defined hosts
network.start(nodes)
# Initialize the host Alice
host_alice = Host('Alice')
# Add a one-way connection (classical and quantum) to Bob
host_alice.add_connection('Bob')
# Start listening
host_alice.start()
host_bob = Host('Bob')
# Bob adds his own one-way connection to Alice and Eve
host_bob.add_connection('Alice')
host_bob.add_connection('Eve')
host_bob.start()
host_eve = Host('Eve')
host_eve.add_connection('Bob')
host_eve.start()
# Add the hosts to the network
# The network is: Alice <--> Bob <--> Eve
network.add_host(host_alice)
network.add_host(host_bob)
network.add_host(host_eve)
# Generate random key
key_size = 8 # the size of the key in bit
hosts = {'Alice': host_alice, 'Bob': host_bob, 'Eve': host_eve}
# Run Alice and Eve
host_alice.send_key(host_eve.host_id, key_size)
start_time = time.time()
while time.time() - start_time < 60:
pass
print('SENDER KEYS')
print(host_alice.qkd_keys)
print('RECEIVER KEYS')
print(host_eve.qkd_keys)
for h in hosts.values():
h.stop()
network.stop()
def main():
network = Network.get_instance()
nodes = ["Alice", "Bob", "Eve", "Dean"]
back = EQSNBackend()
network.start(nodes, back)
network.delay = 0.1
host_alice = Host('Alice', back)
host_alice.add_connection('Bob')
host_alice.add_connection('Eve')
host_alice.start()
host_bob = Host('Bob', back)
host_bob.add_connection('Alice')
host_bob.add_connection('Eve')
host_bob.start()
host_eve = Host('Eve', back)
host_eve.add_connection('Bob')
host_eve.add_connection('Dean')
host_eve.add_connection('Alice')
host_eve.start()
host_dean = Host('Dean', back)
host_dean.add_connection('Eve')
host_dean.start()
network.add_host(host_alice)
network.add_host(host_bob)
network.add_host(host_eve)
network.add_host(host_dean)
share_list = ["Bob", "Eve", "Dean"]
q_id1 = host_alice.send_w(share_list, no_ack=True)
q1 = host_alice.get_w('Alice', q_id1, wait=10)
q2 = host_bob.get_w('Alice', q_id1, wait=10)
q3 = host_eve.get_w('Alice', q_id1, wait=10)
q4 = host_dean.get_w('Alice', q_id1, wait=10)
m1 = q1.measure()
m2 = q2.measure()
m3 = q3.measure()
m4 = q4.measure()
print("\nResults of measurements are %d, %d, %d, %d." % (m1, m2, m3, m4))
network.stop(True)
exit()
def test_generate_topology_mesh(self):
network = Network.get_instance()
network.generate_topology(self.sample_list, 'mesh')
for host_name in self.sample_list:
host = network.get_host(host_name)
other_hosts = self.sample_list.copy()
other_hosts.remove(host_name)
self.assertEqual(list(host.quantum_connections.keys()),
other_hosts)
self.assertEqual(list(host.classical_connections.keys()),
other_hosts)
network.stop(stop_hosts=True)
def main():
network = Network.get_instance()
nodes = ["Alice", "Bob", "Eve", "Dean"]
network.start(nodes)
network.delay = 0.1
host_alice = Host('Alice')
host_alice.add_connection('Bob')
host_alice.start()
host_bob = Host('Bob')
host_bob.add_connection('Alice')
host_bob.add_connection('Eve')
host_bob.start()
host_eve = Host('Eve')
host_eve.add_connection('Bob')
host_eve.add_connection('Dean')
host_eve.start()
host_dean = Host('Dean')
host_dean.add_connection('Eve')
host_dean.start()
network.add_host(host_alice)
network.add_host(host_bob)
network.add_host(host_eve)
network.add_host(host_dean)
# Create a qubit owned by Alice
q = Qubit(host_alice)
# Put the qubit in the excited state
q.X()
# Send the qubit and await an ACK from Dean
q_id = host_alice.send_qubit('Dean', q, no_ack=True)
# Get the qubit on Dean's side from Alice
q_rec = host_dean.get_data_qubit('Alice', q_id)
# Ensure the qubit arrived and then measure and print the results.
if q_rec is not None:
m = q_rec.measure()
print("Results of the measurements for q_id are ", str(m))
else:
print('q_rec is none')
network.stop(True)
exit()
def main():
network = Network.get_instance()
nodes = ["Alice", "Bob", "Eve", "Dean"]
network.start(nodes)
network.delay = 0.1
host_alice = Host('Alice')
host_alice.add_connection('Bob')
host_alice.start()
host_bob = Host('Bob')
host_bob.add_connection('Alice')
host_bob.add_connection('Eve')
host_bob.start()
host_eve = Host('Eve')
host_eve.add_connection('Bob')
host_eve.add_connection('Dean')
host_eve.start()
host_dean = Host('Dean')
host_dean.add_connection('Eve')
host_dean.start()
network.add_host(host_alice)
network.add_host(host_bob)
network.add_host(host_eve)
network.add_host(host_dean)
q_id1 = host_alice.send_epr('Dean', no_ack=True)
q1 = host_alice.get_epr('Dean', q_id1)
q2 = host_dean.get_epr('Alice', q_id1)
if q1 is not None and q2 is not None:
m1 = q1.measure()
m2 = q2.measure()
print("Results of the measurements for the entangled pair are %d %d" %
(m1, m2))
else:
if q1 is None:
print('q1 is none')
if q2 is None:
print('q2 is none')
network.stop(True)
exit()
def main():
network = Network.get_instance()
network.delay = 0.1
network.start()
clock = Clock()
controller_host = ControllerHost(
host_id="host_1",
clock=clock,
)
computing_hosts, q_map = controller_host.create_distributed_network(
num_computing_hosts=2, num_qubits_per_host=10)
controller_host.start()
network.add_hosts(
[computing_hosts[0], computing_hosts[1], controller_host])
q_0_0 = Qubit(computing_host_id="QPU_0", q_id="q_0_0")
q_0_1 = Qubit(computing_host_id="QPU_1", q_id="q_0_1")
q_0_0.single(gate=Operation.I)
q_0_0.two_qubit(gate=Operation.CNOT, target_qubit=q_0_1)
q_0_0.measure(bit_id=q_0_0.q_id)
q_0_1.measure(bit_id=q_0_1.q_id)
qubits = [q_0_0, q_0_1]
circuit = Circuit(q_map, qubits=qubits)
def controller_host_protocol(host):
host.generate_and_send_schedules(circuit)
host.receive_results()
print(host.results)
def computing_host_protocol(host):
host.receive_schedule()
host.send_results()
print(host.host_id, host.bits)
print('starting...')
t = controller_host.run_protocol(controller_host_protocol)
computing_hosts[0].run_protocol(computing_host_protocol)
g = computing_hosts[1].run_protocol(computing_host_protocol)
t.join()
g.join()
network.stop(True)
def main():
backend = EQSNBackend()
network = Network.get_instance()
nodes = ["Alice", "Bob", "Eve", "Dean"]
network.start(nodes, backend)
network.delay = 0.7
hosts = {'alice': Host('Alice', backend), 'bob': Host('Bob', backend)}
network.delay = 0
# A <-> B
hosts['alice'].add_connection('Bob')
hosts['bob'].add_connection('Alice')
hosts['alice'].start()
hosts['bob'].start()
for h in hosts.values():
network.add_host(h)
# send messages to Bob without waiting for ACKs
hosts['alice'].send_classical(hosts['bob'].host_id,
'hello bob one',
await_ack=False)
hosts['alice'].send_classical(hosts['bob'].host_id,
'hello bob two',
await_ack=False)
hosts['alice'].send_classical(hosts['bob'].host_id,
'hello bob three',
await_ack=False)
hosts['alice'].send_classical(hosts['bob'].host_id,
'hello bob four',
await_ack=False)
# Wait for all Acks from Bob
hosts['alice'].await_remaining_acks(hosts['bob'].host_id)
saw_ack = [False, False, False, False]
messages = hosts['alice'].classical
for m in messages:
if m.content == Constants.ACK:
saw_ack[m.seq_num] = True
for ack in saw_ack:
assert ack
print("All tests succesfull!")
network.stop(True)
def test_remove_hosts(self):
network = Network.get_instance()
a = Host('A')
b = Host('B')
c = Host('C')
network.add_hosts([a, b, c])
self.assertEqual(network.num_hosts, 3)
network.remove_host(a)
self.assertEqual(network.num_hosts, 2)
network.remove_host(b)
self.assertEqual(network.num_hosts, 1)
network.remove_host(c)
self.assertEqual(network.num_hosts, 0)
network.stop(True)
def setup_network(num_hosts, backend):
network = Network.get_instance()
network.start(nodes=[str(i) for i in range(num_hosts)], backend=backend)
network.delay = 0.0
hosts = []
for i in range(num_hosts):
h = Host(str(i), backend=backend)
h.delay = 0
h.start()
if i < num_hosts - 1:
h.add_connection(str(i + 1))
if i > 0:
h.add_connection(str(i - 1))
hosts.append(h)
network.add_hosts(hosts)
return network, hosts
def test_generate_topology_star(self):
network = Network.get_instance()
non_center_nodes = self.sample_list.copy()
non_center_nodes.remove('A')
network.generate_topology(self.sample_list, 'star')
center_node = network.get_host('A')
self.assertEqual(list(center_node.quantum_connections.keys()),
non_center_nodes)
self.assertEqual(list(center_node.classical_connections.keys()),
non_center_nodes)
for spoke in non_center_nodes:
node = network.get_host(spoke)
self.assertEqual(list(node.quantum_connections.keys()), ['A'])
self.assertEqual(list(node.classical_connections.keys()), ['A'])
network.stop(stop_hosts=True)
