def __init__(self, num_bits=8, fibre_len=10**-6, fibre_loss_init=0.2, fibre_loss_length=0.25): #,fibreLossModel=default super().__init__() self.node_A = Node("A", ID=0, port_names=["portQA", "portCA"]) self.node_B = Node("B", ID=1, port_names=["portQB", "portCB"]) self.MyQfiber = None self.MyCfiber = None self.num_bits = num_bits self.stateList = None self.res_measure = None self.key_A = [] self.key_B = [] self.fiberLenth = fibre_len self.fibre_loss_init = fibre_loss_init self.fibre_loss_length = fibre_loss_length self.start()
def __init__(self, num_bits=8, fibre_len=10**-6): super().__init__() self.node_A = Node("A", ID=0, port_names=["portQA", "portCA_1", "portCA_2"]) self.node_B = Node("B", ID=1, port_names=["portQB", "portCB_1", "portCB_2"]) self.MyQfiber = None self.MyCfiber = None self.num_bits = num_bits self.qListA = [] self.qListB = [] self.basisList_A = [] self.basisList_B = [] self.res_measure_A = [] self.res_measure_B = [] self.key_A = [] self.key_B = [] self.fiberLenth = fibre_len self.start()
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_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()
class BB84(Protocol): #BB84 functions=========================================================== def BB84_Alice_sendQubits(self): self.stateList, qlist = Create_random_qubits(self.num_bits) self.node_A.ports["portQA"].tx_output(qlist) def BB84_Bob_measure_send(self, qlist): # some qubits might be lost qlist = qlist.items if not isinstance( qlist[0], ns.qubits.qubit.Qubit): #case of not receiving qubits pass else: # B measuring B_basis, self.res_measure = Random_ZX_measure(self.num_bits, qlist) if B_basis[0] == 0 or B_basis[0] == 1 or B_basis[0] == 2: # B send measurement self.node_B.ports["portCB"].tx_output(B_basis) else: print("B measuring failed!!") print(B_basis[0]) def BB84_Alice_measure_send_keygen(self, opList): # A measuring matchList = Compare_measurement(self.num_bits, self.stateList, opList.items) #get opList from B # A return matchList to B self.node_A.ports["portCA"].tx_output(matchList) for i in matchList: self.key_A.append(self.stateList[i] % 2) #quantum state 0,+:0 1,-:1 return self.key_A def BB84_Bob_keygen(self, matchList): for i in matchList.items: self.key_B.append(self.res_measure[int(i)][0]) return self.key_B #control functions=========================================================== def __init__(self, num_bits=8, fibre_len=10**-6, fibre_loss_init=0.2, fibre_loss_length=0.25): #,fibreLossModel=default super().__init__() self.node_A = Node("A", ID=0, port_names=["portQA", "portCA"]) self.node_B = Node("B", ID=1, port_names=["portQB", "portCB"]) self.MyQfiber = None self.MyCfiber = None self.num_bits = num_bits self.stateList = None self.res_measure = None self.key_A = [] self.key_B = [] self.fiberLenth = fibre_len self.fibre_loss_init = fibre_loss_init self.fibre_loss_length = fibre_loss_length self.start() def stop(self): super().stop() self._running = False def is_connected(): super().is_connected() pass def start(self): super().start() # connect and connect quantum fibres self.MyQfiber = QuantumFibre("QFibre_A->B", length=self.fiberLenth, loss_model=FibreLossModel( p_loss_length=self.fibre_loss_length, p_loss_init=self.fibre_loss_init), depolar_rate=0) # create classical fibre self.MyCfiber = DirectConnection( "CFibreConn_A->B", ClassicalFibre("CFibre_A->B", length=self.fiberLenth), ClassicalFibre("CFibre_B->A", length=self.fiberLenth)) self.node_A.connect_to(self.node_B, self.MyQfiber, local_port_name="portQA", remote_port_name="portQB") self.node_B.connect_to(self.node_A, self.MyCfiber, local_port_name="portCB", remote_port_name="portCA") #set callback functions=================================================== self.node_B.ports["portQB"].bind_input_handler( self.BB84_Bob_measure_send) self.node_A.ports["portCA"].bind_input_handler( self.BB84_Alice_measure_send_keygen) self.node_B.ports["portCB"].bind_input_handler(self.BB84_Bob_keygen) # Alice starts====================================================== self.BB84_Alice_sendQubits()
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 __init__(self, num_bits=8, fibre_len_AC=10**-6, fibre_len_AB=10**-6, fibre_len_BC=10**-6, Money=1234, depolar_rate=0, time_independent=False, Threshold=0.99, C_delay=0): super().__init__() self.node_A = Node("A", ID=0, port_names=[ "portQ_A1", "portC_A1", "portC_A2", "portQ_A2", "portC_A3" ]) self.node_B = Node("B", ID=1, port_names=[ "portQ_B1", "portC_B1", "portC_B2", "portQ_B2", "portC_B3" ]) self.node_C = Node("C", ID=2, port_names=["portQ_C1", "portQ_C2"]) self.C_Qmemory = QuantumMemory( "C_QMemory", num_bits, ID=0, memory_noise_models=DepolarNoiseModel( depolar_rate=depolar_rate, time_independent=time_independent) ) #normally time_independent is False unless using probability self.C_delay = C_delay self.MyQfiber_AC = None self.MyQfiber_AB = None self.MyQfiber_BC = None self.MyCfiber_AB = None self.MyCfiber_BA = None self.fiberLenth_AC = fibre_len_AC self.fiberLenth_AB = fibre_len_AB self.fiberLenth_BC = fibre_len_BC self.num_bits = num_bits self.A1ChequeBook = [] self.A2ChequeBook = [] self.BChequeBook = [] self.A_saveUSN = [] #unique serial number stored in A self.B_saveUSN = [] #unique serial number stored in B self.key_BB84_A = [] self.key_BB84_B = [] self.Money = Money self.Threshold = Threshold #Threshold of closeness about whether to accept this cheque self.chequeCloseness = 0 self.Varify = False # True = cheque accepted, False = cheque denied self.start()
class QuantumCheque(Protocol): # QuantumCheque function ========================================================= def BA_BB84_keygen(self, num_bits=8, fibre_len=10**-6, fibre_loss_init=0, fibre_loss_length=0): loc_BB84 = BB84(num_bits=num_bits, fibre_len=fibre_len, fibre_loss_init=fibre_loss_init, fibre_loss_length=fibre_loss_init) # assign keys to A and B self.key_BB84_A = loc_BB84.key_A self.key_BB84_B = loc_BB84.key_B # trigger A's one way function self.node_A.ports["portC_A1"].tx_output('Alice') def B_send_GHZ(self, username): if username.items[0] == 'Alice': self.BChequeBook, tmpAChequeBook, tmpA2ChequeBook = Create_GHZ_triple_qubits_list( self.num_bits) tmpAChequeBook.extend(tmpA2ChequeBook) self.node_B.ports["portQ_B1"].tx_output(tmpAChequeBook) else: print("User name ERROR!") def A_req_USN(self, tmpAChequeBook): self.A1ChequeBook = tmpAChequeBook.items[:self.num_bits] self.A2ChequeBook = tmpAChequeBook.items[self.num_bits:] self.node_A.ports["portC_A2"].tx_output("USN_req") def B_USN_send_A(self, req): self.B_saveUSN = UniqueSerialNumGen( self.num_bits, 0, 1000) #min max value flexible (doesn't matter actually) self.node_B.ports["portC_B3"].tx_output(self.B_saveUSN) def A_owf_send_C(self, saveUSN): self.A_saveUSN = saveUSN.items if len(self.A1ChequeBook) < self.num_bits: print("No more cheque! Aborting!") return 0 else: for i in range(self.num_bits): # Alice write down the amound of money res_owf_qubit = OneWayFunction('Alice', self.key_BB84_A, self.A_saveUSN[i], self.Money) # Alice performs Bell state measurement operate([res_owf_qubit, self.A1ChequeBook[i]], ops.CNOT) H | res_owf_qubit mes_A1 = ns.qubits.qubitapi.measure(self.A1ChequeBook[i], observable=Z) mes_owf_qubit = ns.qubits.qubitapi.measure(res_owf_qubit, observable=Z) if mes_A1[0] == 0 and mes_owf_qubit[0] == 1: Z | self.A2ChequeBook[i] if mes_A1[0] == 1 and mes_owf_qubit[0] == 0: X | self.A2ChequeBook[i] if mes_A1[0] == 1 and mes_owf_qubit[0] == 1: Y | self.A2ChequeBook[i] self.node_A.ports["portQ_A2"].tx_output(self.A2ChequeBook) # C receives qubits from A then wait and send to B def C_rec_wait_send_B(self, chequeQList): chequeQList = chequeQList.items self.C_Qmemory.put(chequeQList) # wait for some time before summit to bank My_waitENVtype = EventType("WAIT_EVENT", "Wait for N nanoseconds") self._schedule_after(self.C_delay, My_waitENVtype) self._wait_once(ns.EventHandler(self.CpopMem), entity=self, event_type=My_waitENVtype) # can't add event_type # pop qubits from qMemory def CpopMem(self, event): # pop out from qmem sening_qList = [] sening_qList = self.C_Qmemory.pop(list(np.arange( self.num_bits))) #pop all self.node_C.ports["portQ_C2"].tx_output(sening_qList) # B varifies the list given by C def CB_Verify(self, chequeQList): chequeQList = chequeQList.items # error correction for i in range(self.num_bits): H | self.BChequeBook[i] bob_measurement = ns.qubits.qubitapi.measure(self.BChequeBook[i], observable=Z) if bob_measurement[0] == 1: Z | chequeQList[i] # For experiment test_var = 'n' # input("Use a fake check? (y/n)") # To use a fake cheque or not res_closeness = [] for i in range(self.num_bits): if test_var == 'n': owf_bank_state = OneWayFunction('Bob', self.key_BB84_B, self.B_saveUSN[i], self.Money) elif (test_var == 'y'): owf_bank_state = OneWayFunction('Bob', [1, 0, 1, 1, 0, 1], 0, 20) # try any value res_closeness.append(SwapTest(owf_bank_state, chequeQList[i])) sum = 0 for i in range(len(res_closeness)): if int(res_closeness[i][0]) == 0: sum += res_closeness[i][1] else: sum += 1 - res_closeness[i][1] self.chequeCloseness = sum / len( res_closeness) # get average closeness value if self.chequeCloseness > self.Threshold: # pass self.Varify = True #print('Verified! Cheque Accepted!') else: # fail self.Varify = False #print('FAILED! ABORTING!' ) # base function ======================================================== def __init__(self, num_bits=8, fibre_len_AC=10**-6, fibre_len_AB=10**-6, fibre_len_BC=10**-6, Money=1234, depolar_rate=0, time_independent=False, Threshold=0.99, C_delay=0): super().__init__() self.node_A = Node("A", ID=0, port_names=[ "portQ_A1", "portC_A1", "portC_A2", "portQ_A2", "portC_A3" ]) self.node_B = Node("B", ID=1, port_names=[ "portQ_B1", "portC_B1", "portC_B2", "portQ_B2", "portC_B3" ]) self.node_C = Node("C", ID=2, port_names=["portQ_C1", "portQ_C2"]) self.C_Qmemory = QuantumMemory( "C_QMemory", num_bits, ID=0, memory_noise_models=DepolarNoiseModel( depolar_rate=depolar_rate, time_independent=time_independent) ) #normally time_independent is False unless using probability self.C_delay = C_delay self.MyQfiber_AC = None self.MyQfiber_AB = None self.MyQfiber_BC = None self.MyCfiber_AB = None self.MyCfiber_BA = None self.fiberLenth_AC = fibre_len_AC self.fiberLenth_AB = fibre_len_AB self.fiberLenth_BC = fibre_len_BC self.num_bits = num_bits self.A1ChequeBook = [] self.A2ChequeBook = [] self.BChequeBook = [] self.A_saveUSN = [] #unique serial number stored in A self.B_saveUSN = [] #unique serial number stored in B self.key_BB84_A = [] self.key_BB84_B = [] self.Money = Money self.Threshold = Threshold #Threshold of closeness about whether to accept this cheque self.chequeCloseness = 0 self.Varify = False # True = cheque accepted, False = cheque denied self.start() def stop(self): super().stop() self._running = False def is_connected(): super().is_connected() pass def start(self): super().start() self.MyCfiber_AB = DirectConnection( "CFibreConn_AB", ClassicalFibre("CFibre_A->B", length=self.fiberLenth_AB), ClassicalFibre("CFibre_B->A", length=self.fiberLenth_AB)) self.MyCfiber_AB2 = DirectConnection( "CFibreConn_AB2", ClassicalFibre("CFibre_A->B", length=self.fiberLenth_AB), ClassicalFibre("CFibre_B->A", length=self.fiberLenth_AB)) self.MyCfiber_BA = DirectConnection( "CFibreConn_BA", ClassicalFibre("CFibre_A->B", length=self.fiberLenth_AB), ClassicalFibre("CFibre_B->A", length=self.fiberLenth_AB)) self.MyQfiber_AC = QuantumFibre("MyQFibre_AC", length=self.fiberLenth_AC, loss_model=None) #"default" self.MyQfiber_AB = QuantumFibre("MyQFibre_AB", length=self.fiberLenth_AB, loss_model=None) self.MyQfiber_BC = QuantumFibre("MyQFibre_BC", length=self.fiberLenth_BC, loss_model=None) self.node_A.connect_to(self.node_B, self.MyCfiber_AB, local_port_name="portC_A1", remote_port_name="portC_B1") self.node_B.connect_to(self.node_A, self.MyQfiber_AB, local_port_name="portQ_B1", remote_port_name="portQ_A1") self.node_A.connect_to(self.node_B, self.MyCfiber_AB2, local_port_name="portC_A2", remote_port_name="portC_B2") self.node_B.connect_to(self.node_A, self.MyCfiber_BA, local_port_name="portC_B3", remote_port_name="portC_A3") self.node_A.connect_to(self.node_C, self.MyQfiber_AC, local_port_name="portQ_A2", remote_port_name="portQ_C1") self.node_C.connect_to(self.node_B, self.MyQfiber_BC, local_port_name="portQ_C2", remote_port_name="portQ_B2") # set callback functions=================================================== self.node_B.ports["portC_B1"].bind_input_handler(self.B_send_GHZ) self.node_A.ports["portQ_A1"].bind_input_handler(self.A_req_USN) self.node_B.ports["portC_B2"].bind_input_handler(self.B_USN_send_A) self.node_A.ports["portC_A3"].bind_input_handler(self.A_owf_send_C) self.node_C.ports["portQ_C1"].bind_input_handler( self.C_rec_wait_send_B) self.node_B.ports["portQ_B2"].bind_input_handler(self.CB_Verify) # Start by BB84 self.BA_BB84_keygen()
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()
class E91(Protocol): def E91_A_sendHalf_EPR(self): qListA, qlistB = Create_multiEPR(self.num_bits) self.qListA = qListA self.node_A.ports["portQA"].tx_output(qlistB) def E91_B_randMeas(self, qListB): self.qListB = qListB.items #print(qListB) self.basisList_B, self.res_measure_B = Random_ZX_measure( self.num_bits, self.qListB) #print(self.basisList_B) self.node_B.ports["portCB_1"].tx_output(self.basisList_B) def E91_A_compare_keyGen(self, basisList_fromB): self.basisList_A, self.res_measure_A = Random_ZX_measure( self.num_bits, self.qListA) self.node_A.ports["portCA_2"].tx_output(self.basisList_A) #print(self.basisList_A) #print(basisList_fromB.items) self.key_A = Compare_basis(self.basisList_A, basisList_fromB.items, self.res_measure_A) self.key_A = ''.join(map(str, self.key_A)) print(self.key_A) # show results def E91_B_compare_keyGen(self, basisList_fromA): self.key_B = Compare_basis(self.basisList_B, basisList_fromA.items, self.res_measure_B) self.key_B = ''.join(map(str, self.key_B)) print(self.key_B) # show results #control functions=========================================================== def __init__(self, num_bits=8, fibre_len=10**-6): super().__init__() self.node_A = Node("A", ID=0, port_names=["portQA", "portCA_1", "portCA_2"]) self.node_B = Node("B", ID=1, port_names=["portQB", "portCB_1", "portCB_2"]) self.MyQfiber = None self.MyCfiber = None self.num_bits = num_bits self.qListA = [] self.qListB = [] self.basisList_A = [] self.basisList_B = [] self.res_measure_A = [] self.res_measure_B = [] self.key_A = [] self.key_B = [] self.fiberLenth = fibre_len self.start() def stop(self): super().stop() self._running = False def is_connected(): super().is_connected() pass def start(self): super().start() # connect and connect quantum fibres self.MyQfiber = QuantumFibre("QFibre_A->B", length=self.fiberLenth) # create classical fibre self.MyCfiber = DirectConnection( "CFibreConn_B->A", ClassicalFibre("CFibre_B->A", length=self.fiberLenth)) self.MyCfiber2 = DirectConnection( "CFibreConn_A->B", ClassicalFibre("CFibre_A->B", length=self.fiberLenth)) self.node_A.connect_to(self.node_B, self.MyQfiber, local_port_name="portQA", remote_port_name="portQB") self.node_B.connect_to(self.node_A, self.MyCfiber, local_port_name="portCB_1", remote_port_name="portCA_1") self.node_A.connect_to(self.node_B, self.MyCfiber2, local_port_name="portCA_2", remote_port_name="portCB_2") #set callback functions=================================================== self.node_B.ports["portQB"].bind_input_handler(self.E91_B_randMeas) self.node_A.ports["portCA_1"].bind_input_handler( self.E91_A_compare_keyGen) self.node_B.ports["portCB_2"].bind_input_handler( self.E91_B_compare_keyGen) # Alice starts====================================================== self.E91_A_sendHalf_EPR()
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
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