def prep_CNOT_control_CQC(cqc): q1 = qubit(cqc) q2 = qubit(cqc) q1.H() q1.cnot(q2) q2.measure() return q1
def testFactoryNew(self): with CQCConnection("Alice", appID=1) as alice: # Should return a list of qubits with consecutive qubit ids alice.set_pending(True) qubit(alice) qubits = alice.flush_factory(10, do_sequence=False) # It is preferable to use the following however: # qubits = alice.allocate_qubits(10) alice.set_pending(False) # Checking the factory and the measure, factory should not log any commands lastEntries = get_last_entries(11) factoryEntry = lastEntries[0] self.assertEqual(factoryEntry["node_name"], "Alice") factory_cqc_header = factoryEntry["cqc_header"] self.assertEqual(factory_cqc_header["type"], CQC_TP_FACTORY) expected_length = CQCFactoryHeader.HDR_LENGTH + CQC_CMD_HDR_LENGTH self.assertEqual(factory_cqc_header["header_length"], expected_length) self.assertEqual(factoryEntry["factory_iterations"], 10) for i in range(1, 11): xEntry = lastEntries[i] x_cmd_cmd_header = xEntry["cmd_header"] self.assertEqual(x_cmd_cmd_header["instruction"], CQC_CMD_NEW) curID = qubits[0]._qID for q in qubits[1:]: self.assertEqual(q._qID, curID + 1) curID = q._qID
def prep_CNOT_target_CQC(cqc): q1 = qubit(cqc) q2 = qubit(cqc) q1.H() q1.cnot(q2) q1.measure() return q2
def test_epr_for_last_position(self): with CQCConnection("Alice") as alice: with CQCConnection("Bob") as bob: alice_qubits = [] bob_qubits = [] for _ in range(Settings.CONF_MAXQUBITS - 1): q = qubit(alice) alice_qubits.append(q) for _ in range(Settings.CONF_MAXQUBITS - 1): q = qubit(bob) bob_qubits.append(q) q = alice.createEPR("Bob", remote_appID=bob._appID) alice_qubits.append(q) q = bob.recvEPR() bob_qubits.append(q) with self.assertRaises(CQCNoQubitError): alice.createEPR("Bob", remote_appID=bob._appID) # remove one qubit from Alice alice_qubits[0].measure() with self.assertRaises(CQCNoQubitError): alice.createEPR("Bob", remote_appID=bob._appID) # remove one qubit from Bob bob_qubits[0].measure() alice.createEPR("Bob", remote_appID=bob._appID) bob.recvEPR()
def testFactoryCPHASE(self): with CQCConnection("Alice", appID=1) as alice: q1 = qubit(alice) q2 = qubit(alice) alice.set_pending(True) q1.cphase(q2) alice.flush_factory(10, do_sequence=False) alice.set_pending(False) entries = get_last_entries(11) factoryEntry = entries[0] self.assertEqual(factoryEntry["node_name"], "Alice") factory_cqc_header = factoryEntry["cqc_header"] self.assertEqual(factory_cqc_header["type"], CQC_TP_FACTORY) expected_length = CQCFactoryHeader.HDR_LENGTH + CQC_CMD_HDR_LENGTH + CQCXtraQubitHeader.HDR_LENGTH self.assertEqual(factory_cqc_header["header_length"], expected_length) self.assertEqual(factoryEntry["factory_iterations"], 10) for i in range(1, 11): xEntry = entries[i] x_cmd_cmd_header = xEntry["cmd_header"] self.assertEqual(x_cmd_cmd_header["instruction"], CQC_CMD_CPHASE) self.assertEqual(x_cmd_cmd_header["qubit_id"], q1._qID) x = xEntry["xtra_header"] self.assertEqual(x["qubit_id"], q2._qID)
def test_more_than_max(self): with CQCConnection("Alice") as alice: for _ in range(Settings.CONF_MAXQUBITS): qubit(alice) with self.assertRaises(CQCNoQubitError): qubit(alice)
def _atomic_flip(self, candidate1, candidate2, coeff): """ Performs the basic biased coinflip between two parties. :param candidate1: the first party id. :param candidate2: the second party id. :param coeff: bias. :return: the winner id. """ with CQCConnection(candidate1) as Alice: qA = qubit(Alice) qB = qubit(Alice) # Bias angle = 2 * math.acos(coeff) step = int(angle * 256 / (2 * math.pi)) qA.rot_Y(step) qA.cnot(qB) qB.X() # Send qubit qB to Bob. Alice.sendQubit(qB, candidate2) # Measure the qubits. measured_value = qA.measure() with CQCConnection(candidate2) as Bob: qB = Bob.recvQubit() bob_value = qB.measure() assert measured_value + bob_value == 1 if measured_value == 1: # `candidate1` is a winner. return candidate1 else: return candidate2
def test_without_context(self): for _ in range(Settings.CONF_MAXQUBITS): cqc = CQCConnection("Alice") self.qubits.append(qubit(cqc)) with self.assertRaises(CQCNoQubitError): cqc = CQCConnection("Alice") qubit(cqc)
def testFactoryCNOTFalse(self): with CQCConnection("Alice", appID=1) as alice: q1 = qubit(alice) qubit(alice) with self.assertRaises(CQCUnsuppError): alice.set_pending(True) q1.cnot(q1) alice.flush_factory(10, do_sequence=False) alice.set_pending(False)
def testCNotRemote(self): with CQCConnection("Alice", appID=1) as alice: # The appId in xtra_header['app_id'] is not 2 when testing. # In fact, doing this code in a real application result in an error as of 2018-03-12 with CQCConnection("Bob", appID=2) as bob: q1 = qubit(alice) q2 = qubit(bob) with self.assertRaises(CQCUnsuppError): q1.cnot(q2)
def prep_CPHASE_target_CQC(cqc): q1 = qubit(cqc) q2 = qubit(cqc) q1.H() q2.H() q1.cphase(q2) q2.H() q1.measure() return q2
def prep_CPHASE_control_CQC(cqc): q1 = qubit(cqc) q2 = qubit(cqc) q1.H() q2.H() q1.cphase(q2) q2.H() q2.measure() return q1
def testGetTime(self): # Test Get time q1 = qubit(self.cqc) time.sleep(3) q2 = qubit(self.cqc) t1 = q1.getTime() t2 = q2.getTime() self.assertEqual(t2 - t1, 3) q1.measure() q2.measure()
def prep_CNOT_control_CQC_FACTORY_even(cqc): q1 = qubit(cqc) q2 = qubit(cqc) q1.H() cqc.set_pending(True) q1.cnot(q2) cqc.flush_factory(4) cqc.set_pending(False) q2.measure() return q1
def prep_CNOT_target_CQC_FACTORY_odd(cqc): q1 = qubit(cqc) q2 = qubit(cqc) q1.H() cqc.set_pending(True) q1.cnot(q2) cqc.flush_factory(3) cqc.set_pending(False) q1.measure() return q2
def testNew(self): with CQCConnection("Alice", appID=0, pend_messages=True) as cqc: qubit(cqc) qubits = cqc.flush_factory(self.iterations) self.assertEqual(len(qubits), self.iterations) for q in qubits: q.X() q.measure() results = cqc.flush() self.assertEqual(results, [1] * self.iterations) self.assertEqual(len(cqc.pending_messages), 0)
def testGetTime(self): with CQCConnection("Alice", appID=1) as cqc: # Test Get time q1 = qubit(cqc) time.sleep(3) q2 = qubit(cqc) t1 = q1.getTime() t2 = q2.getTime() self.assertEqual(t2 - t1, 3) q1.measure() q2.measure()
def prep_CPHASE_control_CQC_FACTORY_odd(cqc): q1 = qubit(cqc) q2 = qubit(cqc) q1.H() q2.H() cqc.set_pending(True) q1.cphase(q2) cqc.flush_factory(3) cqc.set_pending(False) q2.H() q2.measure() return q1
def prep_CPHASE_target_CQC_FACTORY_even(cqc): q1 = qubit(cqc) q2 = qubit(cqc) q1.H() q2.H() cqc.set_pending(True) q1.cphase(q2) cqc.flush_factory(4) cqc.set_pending(False) q2.H() q1.measure() return q2
def testNewQubit(self): with CQCConnection("Alice", appID=1) as alice: qubit(alice, block=False, notify=False) lastEntry = get_last_entries(1)[0] cmd_header = lastEntry["cmd_header"] self.assertEqual(lastEntry["node_name"], "Alice") self.assertEqual(cmd_header["instruction"], CQC_CMD_NEW) self.assertEqual(cmd_header["block"], False) self.assertEqual(cmd_header["notify"], False) cqc_header = lastEntry["cqc_header"] self.assertEqual(cqc_header["type"], CQC_TP_COMMAND) self.assertEqual(cqc_header["header_length"], CQC_CMD_HDR_LENGTH) self.assertEqual(cqc_header["app_id"], 1)
def prep_send_CQC(cqc): with CQCConnection("Alice", appID=1) as Alice: qA = qubit(cqc) qB = qubit(cqc) qA.H() qA.cnot(qB) cqc.sendQubit(qA, "Alice", remote_appID=1) qA = Alice.recvQubit() m = qA.measure() if m == 1: qB.X() qB.H() return qB
def prep_I_CQC_FACTORY(cqc): q = qubit(cqc) cqc.set_pending(True) q.I() cqc.flush_factory(3) cqc.set_pending(False) return q
def prep_K_CQC_FACTORY_EVEN(cqc): q = qubit(cqc) cqc.set_pending(True) q.K() cqc.flush_factory(4) cqc.set_pending(False) return q
def prep_recv_CQC(cqc): with CQCConnection("Alice", appID=1) as Alice: qA = qubit(Alice) qA.H() Alice.sendQubit(qA, "Bob") qB = cqc.recvQubit() return qB
def prep_ROT_X(cqc): q = qubit(cqc) cqc.set_pending(True) q.rot_X(step=4) cqc.flush_factory(4) cqc.set_pending(False) return q
def main(): # Initialize the connection with CQCConnection("Alice") as Alice: Alice.closeClassicalServer() # Generate a key k = random.randint(0, 1) chosen_basis = random.randint(0, 1) # Create a qubit q = qubit(Alice) # Encode the key in the qubit if k == 1: q.X() # Encode in H basis if basis = 1 if chosen_basis == 1: q.H() # Send qubit to Bob (via Eve) Alice.sendQubit(q, "Eve") # Encode and send a classical message m to Bob m = 1 enc = (m + k) % 2 send_message(Alice, "Bob", bytes([enc])) print("\nAlice basis={}".format(BASIS[chosen_basis])) print("Alice key={}".format(k)) print("Alice sent the message m={} to Bob".format(m))
def main(): # Initialize the connection with CQCConnection("Alice") as Alice: # Make an EPR pair with Bob qA = Alice.createEPR("Bob") # Create a qubit to teleport q = qubit(Alice) # Prepare the qubit to teleport in |+> q.H() # Apply the local teleportation operations q.cnot(qA) q.H() # Measure the qubits a = q.measure() b = qA.measure() to_print = "App {}: Measurement outcomes are: a={}, b={}".format( Alice.name, a, b) print("|" + "-" * (len(to_print) + 2) + "|") print("| " + to_print + " |") print("|" + "-" * (len(to_print) + 2) + "|") # Send corrections to Bob Alice.sendClassical("Bob", [a, b])
def testSingleGates(self): with CQCConnection("Alice", pend_messages=True) as alice: with CQCConnection("Bob", appID=1, pend_messages=True) as bob: q = qubit(alice) q.X() q.measure(inplace=True) r = alice.flush() self.assertEqual(len(r), 2) self.assertEqual(r[1], 1) q.reset() q.Y() q.measure(inplace=True) r = alice.flush() self.assertEqual(r, [1]) q.reset() q.Z() q.measure(inplace=True) r = alice.flush() self.assertEqual(r, [0]) q.reset() q.H() q.H() q.measure() r = alice.flush() self.assertEqual(r, [0]) self.assertEqual(alice.pending_messages, []) self.assertEqual(bob.pending_messages, []) alice.flush() bob.flush()
def testSend(self): with CQCConnection("Alice", pend_messages=True) as alice: with CQCConnection("Bob", appID=1, pend_messages=True) as bob: qA = qubit(alice) qAs = alice.flush_factory(10) self.assertIsNone(qA._qID) self.assertFalse(qA.check_active()) for q in qAs: self.assertTrue(q._active) alice.sendQubit(q, name="Bob", remote_appID=1) self.assertTrue(q._active) alice.flush() qB = bob.recvQubit() qBs = bob.flush_factory(10) self.assertIsNone(qB._qID) self.assertFalse(qB.check_active()) for q in qAs: self.assertFalse(q._active) for i in range(1, 10): self.assertEqual(qBs[i - 1]._qID + 1, qBs[i]._qID) bob.set_pending(False) for q in qBs: self.assertEqual(q.measure(), 0) bob.set_pending(True) self.assertEqual(alice.pending_messages, []) self.assertEqual(bob.pending_messages, []) alice.flush() bob.flush()
def main(): n = parse_arguments() basis_string = '' bitstring = '' # Initialize the connection with CQCConnection("Alice") as Alice: for i in range(0, n): # Generate a key k = random.randint(0, 1) bitstring += str(k) chosen_basis = random.randint(0, 1) basis_string += str(chosen_basis) # Create a qubit q = qubit(Alice) # Encode the key in the qubit if k == 1: q.X() # Encode in H basis if basis = 1 if chosen_basis == 1: q.H() # Send qubit to Bob (via Eve) Alice.sendQubit(q, "Eve") receive_message(Alice) print("\nAlice basis={}".format(basis_string)) print("Alice sent the key k={} to Bob".format(bitstring))