def test_measurement(tmpdir): filename = os.path.join(str(tmpdir), 'CQC_File') with CQCToFile(file=filename) as cqc: q = qubit(cqc) a = q.measure() assert a == 0
def commands_to_apply_mix_with_factory(cqc): qbit = qubit(cqc) with CQCMix(cqc) as pgrm: qbit.X() with pgrm.loop(times=3): qbit.H() qbit.Y()
def compute(name: str, instructions: List[BaseInstruction], conn): from cqc.pythonLib import CQCConnection, qubit # Initialize the connection with CQCConnection(name) as connection: qubits = {} for inst in instructions: if isinstance(inst, SingeQubitInstruction): if inst.qubit not in qubits: qubits[inst.qubit] = qubit(connection) inst.apply(qubits.get(inst.qubit)) if isinstance(inst, CNOTInstruction): if inst.control_connection_name == inst.target_connection_name: if inst.control not in qubits: qubits[inst.control] = qubit(connection) if inst.target not in qubits: qubits[inst.target] = qubit(connection) inst.apply(qubits.get(inst.control), qubits.get(inst.target)) else: if inst.control_connection_name == connection.name: if inst.control not in qubits: qubits[inst.control] = qubit(connection) inst.apply_on_control(connection, inst.target_connection_name, qubits.get(inst.control)) else: if inst.target not in qubits: qubits[inst.target] = qubit(connection) inst.apply_on_target(connection, inst.control_connection_name, qubits.get(inst.target)) results = [q.measure() for q in qubits.values()] conn.send(results) conn.close() print(f"Results for {name}", results) return results
def prepareQubit(name, alpha, c, y, noise): q = qubit(name) if c == 0: q.rot_Y(round((256 / math.pi) * math.acos(math.sqrt(y)))) q.rot_Z(128 * alpha) elif c == 1: q.rot_Y(round((256 / math.pi) * math.acos(math.sqrt(1 - y)))) q.rot_Z(128 * ((alpha + 1) % 2)) q = addNoise(q, noise) return q
def main(): # Initialize the connection with CQCConnection("Alice") as Alice: # Here 1)we connect a node (ALice) q = qubit(Alice) # 2)produced a fresh qubit q.H() # 3)applied Hadamard gate coin = q.measure() # 4)mesaured the qubit and the result printed to_print = "{}".format(coin) print("| " + to_print + " |") return coin
def encode_standard(connection, number, length): encoded = [None] * length num_vector = BitVector(intVal=number, size=length) for i in range(length): encoded[i] = qubit(connection) if num_vector[i] != 0: encoded[i].X() # Apply not gate return encoded
def create_qubit(self, host_id): """ Creates a new Qubit of the type of the backend. Args: host_id (String): Id of the host to whom the qubit belongs. Returns: Qubit of backend type. """ return cqc.qubit(self._cqc_connections.get_from_dict(host_id))
def message_reciever(message, qubit2): with CQCConnection("Bob") as Bob: qubit2 = qubit(Bob) if message[1] == 1: qubit2.X() if message[0] == 1: qubit2.Z() d = qubit2.measure() recieve_bit = d recieve_bit = int(d) return recieve_bit
def testReset(self): with CQCConnection("Alice", appID=0, pend_messages=True) as cqc: q1 = qubit(cqc) cqc.flush() q1.X() q1.reset() cqc.flush_factory(self.iterations) q1.measure() m = cqc.flush() self.assertEqual(m, [0]) self.assertEqual(len(cqc.pending_messages), 0)
def testMeasure(self): with CQCConnection("Alice", appID=0, pend_messages=True) as cqc: q = qubit(cqc) q.X() # Let's do an X so all measurement outcomes should be 1 # (to show no reinitialisation) cqc.flush() q.measure() with self.assertRaises(CQCNoQubitError): cqc.flush_factory(self.iterations) self.assertFalse(q._active) self.assertEqual(len(cqc._pending_headers), 0)
def star_expansion(my_qubit_dict, name_inst, source, targets): """does the star expansion of the target from the source Arguments: my_qubit_dict {dict{simulacronQubitObject}} -- [description] name_inst {SimulacronCQCConnectionObjct} -- [description] source {str} -- [description] targets {str} -- [description] Returns: [type] -- [description] """ my_name = name_inst.name #protocol = protocol_from_json(my_name) if targets == [my_name]: # (aka do nothing) #print("return flag1", my_name, source) my_qubit_dict[my_name] = my_qubit_dict[source] return my_qubit_dict else: if my_name in targets: #print("flag3", my_name) my_qubit_dict[my_name] = qubit(name_inst) my_qubit_dict[my_name].H() #print("flag2.5", my_name, my_qubit_dict[my_name]) q_aux = qubit(name_inst) q_aux.H() q_aux.cphase(my_qubit_dict[source]) for target in targets: #print("flag2", my_name, target) q_aux.cphase(my_qubit_dict[target]) q_aux.Y() m1 = q_aux.measure() for t in targets: if t != my_name: #print("flag1", my_name, t) my_qubit_dict[t].Y() m2 = my_qubit_dict[t].measure() return my_qubit_dict
def test_send(self): for sender_name, receiver_name in self.edges: with CQCConnection(sender_name) as sender: with CQCConnection(receiver_name) as receiver: q = qubit(sender) sender.sendQubit(q=q, name=receiver_name, remote_appID=receiver._appID) q = receiver.recvQubit() m = q.measure() self.assertEqual(m, 0) for sender_name, receiver_name in self.non_edges: with CQCConnection(sender_name) as sender: with CQCConnection(receiver_name) as receiver: q = qubit(sender) with self.assertRaises(CQCUnsuppError): sender.sendQubit(q=q, name=receiver_name, remote_appID=receiver._appID) m = q.measure() self.assertEqual(m, 0)
def main(): # Initialize the connection with CQCConnection("Alice") as Alice: # Create qubits q1 = qubit(Alice) q2 = qubit(Alice) J(q1, q2) #passing them through J Gate q1.Z() #sample decision Alice.sendQubit( q2, "Bob") #sending Qubit to Bob after passing it through J gate q3 = Alice.recvQubit() #recieve the manipulated qubit from Bob JD(q1, q3) #passing it through reverse J gate # Measure the qubits a = q1.measure() b = q3.measure() to_print = "App {}: Measurement outcomes are: Alice={}, Bob={}".format( Alice.name, a, b) print("|" + "-" * (len(to_print) + 2) + "|") print("| " + to_print + " |") print("|" + "-" * (len(to_print) + 2) + "|")
def measure(node, q1, q2, measurements): """measurements is a string, with: - first element in ['+', '-'] - second and third letter in ['I', 'X', 'Y', 'Z']""" # Create ancilla anc = qubit(node) ### ____ pre_measure(node, q1, anc, measurements[1]) pre_measure(node, q2, anc, measurements[2]) if measurements[0] == "-": anc.X() return anc.measure()
def testMultipleTypes(self): with CQCConnection("Alice", pend_messages=True) as alice: with CQCConnection("Bob", appID=1, pend_messages=True) as bob: q = qubit(alice) alice.flush() q.X() qubit(alice) q.measure(inplace=True) res = alice.flush_factory(8) alice.set_pending(False) q.measure() ms = res[1::2] qs = res[::2] for qu in qs: self.assertEqual(qu.measure(), 0) self.assertEqual(len(res), 16) self.assertEqual(ms, [1, 0] * 4) alice.set_pending(True) self.assertEqual(alice.pending_messages, []) self.assertEqual(bob.pending_messages, []) alice.flush() bob.flush()
def encode_hadamard(connection, number, length): encoded = [None] * length num_vector = BitVector(intVal=number, size=length) for i in range(length): encoded[i] = qubit(connection) if num_vector[i] != 0: encoded[i].X() # Apply not gate # Put qubit into the hadamard basis encoded[i].H() return encoded
def testMeasureInplace(self): with CQCConnection("Alice", appID=0, pend_messages=True) as cqc: q = qubit(cqc) q.X() # Let's do an X so all measurement outcomes should be 1 # (to show no reinitialisation) cqc.flush() q.measure(inplace=True) m = cqc.flush_factory(self.iterations) self.assertEqual(len(m), self.iterations) self.assertTrue(x == 1 for x in m) q.measure() cqc.flush() self.assertEqual(len(cqc._pending_headers), 0)
def testSimpleSequence(self): with CQCConnection("Alice", pend_messages=True) as alice: with CQCConnection("Bob", appID=1, pend_messages=True) as bob: q = qubit(alice) q.H() q.Z() q.H() q.measure() r = alice.flush()[1] self.assertEqual(r, 1) self.assertEqual(alice.pending_messages, []) self.assertEqual(bob.pending_messages, []) alice.flush() bob.flush()
def test_createqubit(tmpdir): filename = os.path.join(str(tmpdir), 'CQC_File') with CQCToFile(file=filename, binary=False) as cqc: qubit(cqc) # Read the files before cqc goes out of context and flushes with open(filename) as f: lines = f.readlines() assert len(lines) == 1 # Check that the first line initialize a qubit headers = parse_cqc_message(eval(lines[0][:-1])) assert len(headers) == 2 hdr, cmd = headers assert isinstance(hdr, CQCHeader) assert hdr.tp == CQCType.COMMAND assert isinstance(cmd, CQCCmdHeader) assert cmd.qubit_id == 0 assert cmd.instr == CQC_CMD_NEW
def testSend(self): with CQCConnection("Alice", appID=0, pend_messages=True) as cqc: q = qubit(cqc) q.X() cqc.flush() with CQCConnection("Bob", appID=1) as bob: # Get receiving host cqc.sendQubit(q, "Bob", remote_appID=1) with self.assertRaises(CQCNoQubitError): cqc.flush_factory(self.iterations) qB = bob.recvQubit() self.assertTrue(qB.measure(), 1) self.assertFalse(q._active) self.assertEqual(len(cqc.pending_messages), 0)
def initialize_Qubit_register(num_qubit, Owner): """ Initialize quantum registers. Multiple qubits are stored and returned as an array. Returns an array of initialized qubits. :param num_qubit: Number of qubits to initialize :param Owner: The owner of the qubit / CQCConnection. """ qubits = [] for x in range(0, num_qubit): one_more_qubit = qubit(Owner) qubits.append(one_more_qubit) return qubits
def main(agents): print("running Bob") # Initialize the connection with CQCConnection(agents[1]) as Bob: # Make an EPR pair with Alice qB = Bob.recvEPR() for agent in agents[2:]: # Create a fresh qubit qC = qubit(Bob) # Entangle the new qubit qB.cnot(qC) # Send qubit to Charlie Bob.sendQubit(qC, agent) mCharlies = [] for charlie in agents[2:]: mCharlies.append(list(Bob.recvClassical())[0]) bp = randint(0, 1) b = list(Bob.recvClassical())[0] if (bp + sum(mCharlies)) % 2 == 1: qB.Z() data = Bob.recvClassical() message = list(data) a = message[0] b = message[1] # Apply corrections if b == 1: qB.X() if a == 1: qB.Z() # Measure qubit m = qB.measure() print("Bob received message", m)
def test_send_for_last_position(self): with CQCConnection("Alice") as alice: with CQCConnection("Bob") as bob: alice_qubits = [] bob_qubits = [] for _ in range(simulaqron_settings.max_qubits): q = qubit(alice) alice_qubits.append(q) for _ in range(simulaqron_settings.max_qubits - 1): q = qubit(bob) bob_qubits.append(q) alice.sendQubit(alice_qubits[0], "Bob", remote_appID=bob._appID) q = bob.recvQubit() bob_qubits.append(q) with self.assertRaises(CQCNoQubitError): alice.sendQubit(alice_qubits[1], "Bob", remote_appID=bob._appID) # remove one qubit from Bob bob_qubits[0].measure() alice.sendQubit(alice_qubits[1], "Bob", remote_appID=bob._appID) bob.recvQubit()
def testMeasuringMultipleQubits(self): with CQCConnection("Alice", pend_messages=True) as alice: with CQCConnection("Bob", appID=1, pend_messages=True) as bob: qA = qubit(alice) qs = alice.flush_factory(10) self.assertIsNone(qA._qID) self.assertFalse(qA.check_active()) for q in qs: q.measure() ms = alice.flush() self.assertEqual(ms, [0] * 10) self.assertEqual(alice.pending_messages, []) self.assertEqual(bob.pending_messages, []) alice.flush() bob.flush()
def one_way_function(conn, BB84_key, db_id, r, M): owf_state = qubit(conn) BB84_key = int(BB84_key, 2) owf_key = bin(BB84_key)[2:] + bin(db_id)[2:] + bin(r)[2:] + bin(M)[2:] owf_key = int(abs(hash(str(owf_key)))) # p1 , p2, p3 are prime numbers , so coprimes # thus rotation X(key%p1) and Y(key%p2) and Z(key%p3) are independant p1 = 33179 p2 = 32537 p3 = 31259 owf_state.rot_X(owf_key%p1%256) owf_state.rot_Y(owf_key%p2%256) owf_state.rot_Z(owf_key%p3%256) return owf_state
def testAlternating(self): with CQCConnection("Alice", pend_messages=True) as alice: with CQCConnection("Bob", appID=1, pend_messages=True) as bob: q = qubit(alice) alice.flush() q.X() q.measure(inplace=True) res = alice.flush_factory(10) q.measure() alice.flush() self.assertEqual(res, [1, 0] * 5) self.assertEqual(alice.pending_messages, []) self.assertEqual(bob.pending_messages, []) alice.flush() bob.flush()
def create_conn(device_name, target_name): t0 = time.time() print('Sending RECV from %s to %s' % (device_name, target_name)) send_rec(device_name, target_name) print('Starting creating and sending QK from: %s to: %s' % (device_name, target_name)) secret_key = '' with CQCConnection(device_name) as Alice: print('start comm') for i in range(256): # Make an EPR pair with Bob qA = Alice.createEPR(target_name) # Create a random number q_random = qubit(Alice) q_random.H() r_number = q_random.measure() secret_key += str(r_number) #print('Random number: ' + str(r_number)) # Create a qubit to teleport q = qubit(Alice) # Prepare the qubit to teleport in |+> if r_number == 1: q.X() # Apply the local teleportation operations q.cnot(qA) q.H() # Measure the qubits a = q.measure() b = qA.measure() Alice.sendClassical(target_name, [a, b]) print(hex(int(secret_key, 2))) t1 = time.time() secs = t1 - t0 print('It took: %d mins %d seconds' % (secs // 60, secs % 60)) print(bitstring_to_bytes(secret_key)) send(bitstring_to_bytes(secret_key))
def swap_test(conn, q1, q2): # swap_test implementation from : # https://en.wikipedia.org/wiki/Swap_test q0 = qubit(conn) q0.H() CSWAP(q0, q1, q2) q0.H() m = q0.measure() # collaspse everything after swap_test to avoid : # cqc.pythonLib.CQCNoQubitError: No more qubits available q1.measure() q2.measure() return m
def bobNode(): with CQCConnection("Bob") as Bob: #Receving Alice's EPR qB = Bob.recvEPR() data = Bob.recvClassical() message = list(data) a = message[0] b = message[1] if b == 1: qB.X() if a == 1: qB.Z() m = qB.measure(inplace=True) #Similar to Alice's retention of qA. print("Bob: Measurement outcomes of A->B is: {}".format(m)) print("-"*50+"\n\n") #Just flipping the previous outcome for fun n = 2**m - 1 print("|| Now, Bob will send a message to Alice ||") print("-"*25) #Creating Bob's own qubit and # controversially recreating EPR (Refer line 26 in Alice's code) qB = Bob.createEPR("Alice") q = qubit(Bob) #Using the flipped outcome if n: q.X() q.H() q.cnot(qB) q.H() c = q.measure() d = qB.measure() print("Bob: Measurement outcomes of B->A are: c={}, d={} \n\n".format(c, d)) Bob.sendClassical("Alice", [c, d])
def createRandom(self): """ Method that creates the random key for the iteration. Uses randomness of Quantum Mechanics to produce the required string. :return: Random key. :rtype: String """ random_key = '' with CQCConnection(self.name) as User: for i in range(24): q = qubit(User) q.H() random_key = random_key + str(q.measure()) return random_key