def test_running(self):
qubits = ns.qubits.create_qubits(1)
p = PingPongProtocol(self.node, observable=ns.Z, qubit=qubits[0])
p.start()
self.assertTrue(p.is_running)
self.assertEqual(len(self.node.ports["qubitIO"].output_queue), 1)
ns.sim_run(3)
self.assertTrue(p.is_running)
self.assertEqual(len(self.node.ports["qubitIO"].output_queue), 1)
self.node.ports["qubitIO"].tx_input(qubits[0])
output = self._get_printed_output(ns.sim_run)
expected_output = " 3.0: TestNode measured |0> with probability 1.00\n"
self.assertEqual(output, expected_output)
# Running without qubit should result in no output queue
ns.sim_reset()
node2 = Node(name="TestNode2", port_names=["qubitIO"])
p2 = PingPongProtocol(node2, observable=ns.X)
p2.start()
self.assertTrue(p2.is_running)
self.assertEqual(len(node2.ports["qubitIO"].output_queue), 0)
qubits = ns.qubits.create_qubits(1)
node2.ports["qubitIO"].tx_input(qubits[0])
output = self._get_printed_output(ns.sim_run)
expected_output = " 0.0: TestNode2 measured |-> with probability 0.50\n"
self.assertEqual(output, expected_output)
def Sim(run_times=1, delay=0, depolar_rate=0):
closeness_List = []
for i in range(run_times):
ns.sim_reset()
qc = QuantumCheque(
num_bits=10, C_delay=delay, Money=110,
depolar_rate=depolar_rate) # given arbitrary money value
ns.sim_run()
closeness_List.append(qc.chequeCloseness)
return sum(closeness_List) / len(closeness_List)
def run_BB84_sim(runtimes=1,
num_bits=8,
fibre_len=10**-6,
fibre_loss_init=0.2,
fibre_loss_length=0.25):
MyBB84List = [] #protocol list
for i in range(runtimes):
ns.sim_reset()
#print("The ",i,"th run...")
MyBB84List.append(
BB84(num_bits, fibre_len, fibre_loss_init,
fibre_loss_length).key_B)
ns.sim_run()
return MyBB84List
def main():
# Initialise the simulation.
ns.sim_reset()
distance = 2.74 / 1000 # default unit of length in channels is km
delay_model = PingPongDelayModel()
# Set-up the network.
node_ping = Node("Ping", port_names=["port_to_channel"])
node_pong = Node("Pong", port_names=["port_to_channel"])
connection = DirectConnection(
"Connection",
QuantumChannel(name="qchannel[ping to pong]",
length=distance,
models={"delay_model": delay_model}),
QuantumChannel(name="qchannel[pong to ping]",
length=distance,
models={"delay_model": delay_model}))
node_ping.connect_to(remote_node=node_pong,
connection=connection,
local_port_name="qubitIO",
remote_port_name="qubitIO")
# Assign protocols to the nodes.
qubits = ns.qubits.create_qubits(1)
ping_protocol = PingPongProtocol(node_ping,
observable=ns.Z,
qubit=qubits[0])
pong_protocol = PingPongProtocol(node_pong, observable=ns.X)
# Start the protocols and the simulation.
print("Start the PingPong simulation:\n")
ping_protocol.start()
pong_protocol.start()
stats = ns.sim_run(91)
print(stats)
def run_experiment(fibre_length,
dephase_rate,
key_size,
t_time=None,
runs=100,
q_source_probs=(1., 0.),
loss=(0, 0)):
if t_time is None:
t_time = {'T1': 10001, 'T2': 10000}
global bob_keys, alice_keys
bob_keys = []
alice_keys = []
# ns.logger.setLevel(1)
for _ in range(runs):
ns.sim_reset()
n = TwoPartyNetwork(fibre_length, dephase_rate, key_size, t_time,
q_source_probs, loss).generate_noisy_network()
node_a = n.get_node("alice")
node_b = n.get_node("bob")
p1 = KeySenderProtocol(node_a, key_size=key_size)
p2 = KeyReceiverProtocol(node_b, key_size=key_size)
p1.start()
p2.start()
ns.sim_run()
def keys_match(key1, key2):
if len(key1) != len(key2):
return False
for i in range(len(key1)):
if key1[i] != key2[i]:
return False
return True
_stats = {'MISMATCHED_KEYS': 0, 'MATCHED_KEYS': 0}
for i, bob_key in enumerate(bob_keys):
alice_key = alice_keys[i]
if not keys_match(alice_key, bob_key):
_stats['MISMATCHED_KEYS'] += 1
else:
_stats['MATCHED_KEYS'] += 1
return _stats
def run_simulation(sim_params, attempts, memory_depths):
simulation_data = pandas.DataFrame()
for memory_depth in memory_depths:
ns.sim_reset() # reset simulation stats/time each run
ns.set_qstate_formalism(
QFormalism.DM
) # set formalism to ensure noise/error is calculated accurately
# phys_instructions = [PhysicalInstruction(instr.INSTR_MEASURE_BELL, duration=5.0, parallel=True)] # FIXME: possibly for later use
network = setup_network(
source_attempts=attempts, memory_depth=memory_depth,
**sim_params) # describe network parameters as given in sim_params
source_config = {
'probability_emission': sim_params['probability_emission']
}
if memory_depth == 0: # variable to determine which function to run in RepeaterProtocol
use_memory = False
else:
use_memory = True
memory_config = {
'use_memory': use_memory,
'reset_period_cycles': sim_params['memory_reset_period'],
'reset_duration_cycles': sim_params['memory_reset_duration'],
'probability_detection': sim_params['probability_detection']
}
entangle_sim, dc = sim_setup(network, source_config, memory_config)
entangle_sim.start()
stats = ns.sim_run() # run until out of attempts on source clocks
if dc.dataframe.empty: # build df for case with no successes
data = [{
'Memory Depth': memory_depth,
'num_meas': 0,
'fid_joint': None
}]
df = pandas.DataFrame(data)
else: # build df for each run from data collector
fid_joint = dc.dataframe['fid_joint'].mean() # avg joint fidelity
num_meas = len(
dc.dataframe) # number of measurement events during run
mem_use_A = dc.dataframe['pos_A'].value_counts()
mem_use_B = dc.dataframe['pos_B'].value_counts()
mem_use = mem_use_A.append(
mem_use_B
) # FIXME: for future use, tracking which mem slots are used
data = [{
'Memory Depth': memory_depth,
'num_meas': num_meas,
'fid_joint': fid_joint
}]
df = pandas.DataFrame(data) # pack data on each run in df
simulation_data = simulation_data.append(
df) # append df for each run to simulation data
return simulation_data
# Await response from Bob
yield self.await_port_input(self.node.ports[self.c_port])
kept_indices = self.node.ports[self.c_port].rx_input().items
self.node.ports[self.c_port].tx_output(kept_indices[:-1])
final_key = []
for i in kept_indices[:-1]:
final_key.append(secret_key[i])
self.key = final_key
self.send_signal(signal_label=Signals.SUCCESS, result=final_key)
if __name__ == '__main__':
n = TwoPartyNetwork('net', 0, 0, 10, t_time={'T1': 110, 'T2': 100}, loss=(0, 0)).generate_noisy_network()
node_a = n.get_node("alice")
node_b = n.get_node("bob")
p1 = KeySenderProtocol(node_a, key_size=200)
p2 = KeyReceiverProtocol(node_b, key_size=200)
p1.start()
p2.start()
# ns.logger.setLevel(4)
stats = ns.sim_run()
print(len(p1.key))
print(p1.key)
print(p2.key)
self.observable = observable
self.qubit = qubit
# Define matching pair of strings for pretty printing of basis states:
self.basis = ["|0>", "|1>"] if observable == ns.Z else ["|+>", "|->"]
def run(self):
if self.qubit is not None:
# Send (TX) qubit to the other node via port's output:
self.node.ports["qubitIO"].tx_output(self.qubit)
while True:
# Wait (yield) until input has arrived on our port:
yield self.await_port_input(self.node.ports["qubitIO"])
# Receive (RX) qubit on the port's input:
message = self.node.ports["qubitIO"].rx_input()
qubit = message.items[0]
meas, prob = ns.qubits.measure(qubit, observable=self.observable)
print(f"{ns.sim_time():5.1f}: {self.node.name} measured "
f"{self.basis[meas]} with probability {prob:.2f}")
# Send (TX) qubit to the other node via connection:
self.node.ports["qubitIO"].tx_output(qubit)
qubits = ns.qubits.create_qubits(1)
A_protocol = PingPongProtocol(node_A, observable=ns.Z, qubit=qubits[0])
B_protocol = PingPongProtocol(node_B, observable=ns.X)
A_protocol.start()
B_protocol.start()
run_stats = ns.sim_run(duration=100000)
print(run_stats)
def run_E91_sim(runtimes=1,num_bits=20,fibre_len=10**-9,memNoiseMmodel=None,processorNoiseModel=None
,loss_init=0,loss_len=0,QChV=2.083*10**-4,CChV=2.083*10**-4):
MyE91List_A=[] # local protocol list A
MyE91List_B=[] # local protocol list B
MyKeyRateList=[]
A_originBasisList=[]
B_measureBasisList=[]
for i in range(runtimes):
ns.sim_reset()
# nodes====================================================================
nodeA = Node("Alice", port_names=["portQA_1","portCA_1","portCA_2"])
nodeB = Node("Bob" , port_names=["portQB_1","portCB_1","portCB_2"])
# processors===============================================================
#noise_model=None
Alice_processor=QuantumProcessor("processor_A", num_positions=10**5,
mem_noise_models=memNoiseMmodel, phys_instructions=[
PhysicalInstruction(INSTR_INIT, duration=1, parallel=True),
PhysicalInstruction(INSTR_X, duration=1, q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_Z, duration=1, q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_H, duration=1, q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_CNOT,duration=10,q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_MEASURE, duration=10,q_noise_model=processorNoiseModel, parallel=True),
PhysicalInstruction(INSTR_MEASURE_X, duration=10,q_noise_model=processorNoiseModel, parallel=True)])
Bob_processor=QuantumProcessor("processor_B", num_positions=10**5,
mem_noise_models=memNoiseMmodel, phys_instructions=[
PhysicalInstruction(INSTR_INIT, duration=1, parallel=True),
PhysicalInstruction(INSTR_X, duration=1, q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_Z, duration=1, q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_H, duration=1, q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_CNOT,duration=10,q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_MEASURE, duration=10,q_noise_model=processorNoiseModel, parallel=True),
PhysicalInstruction(INSTR_MEASURE_X, duration=10,q_noise_model=processorNoiseModel, parallel=True)])
# channels==================================================================
MyQChannel=QuantumChannel("QChannel_A->B",delay=10
,length=fibre_len
,models={"quantum_loss_model":
FibreLossModel(p_loss_init=loss_init,p_loss_length=loss_len, rng=None),
"delay_model": FibreDelayModel(c=QChV)})
nodeA.connect_to(nodeB, MyQChannel,
local_port_name =nodeA.ports["portQA_1"].name,
remote_port_name=nodeB.ports["portQB_1"].name)
MyCChannel = ClassicalChannel("CChannel_B->A",delay=0
,length=fibre_len)
MyCChannel2= ClassicalChannel("CChannel_A->B",delay=0
,length=fibre_len)
nodeB.connect_to(nodeA, MyCChannel,
local_port_name="portCB_1", remote_port_name="portCA_1")
nodeA.connect_to(nodeB, MyCChannel2,
local_port_name="portCA_2", remote_port_name="portCB_2")
startTime=ns.sim_time()
#print("startTime:",startTime)
Alice_protocol = AliceProtocol(nodeA,Alice_processor,num_bits)
Bob_protocol = BobProtocol(nodeB,Bob_processor,num_bits)
Bob_protocol.start()
Alice_protocol.start()
#ns.logger.setLevel(1)
stats = ns.sim_run()
'''
endTime=Bob_protocol.endTime
#print("endTime:",endTime)
MyE91List_A.append(Alice_protocol.key)
MyE91List_B.append(Bob_protocol.key)
#simple key length calibration
s = SequenceMatcher(None, Alice_protocol.key, Bob_protocol.key)# unmatched rate
MyKeyRateList.append((len(Bob_protocol.key)*(1-s.ratio()))*10**9/(endTime-startTime)) #second
'''
MyE91List_A.append(Alice_protocol.key)
MyE91List_B.append(Bob_protocol.key)
A_originBasisList.append(Alice_protocol.basisList)
B_measureBasisList.append(Bob_protocol.basisList)
#return MyE91List_A, MyE91List_B, MyKeyRateList
return MyE91List_A, MyE91List_B, A_originBasisList, B_measureBasisList
def run_UBQC_sim(runtimes=1,
fibre_len=10**-9,
processorNoiseModel=None,
memNoiseMmodel=None,
loss_init=0.25,
loss_len=0.2,
QChV=3 * 10**2,
CChV=3 * 10**2):
resList = []
successCount = 0
set_qstate_formalism(QFormalism.DM)
for i in range(runtimes):
ns.sim_reset()
# nodes====================================================================
nodeServer = Node("Server",
port_names=["portQS_1", "portCS_1", "portCS_2"])
nodeClient = Node("Client",
port_names=["portQC_1", "portCC_1", "portCC_2"])
# processors===============================================================
processorServer = QuantumProcessor(
"processorServer",
num_positions=10,
mem_noise_models=memNoiseMmodel,
phys_instructions=[
PhysicalInstruction(INSTR_X,
duration=1,
q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_Z,
duration=1,
q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_H,
duration=1,
q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_CNOT,
duration=1,
q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_CZ,
duration=10,
q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_MEASURE, duration=10, parallel=True),
PhysicalInstruction(INSTR_MEASURE_X,
duration=10,
parallel=True),
PhysicalInstruction(INSTR_R22, duration=1, parallel=True),
PhysicalInstruction(INSTR_R45, duration=1, parallel=True),
PhysicalInstruction(INSTR_R67, duration=1, parallel=True),
PhysicalInstruction(INSTR_R90, duration=1, parallel=True),
PhysicalInstruction(INSTR_R112, duration=1, parallel=True),
PhysicalInstruction(INSTR_R135, duration=1, parallel=True),
PhysicalInstruction(INSTR_R157, duration=1, parallel=True),
PhysicalInstruction(INSTR_R180, duration=1, parallel=True),
PhysicalInstruction(INSTR_R202, duration=1, parallel=True),
PhysicalInstruction(INSTR_R225, duration=1, parallel=True),
PhysicalInstruction(INSTR_R247, duration=1, parallel=True),
PhysicalInstruction(INSTR_R270, duration=1, parallel=True),
PhysicalInstruction(INSTR_R292, duration=1, parallel=True),
PhysicalInstruction(INSTR_R315, duration=1, parallel=True),
PhysicalInstruction(INSTR_R337, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv22, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv45, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv67, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv90, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv112, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv135, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv157, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv180, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv202, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv225, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv247, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv270, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv292, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv315, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv337, duration=1, parallel=True),
PhysicalInstruction(INSTR_SWAP, duration=1, parallel=True)
])
processorClient = QuantumProcessor(
"processorClient",
num_positions=10,
mem_noise_models=memNoiseMmodel,
phys_instructions=[
PhysicalInstruction(INSTR_X,
duration=1,
q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_Z,
duration=1,
q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_H,
duration=1,
q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_CNOT,
duration=10,
q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_MEASURE, duration=10, parallel=True),
PhysicalInstruction(INSTR_MEASURE_X,
duration=10,
parallel=True),
PhysicalInstruction(INSTR_R22, duration=1, parallel=True),
PhysicalInstruction(INSTR_R45, duration=1, parallel=True),
PhysicalInstruction(INSTR_R67, duration=1, parallel=True),
PhysicalInstruction(INSTR_R90, duration=1, parallel=True),
PhysicalInstruction(INSTR_R112, duration=1, parallel=True),
PhysicalInstruction(INSTR_R135, duration=1, parallel=True),
PhysicalInstruction(INSTR_R157, duration=1, parallel=True),
PhysicalInstruction(INSTR_R180, duration=1, parallel=True),
PhysicalInstruction(INSTR_R202, duration=1, parallel=True),
PhysicalInstruction(INSTR_R225, duration=1, parallel=True),
PhysicalInstruction(INSTR_R247, duration=1, parallel=True),
PhysicalInstruction(INSTR_R270, duration=1, parallel=True),
PhysicalInstruction(INSTR_R292, duration=1, parallel=True),
PhysicalInstruction(INSTR_R315, duration=1, parallel=True),
PhysicalInstruction(INSTR_R337, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv22, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv45, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv67, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv90, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv112, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv135, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv157, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv180, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv202, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv225, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv247, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv270, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv292, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv315, duration=1, parallel=True),
PhysicalInstruction(INSTR_Rv337, duration=1, parallel=True)
])
# channels==================================================================
MyQChannel = QuantumChannel("QChannel_S->C",
delay=0,
length=fibre_len,
models={
"quantum_loss_model":
FibreLossModel(p_loss_init=loss_init,
p_loss_length=loss_len,
rng=None),
"delay_model":
FibreDelayModel(c=QChV)
})
nodeServer.connect_to(
nodeClient,
MyQChannel,
local_port_name=nodeServer.ports["portQS_1"].name,
remote_port_name=nodeClient.ports["portQC_1"].name)
MyCChannel = ClassicalChannel("CChannel_C->S",
delay=0,
length=fibre_len)
MyCChannel2 = ClassicalChannel("CChannel_S->C",
delay=0,
length=fibre_len)
nodeClient.connect_to(nodeServer,
MyCChannel,
local_port_name="portCC_1",
remote_port_name="portCS_1")
nodeServer.connect_to(nodeClient,
MyCChannel2,
local_port_name="portCS_2",
remote_port_name="portCC_2")
protocolServer = ProtocolServer(nodeServer, processorServer)
protocolClient = ProtocolClient(nodeClient, processorClient, 1)
protocolServer.start()
protocolClient.start()
#ns.logger.setLevel(1)
stats = ns.sim_run()
resList.append(protocolClient.verified)
for i in resList:
if i == True:
successCount += 1
return successCount / runtimes
def run_E91_sim(runtimes=1, num_bits=20, fibre_len=10**-9, noise_model=None):
MyE91List_A = [] # local protocol list A
MyE91List_B = [] # local protocol list B
for i in range(runtimes):
ns.sim_reset()
# Hardware configuration
Alice_processor = sendableQProcessor(
"processor_A",
num_positions=100,
mem_noise_models=None,
phys_instructions=[
PhysicalInstruction(INSTR_INIT, duration=1, parallel=True),
PhysicalInstruction(INSTR_X,
duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_Z,
duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_H,
duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_CNOT,
duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_MEASURE, duration=1, parallel=True)
],
topologies=[None, None, None, None, None, None])
#mem_noise_models=[DepolarNoiseModel(0)] * 100
Bob_processor = sendableQProcessor(
"processor_B",
num_positions=100,
mem_noise_models=None,
phys_instructions=[
PhysicalInstruction(INSTR_INIT, duration=1, parallel=True),
PhysicalInstruction(INSTR_X,
duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_Z,
duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_H,
duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_CNOT,
duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_MEASURE, duration=1, parallel=True)
],
topologies=[None, None, None, None, None, None])
node_A = Node("A",
ID=0,
port_names=["portQA_1", "portCA_1", "portCA_2"])
node_B = Node("B",
ID=1,
port_names=["portQB_1", "portCB_1", "portCB_2"])
# connection
MyQfiber = QuantumFibre("QFibre_A->B",
length=fibre_len,
quantum_loss_model=None)
# default value:
# p_loss_init=0.2, p_loss_length=0.25,depolar_rate=0, c=200000, models=None
MyCfiber = DirectConnection(
"CFibreConn_B->A", ClassicalFibre("CFibre_B->A", length=fibre_len))
MyCfiber2 = DirectConnection(
"CFibreConn_A->B", ClassicalFibre("CFibre_A->B", length=fibre_len))
node_A.connect_to(node_B,
MyQfiber,
local_port_name=node_A.ports["portQA_1"].name,
remote_port_name=node_B.ports["portQB_1"].name)
node_B.connect_to(node_A,
MyCfiber,
local_port_name="portCB_1",
remote_port_name="portCA_1")
node_A.connect_to(node_B,
MyCfiber2,
local_port_name="portCA_2",
remote_port_name="portCB_2")
Alice = E91_A(node=node_A,
processor=Alice_processor,
num_bits=num_bits,
portNameQ1="portQA_1",
portNameC1="portCA_1",
portNameC2="portCA_2")
Bob = E91_B(node=node_B,
processor=Bob_processor,
num_bits=num_bits,
portNameQ1="portQB_1",
portNameC1="portCB_1",
portNameC2="portCB_2")
for i in Alice.A_prepare_qubits():
pass
ns.sim_run()
MyE91List_A.append(Alice.key)
MyE91List_B.append(Bob.key)
return MyE91List_A, MyE91List_B
board_size = int(input("Enter the size of the Main Memory: "))
#Building the network
network = board_network(board_size)
#Get the ports from connections
classical_ports_tm0 = network.get_connected_ports('TaskMasterNode', 'PlayerZeroNode', 'TMP0')
classical_ports_tm1 = network.get_connected_ports('TaskMasterNode', 'PlayerOneNode', 'TMP1')
quantum_ports_tm0 = network.get_connected_ports('TaskMasterNode', 'PlayerZeroNode', 'QTMP0')
quantum_ports_tm1 = network.get_connected_ports('TaskMasterNode', 'PlayerOneNode', 'QTMP1')
#Initialize Nodes with Protocols
protocols = TaskMasterProtocol(network.nodes['TaskMasterNode'], board_size, classical_ports_tm0[0], quantum_ports_tm0[0], classical_ports_tm1[0], quantum_ports_tm1[0]).start()
playerZero = PlayerProtocol(0, board_size, quantum_ports_tm0[1], classical_ports_tm0[1], network.nodes['PlayerZeroNode']).start()
playerOne = PlayerProtocol(1, board_size, quantum_ports_tm1[1], classical_ports_tm1[1], network.nodes['PlayerOneNode']).start()
ns.sim_run()
print("Game finished. All moves played. Take a look at the measurements of the board.")
score = 0
for i in range(board_size):
a = network.nodes['TaskMasterNode'].qmemory.measure(i)
score += a[0][0] * a[1][0]
print(a)
print("The score is ", score)
if score < board_size/2:
print("Player Zero Wins")
else:
print("Player One Wins")
def run_QLine_sim(I,
T,
maxKeyLen=1,
fibreLen=10**-3,
memNoise=None,
noise_model=None,
lossInd=0.2,
lossLen=0.25):
# Hardware configuration
processorA = sendableQProcessor(
"processor_A",
num_positions=2,
mem_noise_models=memNoise,
phys_instructions=[
PhysicalInstruction(INSTR_INIT, duration=1, parallel=True),
PhysicalInstruction(INSTR_X, duration=2,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_H, duration=2,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_MEASURE,
duration=5,
q_noise_model=noise_model,
parallel=True)
])
#mem_noise_models=[DepolarNoiseModel(0)] * 100
processorB = sendableQProcessor(
"processor_B",
num_positions=2,
mem_noise_models=memNoise,
phys_instructions=[
PhysicalInstruction(INSTR_INIT, duration=1, parallel=True),
PhysicalInstruction(INSTR_X, duration=2,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_H, duration=2,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_MEASURE,
duration=5,
q_noise_model=noise_model,
parallel=True)
])
processorC = sendableQProcessor(
"processor_C",
num_positions=2,
mem_noise_models=memNoise,
phys_instructions=[
PhysicalInstruction(INSTR_INIT, duration=1, parallel=True),
PhysicalInstruction(INSTR_X, duration=2,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_H, duration=2,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_MEASURE,
duration=5,
q_noise_model=noise_model,
parallel=True)
])
processorD = sendableQProcessor(
"processor_D",
num_positions=2,
mem_noise_models=memNoise,
phys_instructions=[
PhysicalInstruction(INSTR_INIT, duration=1, parallel=True),
PhysicalInstruction(INSTR_X, duration=2,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_H, duration=2,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_MEASURE,
duration=5,
q_noise_model=noise_model,
parallel=True)
])
processorE = sendableQProcessor(
"processor_E",
num_positions=2,
mem_noise_models=memNoise,
phys_instructions=[
PhysicalInstruction(INSTR_INIT, duration=1, parallel=True),
PhysicalInstruction(INSTR_X, duration=2,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_H, duration=2,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_MEASURE,
duration=5,
q_noise_model=noise_model,
parallel=True)
])
node_A = Node("A", ID=0)
node_B = Node("B", ID=1)
node_C = Node("C", ID=2)
node_D = Node("D", ID=3)
#node_E = Node("E",ID=4)
nodeList = [node_A, node_B, node_C, node_D]
processorList = [processorA, processorB, processorC, processorD]
keyListI = [] # key for I, length unknown
keyListT = [] # key for T, length unknown
totalTime = 0.0
errorTimes = 0
for i in range(maxKeyLen):
ns.sim_reset()
myQLine = QLine(nodeList=nodeList,
processorList=processorList,
fibreLen=fibreLen,
initNodeID=I,
targetNodeID=T,
lossInd=lossInd,
lossLen=lossLen)
myQLine.start()
ns.sim_run()
if myQLine.keyI == myQLine.keyT and myQLine.keyI != None:
keyListI.append(myQLine.keyI)
keyListT.append(myQLine.keyT)
totalTime += myQLine.TimeD
elif myQLine.keyI != myQLine.keyT:
errorTimes += 1
#print(myQLine.keyI)
#print(myQLine.keyT)
return keyListI, keyListT, totalTime #,errorTimes
def run_QToken_sim(runTimes=1,
num_bits=100,
fibre_len=0,
waitTime=1,
processNoiseModel=None,
memNoiseModel=None,
loss_init=0,
loss_len=0,
threshold=0.854,
fibreLoss_init=0.2,
fibreLoss_len=0.25,
QChDelay=1,
CChDelay=0):
resList = []
for i in range(runTimes):
ns.sim_reset()
# nodes====================================================================
nodeA = Node("Alice", port_names=["portQA_1", "portCA_1", "portCA_2"])
nodeB = Node("Bob", port_names=["portQB_1", "portCB_1", "portCB_2"])
# processors===============================================================
#noise_model=None
Alice_processor = QuantumProcessor(
"processor_A",
num_positions=3 * 10**3,
mem_noise_models=memNoiseModel,
phys_instructions=[
PhysicalInstruction(INSTR_X,
duration=1,
q_noise_model=processNoiseModel),
PhysicalInstruction(INSTR_Z,
duration=1,
q_noise_model=processNoiseModel),
PhysicalInstruction(INSTR_H,
duration=1,
q_noise_model=processNoiseModel),
PhysicalInstruction(INSTR_CNOT,
duration=10,
q_noise_model=processNoiseModel),
PhysicalInstruction(INSTR_MEASURE,
duration=10,
q_noise_model=processNoiseModel,
parallel=True),
PhysicalInstruction(INSTR_MEASURE_X,
duration=10,
q_noise_model=processNoiseModel,
parallel=True)
])
Bob_processor = QuantumProcessor(
"processor_B",
num_positions=3 * 10**3,
mem_noise_models=memNoiseModel,
phys_instructions=[
PhysicalInstruction(INSTR_X,
duration=1,
q_noise_model=processNoiseModel),
PhysicalInstruction(INSTR_Z,
duration=1,
q_noise_model=processNoiseModel),
PhysicalInstruction(INSTR_H,
duration=1,
q_noise_model=processNoiseModel),
PhysicalInstruction(INSTR_CNOT,
duration=10,
q_noise_model=processNoiseModel),
PhysicalInstruction(INSTR_MEASURE,
duration=10,
q_noise_model=processNoiseModel,
parallel=True),
PhysicalInstruction(INSTR_MEASURE_X,
duration=10,
q_noise_model=processNoiseModel,
parallel=True)
])
# channels==================================================================
MyQChannel = QuantumChannel("QChannel_B->A",
delay=QChDelay,
length=fibre_len,
models={
"myFibreLossModel":
FibreLossModel(
p_loss_init=fibreLoss_init,
p_loss_length=fibreLoss_len,
rng=None)
})
nodeB.connect_to(nodeA,
MyQChannel,
local_port_name=nodeB.ports["portQB_1"].name,
remote_port_name=nodeA.ports["portQA_1"].name)
MyCChannel = ClassicalChannel("CChannel_A->B",
delay=CChDelay,
length=fibre_len)
MyCChannel2 = ClassicalChannel("CChannel_B->A",
delay=CChDelay,
length=fibre_len)
nodeA.connect_to(nodeB,
MyCChannel,
local_port_name="portCA_1",
remote_port_name="portCB_1")
nodeB.connect_to(nodeA,
MyCChannel2,
local_port_name="portCB_2",
remote_port_name="portCA_2")
Alice_protocol = AliceProtocol(nodeA,
Alice_processor,
num_bits,
waitTime=waitTime)
Bob_protocol = BobProtocol(nodeB,
Bob_processor,
num_bits,
threshold=threshold)
Bob_protocol.start()
Alice_protocol.start()
#ns.logger.setLevel(1)
stats = ns.sim_run()
resList.append(Bob_protocol.successfulRate)
#print("Bob_protocol.successfulRate:",Bob_protocol.successfulRate)
return sum(resList) / len(resList)
def run_AT_sim(numNodes=4,fibre_len=10**-9,processorNoiseModel=None,memNoiseMmodel=None,loss_init=0,loss_len=0
,QChV=3*10**-4):
# initialize
ns.sim_reset()
sideProcessorList=[]
sideNodeList=[]
centerPortList=[]
channelList=[]
senderID=randint(0,numNodes-1)
receiverID=randint(0,numNodes-1)
while receiverID==senderID:
receiverID=randint(0,numNodes-1)
# build star network hardware components
## create side components
for i in range(numNodes):
### processors================================================================
sideProcessorList.append(createProcessorAT(name="ProcessorSide_"+str(i)))
### nodes=====================================================================
sideNodeList.append(Node("node_"+str(i), port_names=["portQside"]))
### channels==================================================================
channelList.append(QuantumChannel("QChannel_Center->Side_"+str(i),delay=10,length=fibre_len
,models={"quantum_loss_model":
FibreLossModel(p_loss_init=loss_init,p_loss_length=loss_len, rng=None),
"delay_model": FibreDelayModel(c=QChV)}))
### record port list for center node
centerPortList.append("PortQCenter_"+str(i))
## create center component
CenterNode=Node("CenterNode", port_names=centerPortList)
CenterProcessor=createProcessorAT(name="ProcessorCenter")
## connect==================================================================
for i in range(numNodes):
CenterNode.connect_to(sideNodeList[i], channelList[i],
local_port_name =CenterNode.ports["PortQCenter_"+str(i)].name,
remote_port_name=sideNodeList[i].ports["portQside"].name)
# create protocol object
myProtocol_center = AT_Wstate_center(CenterNode,CenterProcessor,numNodes,portQlist=centerPortList)
myProtocol_sideList=[]
## create side protocol
for i in range(numNodes):
if i==senderID:
# create sender
myProtocol_sideList.append(AT_Wstate_side(sideNodeList[i],sideProcessorList[i], sender=True))
elif i==receiverID:
# create receiver
myProtocol_sideList.append(AT_Wstate_side(sideNodeList[i],sideProcessorList[i],receiver=True))
else:
# create normal side node
myProtocol_sideList.append(AT_Wstate_side(sideNodeList[i],sideProcessorList[i]))
for sideProtocols in myProtocol_sideList:
sideProtocols.start()
myProtocol_center.start()
#ns.logger.setLevel(1)
stats = ns.sim_run()
def run_UBQC_sim(runtimes=1,
num_bits=20,
fibre_len=10**-9,
noise_model=None,
loss_init=0,
loss_len=0):
ns.sim_reset()
# nodes====================================================================
nodeA = Node("Alice", port_names=["portQA_1", "portCA_1", "portCA_2"])
nodeB = Node("Bob", port_names=["portQB_1", "portCB_1", "portCB_2"])
# processors===============================================================
Alice_processor = sendableQProcessor(
"processor_A",
num_positions=5,
mem_noise_models=None,
phys_instructions=[
PhysicalInstruction(INSTR_INIT, duration=1, parallel=True),
PhysicalInstruction(INSTR_X, duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_Z, duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_H, duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_CNOT,
duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_MEASURE, duration=1, parallel=True),
PhysicalInstruction(INSTR_MEASURE_X, duration=1, parallel=True)
])
Bob_processor = sendableQProcessor(
"processor_B",
num_positions=100,
mem_noise_models=None,
phys_instructions=[
PhysicalInstruction(INSTR_INIT, duration=1, parallel=True),
PhysicalInstruction(INSTR_X, duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_Z, duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_H, duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_CNOT,
duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_MEASURE, duration=1, parallel=True),
PhysicalInstruction(INSTR_MEASURE_X, duration=1, parallel=True)
])
# fibres==================================================================
MyQfiber = QuantumFibre("QFibre_A->B",
length=fibre_len,
quantum_loss_model=None,
p_loss_init=loss_init,
p_loss_length=loss_len)
nodeA.connect_to(nodeB,
MyQfiber,
local_port_name=nodeA.ports["portQA_1"].name,
remote_port_name=nodeB.ports["portQB_1"].name)
MyCfiber = DirectConnection(
"CFibreConn_B->A", ClassicalFibre("CFibre_B->A", length=fibre_len))
MyCfiber2 = DirectConnection(
"CFibreConn_A->B", ClassicalFibre("CFibre_A->B", length=fibre_len))
nodeB.connect_to(nodeA,
MyCfiber,
local_port_name="portCB_1",
remote_port_name="portCA_1")
nodeA.connect_to(nodeB,
MyCfiber2,
local_port_name="portCA_2",
remote_port_name="portCB_2")
Alice = ClientProtocol(nodeA, Alice_processor, 2, 2)
BOb = ServerProtocol(nodeB, Bob_processor, 2, 2)
Alice.start()
BOb.start()
#ns.logger.setLevel(1)
ns.sim_run()
def QuantumMem_plot():
x_axis=[]
y_axis=[]
num_bits=1
timeIND=False
min_time=0
max_time=7000000 #ns
#first line
depolar_rate=1000
for i in range(min_time,max_time,50000):
ns.sim_reset()
x_axis.append(i/1000)
Qt=QMemoryDelay(num_bits=num_bits,depolar_rate=depolar_rate,delay=i)
ns.sim_run()
y_axis.append(Qt.qList[0].qstate.dm[1][1].real) # only take the first qubit from DM
# and take the probability of bit flip
plt.plot(x_axis, y_axis, 'go-',label='depolar rate = 1000')
#second line
x_axis.clear()
y_axis.clear()
depolar_rate=500
for i in range(min_time,max_time,50000):
ns.sim_reset()
x_axis.append(i/1000)
Qt2=QMemoryDelay(num_bits=num_bits,depolar_rate=depolar_rate,delay=i)
ns.sim_run()
y_axis.append(Qt2.qList[0].qstate.dm[1][1].real)
plt.plot(x_axis, y_axis, 'bo-',label='depolar rate = 500')
# 3rd line
x_axis.clear()
y_axis.clear()
depolar_rate=50
for i in range(min_time,max_time,50000):
ns.sim_reset()
x_axis.append(i/1000)
Qt3=QMemoryDelay(num_bits=num_bits,depolar_rate=depolar_rate,delay=i)
ns.sim_run()
y_axis.append(Qt3.qList[0].qstate.dm[1][1].real)
plt.plot(x_axis, y_axis, 'ro-',label='depolar rate = 50')
plt.title('Depolar Noise Effects on qubits')
plt.ylabel('average qubit error rate ')
plt.xlabel('time stayed in quantum memory (μs)')
plt.legend()
plt.savefig('QMem.png')
plt.show()
def __call__(self, ):
stats = ns.sim_run()
return stats
def run_E91_sim(runtimes=1,
num_bits=20,
fibre_len=10**-9,
noise_model=None,
loss_init=0,
loss_len=0):
MyE91List_A = [] # local protocol list A
MyE91List_B = [] # local protocol list B
for i in range(runtimes):
ns.sim_reset()
# nodes====================================================================
nodeA = Node("Alice", port_names=["portQA_1", "portCA_1", "portCA_2"])
nodeB = Node("Bob", port_names=["portQB_1", "portCB_1", "portCB_2"])
# processors====================================================================
noise_model = None
Alice_processor = sendableQProcessor(
"processor_A",
num_positions=100,
mem_noise_models=None,
phys_instructions=[
PhysicalInstruction(INSTR_INIT, duration=1, parallel=True),
PhysicalInstruction(INSTR_X,
duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_Z,
duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_H,
duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_CNOT,
duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_MEASURE, duration=1, parallel=True),
PhysicalInstruction(INSTR_MEASURE_X, duration=1, parallel=True)
])
Bob_processor = sendableQProcessor(
"processor_B",
num_positions=100,
mem_noise_models=None,
phys_instructions=[
PhysicalInstruction(INSTR_INIT, duration=1, parallel=True),
PhysicalInstruction(INSTR_X,
duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_Z,
duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_H,
duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_CNOT,
duration=1,
q_noise_model=noise_model),
PhysicalInstruction(INSTR_MEASURE, duration=1, parallel=True),
PhysicalInstruction(INSTR_MEASURE_X, duration=1, parallel=True)
])
# fibres=======================================================================
MyQfiber = QuantumFibre("QFibre_A->B",
length=fibre_len,
quantum_loss_model=None,
p_loss_init=loss_init,
p_loss_length=loss_len)
nodeA.connect_to(nodeB,
MyQfiber,
local_port_name=nodeA.ports["portQA_1"].name,
remote_port_name=nodeB.ports["portQB_1"].name)
MyCfiber = DirectConnection(
"CFibreConn_B->A", ClassicalFibre("CFibre_B->A", length=fibre_len))
MyCfiber2 = DirectConnection(
"CFibreConn_A->B", ClassicalFibre("CFibre_A->B", length=fibre_len))
nodeB.connect_to(nodeA,
MyCfiber,
local_port_name="portCB_1",
remote_port_name="portCA_1")
nodeA.connect_to(nodeB,
MyCfiber2,
local_port_name="portCA_2",
remote_port_name="portCB_2")
Alice_protocol = AliceProtocol(nodeA, Alice_processor, num_bits)
Bob_protocol = BobProtocol(nodeB, Bob_processor, num_bits)
Alice_protocol.start()
Bob_protocol.start()
#ns.logger.setLevel(1)
stats = ns.sim_run()
MyE91List_A.append(Alice_protocol.key)
MyE91List_B.append(Bob_protocol.key)
return MyE91List_A, MyE91List_B
def run_Teleport_sim(runtimes=1,
fibre_len=10**-9,
memNoiseMmodel=None,
processorNoiseModel=None,
loss_init=0,
loss_len=0,
QChV=3 * 10**-4,
CChV=3 * 10**-4):
for i in range(runtimes):
ns.sim_reset()
# nodes====================================================================
nodeSender = Node("SenderNode", port_names=["portC_Sender"])
nodeReceiver = Node("ReceiverNode", port_names=["portC_Receiver"])
# processors===============================================================
processorSender = QuantumProcessor(
"processorSender",
num_positions=10,
mem_noise_models=memNoiseMmodel,
phys_instructions=[
PhysicalInstruction(INSTR_X,
duration=1,
q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_Z,
duration=1,
q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_H,
duration=1,
q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_CNOT,
duration=10,
q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_MEASURE,
duration=10,
q_noise_model=processorNoiseModel,
parallel=False)
])
processorReceiver = QuantumProcessor(
"processorReceiver",
num_positions=10,
mem_noise_models=memNoiseMmodel,
phys_instructions=[
PhysicalInstruction(INSTR_X,
duration=1,
q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_Z,
duration=1,
q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_H,
duration=1,
q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_CNOT,
duration=10,
q_noise_model=processorNoiseModel),
PhysicalInstruction(INSTR_MEASURE,
duration=10,
q_noise_model=processorNoiseModel,
parallel=False)
])
# channels==================================================================
MyCChannel = ClassicalChannel("CChannel_S->R",
delay=0,
length=fibre_len)
nodeSender.connect_to(nodeReceiver,
MyCChannel,
local_port_name="portC_Sender",
remote_port_name="portC_Receiver")
# make an EPR pair and origin state
oriQubit, epr1, epr2 = create_qubits(3)
operate(epr1, H)
operate([epr1, epr2], CNOT)
# make oriQubit
operate(oriQubit, H)
myQT_Sender = QuantumTeleportationSender(node=nodeSender,
processor=processorSender,
SendQubit=oriQubit,
EPR_1=epr1)
myQT_Receiver = QuantumTeleportationReceiver(
node=nodeReceiver, processor=processorReceiver, EPR_2=epr2)
myQT_Receiver.start()
myQT_Sender.start()
#ns.logger.setLevel(1)
stats = ns.sim_run()
return 0
