def period_finder(n: int, x: int) -> int: """ Solves the period finding problem. :param n: (int) the integer to be factoring :param x: (int) the random number used to solve the period finding problem :return: (int) the period of the function f: a -> x^a mod n """ # Create the job using the above function job = build_quantum_program(n, x) # Initialize the quantum simulator qpu = PyLinalg() # The probability to find the right period with Shor's algorithm is greater than 1/2, so we execute the quantum # program until to find a consistent period while True: # If the period found by Shor's quantum algorithm is wrong then an exception is raised try: # Submit the job and retrieve the result measure = qpu.submit(job) # Extract the period from the measurement r = continued_fraction_expansion(n, measure.raw_data[0].state.int, int(np.trunc(np.log2(n**2))) + 1) # Check the period is valid if x**r % n == 1: return r # A ValueError exception has been caught which means the period is not extractable from the previous measurement except ValueError: continue
def main(): # _a is for Alice, _b is for Bob, _c is for classical pr = Program() to_teleport = pr.qalloc() epr_pair_a = pr.qalloc() epr_pair_a_c = pr.calloc() to_teleport_c = pr.calloc() epr_pair_b = pr.qalloc() # Prepare EPR pair pr.apply(H, *epr_pair_a) pr.apply(CNOT, *epr_pair_a, *epr_pair_b) # Now Alice has her half of the EPR pair (epr_pair_a) and Bob the other one # (epr_pair_b qubit) # Prepare random state on the qubit(s) to teleport pr.apply(RY(random() * pi), *to_teleport) pr.apply(RX(random() * pi), *to_teleport) pr.apply(RZ(random() * pi), *to_teleport) # At this point we make a copy of the original program. The idea is to show # the state we would obtain if we would stop at this stage, before the # teleportation. pr2 = deepcopy(pr) # We continue with the teleportation circuit # Alice interact her to_teleport_qubit with her half of the EPR pair pr.apply(CNOT, *to_teleport, *epr_pair_a) pr.apply(H, *to_teleport) # ... and then she measures her 2 qubits pr.measure(to_teleport, to_teleport_c) pr.measure(epr_pair_a, epr_pair_a_c) # She then sends her measured qubits to Bob which, depending on their value # being 0 or 1, performs the classically controlled X and Z on his own half of the EPR pair pr.cc_apply(epr_pair_a_c[0], X, epr_pair_b[0]) pr.cc_apply(to_teleport_c[0], Z, epr_pair_b[0]) # circ = pr.to_circ() circ2 = pr2.to_circ() # simulation qpu = PyLinalg() res = qpu.submit(circ.to_job(qubits=[epr_pair_b])) res2 = qpu.submit(circ2.to_job(qubits=[to_teleport])) print("Original state, measured on to_teleport qubit") for sample in res2: # print(f"state {sample.state} with amplitude {sample.amplitude} and probability {sample.probability}") print(f"state {sample.state} with amplitude {sample.probability}") print("Teleported state, measured on ") for sample in res: print(f"state {sample.state} with probability {sample.probability}")
def test_teleportation(): """ Checks the output of the teleportation """ # Generate two circuits for circ in [generate_teleportation(True), generate_teleportation(False)] * 10: # Submit teleportation circuit to PyLinalg result = PyLinalg().submit(circ.to_job()) # Init expected result amplitude_zero = -0.5319070945531361 - 0.6198336118074692j amplitude_one = 0.4378426919829602 + 0.3757325026063933j # Check result assert len(result) == 2 for sample in result: # If last qubit is 1 if sample.state.int & 1: assert sample.amplitude == pytest.approx(amplitude_one) # If last qubit is 0 else: assert sample.amplitude == pytest.approx(amplitude_zero)
def test_multiple_measurements(): """ Submit a circuit composed to 2 intermediate measurements """ # Build a program prog = Program() qbits = prog.qalloc(2) cbits = prog.calloc(2) prog.apply(X, qbits[0]) prog.measure(qbits, cbits) prog.apply(CNOT, qbits) prog.measure(qbits, cbits) circ = prog.to_circ() # Submit circuit result = PyLinalg().submit(circ.to_job()) # Check result assert len(result) == 1 sample = result.raw_data[0] assert sample.state.int == 3 # Check intermediate measurements assert len(sample.intermediate_measurements) == 2 assert sample.intermediate_measurements[0].cbits == [True, False] assert sample.intermediate_measurements[1].cbits == [True, True]
class OracleDeutschJozsaTest(unittest.TestCase): qpu = PyLinalg() def test_balanced(self): max_qubit = 6 for n in range(1, max_qubit + 1): with self.subTest(n=n): # It also creates an additional qubit for output oracle = BalancedOracle(n) count1 = 0 for i in range(2**n): pr = Program() qreg = pr.qalloc(n) qout = pr.qalloc(1) qr_init = initialize_qureg_given_int(i, qreg, False) pr.apply(qr_init, qreg) pr.apply(oracle.generate(), [*qreg, *qout]) # display(pr.to_circ()) # res = self.qpu.submit(pr.to_circ().to_job()) # for sample in res: # print(sample.state, sample.probability) res = self.qpu.submit(pr.to_circ().to_job(qubits=[qout])) self.assertEqual(len(res.raw_data), 1) sample = res.raw_data[0] if sample.state.state == 1: count1 += 1 self.assertEqual(count1, 2**(n - 1))
def main(): qpu = PyLinalg() namespace = parse_arguments() print(namespace) alg = TeleportationAlgorithm pr, meas_qbits = alg.generate_program(namespace.n) ress = alg.simulate_program(pr, qpu) for res in ress: print(res.state, res.probability) print("***")
def main(): qpu = PyLinalg() namespace = parse_arguments() print(namespace) if not namespace.bitstring: namespace.bitstring = bin(random.getrandbits(namespace.n))[2:].zfill( namespace.n) print(f"String {namespace.bitstring} ") algs_oracles = [ (DeutschJozsaAlgorithm, COra(namespace.n), {}), (DeutschJozsaAlgorithm, BOra(namespace.n), {}), (BernsteinVaziraniAlgorithm, BPOra(namespace.n), { "s": namespace.bitstring }), (GroverAlgorithm, FSOra(namespace.n), { "s": namespace.bitstring }), ] for alg, oracle, kwargs in algs_oracles: print(alg) print(oracle) print(kwargs) oracle_rout = oracle.generate(**kwargs) pr, meas_qbits = alg.generate_program(namespace.n, oracle_rout) cr = pr.to_circ() if namespace.display: display(cr) # High amp_threshold, but it's fine for our oracles ress = alg.simulate_program(pr, qpu, job_args={ 'qubits': meas_qbits, 'amp_threshold': 1e-1 }) for res in ress: print(res.state, res.probability) print("***")
def test_reset(): """ Check the reset gate """ # Define a program prog = Program() qbits = prog.qalloc(2) prog.apply(X, qbits[0]) prog.reset(qbits) circ = prog.to_circ() # Submit circuit result = PyLinalg().submit(circ.to_job()) # Check result assert len(result) == 1 sample = result.raw_data[0] assert sample.state.int == 0 # Check intermediate measurements assert len(sample.intermediate_measurements) == 1 print(sample.intermediate_measurements) assert sample.intermediate_measurements[0].cbits == [True, False]
from qat.qpus import PyLinalg # Create a Program qprog = Program() # Number of qbits nbqbits = 2 # Allocate some qbits qbits = qprog.qalloc(nbqbits) # Apply some quantum Gates qprog.apply(H, qbits[0]) qprog.apply(CNOT, qbits[0], qbits[1]) print(qprog) # Export this program into a quantum circuit circuit = qprog.to_circ() # Create a Quantum Processor Unit linalgqpu = PyLinalg() # Create a job job = circuit.to_job() # Submit the job to the QPU result = linalgqpu.submit(job) # Iterate over the final state vector to get all final components for sample in result: print("State %s amplitude %s" % (sample.state, sample.amplitude))
def mean_op(op, circuit): qpu = LinAlg() job = circuit.to_job("OBS", observable=op) res = qpu.submit(job).value return res