def grover(n, s): p = Program() # create program ################## ## Define Gates ## ################## uf = build_uf(n, s) # build Uf p.defgate("Uf", uf) # define Uf ug = build_ug(n) # build Ug p.defgate("Ug", ug) # define Ug gate_string = build_gate_string(n) # useful for applying gates #################### ## Create Program ## #################### hadamard_n(n, p) # apply Hadamard to first N registers p.inst(X(n), H(n)) # apply X and N to last register to get minus for i in range(int( (np.pi * (2**(n / 2))) / 4)): # repeat (pi*2^(n/2))/4 times p.inst(("Uf" + gate_string)) # apply Uf to all registers hadamard_n(n, p) # apply Hadamard to first N p.inst(("Ug" + gate_string[:-2])) # apply Ug to first N hadamard_n(n, p) # apply Hadamard to first N for i in range(n): p.measure(i, i) # measure first N qubits, store in same registers return p
def main(n, s): p = Program() #make all the gates g = make_gate(n) Uf = make_UF_gate(n, s) p.defgate("RACL", g) p.defgate("UF", Uf) apply_Hn(p) #applying the first series of H gates to the first n qubits p.inst(X(n), H(n)) #get the |-> qubit into our system r = int((math.pi * (2**(n / 2)) / 4)) #r is the number of iteration for i in range(r): p.inst(("UF", *range(n))) #apply Uf apply_Hn( p) #applying the second series of H gates to the first n qubits p.inst(("RACL", *range(n))) #applying the unitary 2(|0><0|)^n - I^n apply_Hn( p) #applying the third series of H gates to the first n qubits #Make the Measurement classical_regs = [*range(n)] for i in range(n): p.measure(i, i) result = qvm.run(p, classical_regs) #print (result) #convert the result from binary to decimal t = 0 for i in range(n): t += (2**i) * result[0][n - 1 - i] print("the answer is ", t)
def test_basic_compile_defgate(): p = Program() p.inst(RX(pi, 0)) p.defgate("test", [[0, 1], [1, 0]]) p.inst(("test", 2)) p.inst(RZ(pi / 2, 0)) assert p == basic_compile(p)
def test_prog_merge(): prog_0 = Program(X(0)) prog_1 = Program(Y(0)) assert merge_programs([prog_0, prog_1]).out() == (prog_0 + prog_1).out() prog_0.defgate("test", np.eye(2)) prog_0.inst(("test", 0)) prog_1.defgate("test", np.eye(2)) prog_1.inst(("test", 0)) assert merge_programs([prog_0, prog_1]).out() == """DEFGATE test:
def add_damping_dephasing_noise(prog, T1, T2, gate_time): p = Program() p.defgate("noise", np.eye(2)) p.define_noisy_gate("noise", [0], damping_after_dephasing(T1, T2, gate_time)) for elem in prog: p.inst(elem) if isinstance(elem, Measurement): continue # skip measurement p.inst(("noise", 0)) return p
def _create_expected_program(): expected_prog = Program() expected_prog.defgate("SIMON_ORACLE", EXPECTED_SIMON_ORACLE) expected_prog.inst("H 0") expected_prog.inst("H 1") expected_prog.inst("H 2") expected_prog.inst("SIMON_ORACLE 5 4 3 2 1 0") expected_prog.inst("H 0") expected_prog.inst("H 1") expected_prog.inst("H 2") return expected_prog
def grover(marked_element): # Determine number of qubits needed n = len(marked_element) N = 2**n no_marked = int(marked_element, 2) # Determine number of times to iterate T = int(round(np.pi * np.sqrt(N) / 4 - 0.5)) print('Number of iterations T =', T) # Invoking and renaming Program and Connection qvm = QVMConnection() p = Program() # Step 1: Start with qubits in equal superposition for i in range(n): p.inst(H(i)) # Defining Oracle matrices: U_0 and U_f U_0 = np.eye(N) U_0[0][0] = -1 U_f = np.eye(N) U_f[no_marked][no_marked] = -1 # Defining Oracle gates p.defgate("U0", U_0) p.defgate("Uf", U_f) # Step 2: Repeat applications of U_f and D for i in range(T): # Apply U_f p.inst(("Uf", ) + tuple(range(n))) # Apply D for j in range(n): p.inst(H(j)) p.inst(("U0", ) + tuple(range(n))) for j in range(n): p.inst(H(j)) # Step 3: Measure all the qubits and output result for i in range(n): p.measure(i) # Run the program results = qvm.run(p, list(range(n)), 1) print('Element found =', results[0]) return results[0]
def setup(n, s): """ function to set up program Uf and special unitary """ p = Program() # initializes program Uf = np.identity(2**(n + 1)) # starts Uf as identity with size 2^ (n + 1) Uf[:, [2 * s, 2 * s + 1]] = Uf[:, [2 * s + 1, 2 * s ]] # switch the columns of the s^th qubit p.defgate("Uf", Uf) # defines array as unitary Uf special = -1 * np.identity( 2**n) # starts special as negative identity with size 2^n special[0, 0] = 1 # makes the very first entry positive p.defgate("special", special) # defines array as unitary special return p
def test_unitary_errors(qvm_unitary): # do we properly throw errors when non-gates are thrown into a unitary? # try measuring prog = Program() prog.inst([H(0), H(1)]) prog.measure(0, [0]) with pytest.raises(TypeError): qvm_unitary.unitary(prog) # try an undefined DefGate prog = Program() prog.defgate("hello", np.array([[0, 1], [1, 0]])) prog.inst(("hello2", 0)) with pytest.raises(TypeError): qvm_unitary.unitary(prog)
def test_if_then_inherits_defined_gates(): p1 = Program() p1.inst(H(0)) p1.measure(0, 0) p2 = Program() p2.defgate("A", np.array([[1., 0.], [0., 1.]])) p2.inst(("A", 0)) p3 = Program() p3.defgate("B", np.array([[0., 1.], [1., 0.]])) p3.inst(("B", 0)) p1.if_then(0, p2, p3) assert p2.defined_gates[0] in p1.defined_gates assert p3.defined_gates[0] in p1.defined_gates
def test_if_then_inherits_defined_gates(): p1 = Program() p1.inst(H(0)) p1.measure(0, MemoryReference("ro", 0)) p2 = Program() p2.defgate("A", np.array([[1.0, 0.0], [0.0, 1.0]])) p2.inst(("A", 0)) p3 = Program() p3.defgate("B", np.array([[0.0, 1.0], [1.0, 0.0]])) p3.inst(("B", 0)) p1.if_then(MemoryReference("ro", 0), p2, p3) assert p2.defined_gates[0] in p1.defined_gates assert p3.defined_gates[0] in p1.defined_gates
def _modified_noise_model_program_header(noise_model: NoiseModel) -> "Program": """ Generate the header for a pyquil Program that uses ``noise_model`` to overload noisy gates. The program header consists of 3 sections: - The ``DEFGATE`` statements that define the meaning of the newly introduced "noisy" gate names. - The ``PRAGMA ADD-KRAUS`` statements to overload these noisy gates on specific qubit targets with their noisy implementation. - THe ``PRAGMA READOUT-POVM`` statements that define the noisy readout per qubit. :param noise_model: The assumed noise model. :return: A quil Program with the noise pragmas. """ from pyquil.quil import Program p = Program() defgates: Set[str] = set() for k in noise_model.gates: # obtain ideal gate matrix and new, noisy name by looking it up in the NOISY_GATES dict try: ideal_gate, new_name = get_modified_noisy_gate( k.gate, tuple(k.params)) # if ideal version of gate has not yet been DEFGATE'd, do this if new_name not in defgates: p.defgate(new_name, ideal_gate) defgates.add(new_name) except NoisyGateUndefined: print( "WARNING: Could not find ideal gate definition for gate {}". format(k.gate), file=sys.stderr, ) new_name = k.gate # define noisy version of gate on specific targets p.define_noisy_gate(new_name, k.targets, k.kraus_ops) # define noisy readouts for q, ap in noise_model.assignment_probs.items(): p.define_noisy_readout(q, p00=ap[0, 0], p11=ap[1, 1]) return p
def deutsch_jozsa(f): # Determine number of qubits needed N = len(f) n = int(np.log2(N)) # Invoking and renaming qvm = QVMConnection() p = Program() # Applying first round of n Hadamards for i in range(n): p.inst(H(i)) # Defining the Oracle matrix U_f = np.eye(N) for i in range(N): if f[i] == '1': U_f[i][i] = -1 # Adding the Oracle matrix as a gate p.defgate("Uf", U_f) # Applying Oracle gate p.inst(("Uf", ) + tuple(range(n))) # Applying second run of n Hadamards for i in range(n): p.inst(H(i)) # Measure all the qubits and output result for i in range(n): p.measure(i, i) # Run the program classical_reg = list(range(n)) results = qvm.run(p, classical_reg, 1) y = 0 for i in range(n): y = y + 2**i * int(results[0][i]) if y == 0: print('Function is constant.') else: print('Function is balanced.')
def runAlg(cf): qvm = api.QVMConnection() p = Program() p.defgate('cF', cf) p.inst( # Prepare 0 as a superposition |0> + |1> # Prepare 1 as the Fourier Transform of |0> - |1> H(0), X(1), H(1), # one application of cF gate ('cF', 0, 1), # project and measure H(0), MEASURE(0, 0)) print(p) result = qvm.run(p, [0]) print(result) parseResult(result)
def _remove_reset_from_program(program: Program) -> Program: """ Trim the RESET from a program because in measure_observables it is re-added. :param program: Program to remove RESET(s) from. :return: Trimmed Program. """ definitions = [gate for gate in program.defined_gates] p = Program(*[inst for inst in program if not isinstance(inst, Reset)]) for definition in definitions: if isinstance(definition, DefPermutationGate): p.inst( DefPermutationGate(definition.name, list(definition.permutation))) else: p.defgate(definition.name, definition.matrix, definition.parameters) return p
def runGame(choice): qvm = api.QVMConnection() yourChoiceRegister = 0 buddyChoiceRegister = 1 p = Program() j = np.array([[1.0 / math.sqrt(2), 0, 0, 1.0j / math.sqrt(2)], [0, 1.0 / math.sqrt(2), 1.0j / math.sqrt(2), 0], [0, 1.0j / math.sqrt(2), 1.0 / math.sqrt(2), 0], [1.0j / math.sqrt(2), 0, 0, 1.0 / math.sqrt(2)]]) p.defgate('J', j) jt = np.array([[1.0 / math.sqrt(2), 0, 0, -1.0j / math.sqrt(2)], [0, 1.0 / math.sqrt(2), -1.0j / math.sqrt(2), 0], [0, -1.0j / math.sqrt(2), 1.0 / math.sqrt(2), 0], [-1.0j / math.sqrt(2), 0, 0, 1.0 / math.sqrt(2)]]) p.defgate('Jt', jt) if choice == 'snitch': yourAction = X(yourChoiceRegister) elif choice == 'silent': yourAction = I(yourChoiceRegister) print('your buddy will play the miracle move:') miracleMove = np.array([[1.0j / math.sqrt(2), 1.0 / math.sqrt(2)], [-1.0 / math.sqrt(2), -1.0j / math.sqrt(2)]]) p.defgate('MIRACLE', miracleMove) buddyAction = (('MIRACLE', buddyChoiceRegister)) p.inst(('J', 0, 1), yourAction, buddyAction, ('Jt', 0, 1), MEASURE(1, 1), MEASURE(0, 0)) print(p) result = qvm.run(p, [0, 1], 90) print(result) parseResult(result)
def add_noise_to_program(prog, T1=30e-6, T2=None, gate_time_1q=50e-9, gate_time_2q=150e-09): """ Add generic damping and dephasing noise to a program. This high-level function is provided as a convenience to investigate the effects of a generic noise model on a program. For more fine-grained control, please investigate the other methods available in the ``pyquil.kraus`` module. In an attempt to closely model the QPU, noisy versions of RX(+-pi/2) and CZ are provided; I and parametric RZ are noiseless, and other gates are not allowed. To use this function, you need to compile your program to this native gate set. The default noise parameters - T1 = 30 us - T2 = T1 / 2 - 1q gate time = 50 ns - 2q gate time = 150 ns are currently typical for near-term devices. This function will define new gates and add Kraus noise to these gates. It will translate the input program to use the noisy version of the gates. :param prog: A pyquil program consisting of I, RZ, CZ, and RX(+-pi/2) instructions :param T1: The T1 amplitude damping time. By default, this is 30 us :param T2: The T2 dephasing time. By default, this is one-half of the T1 time. :param gate_time_1q: The duration of the one-qubit gates, namely RX(+pi/2) and RX(-pi/2). By default, this is 50 ns. :param gate_time_2q: The duration of the two-qubit gates, namely CZ. By default, this is 150 ns. :return: A new program with noisy operators. """ if T2 is None: T2 = T1 / 2.0 from pyquil.quil import Program # Avoid circular dependency qubits, edges = _get_program_topology(prog) new_prog = Program() # Define noisy 1q gates for name, matrix in SINGLE_Q.items(): new_prog.defgate(name, matrix) k_ops = append_kraus_to_gate(damping_after_dephasing( T1=T1, T2=T2, gate_time=gate_time_1q), gate_matrix=matrix) for qubit in qubits: new_prog.define_noisy_gate(name, (qubit, ), k_ops) # Define noisy 2q gates for name, matrix in TWO_Q.items(): new_prog.defgate(name, matrix) k1q = damping_after_dephasing(T1=T1, T2=T2, gate_time=gate_time_2q) k_total = append_kraus_to_gate(tensor_kraus_maps(k1q, k1q), gate_matrix=matrix) for q1, q2 in edges: # Note! q1 must be less than q2. This is done in _get_program_topology assert q1 < q2 new_prog.define_noisy_gate(name, (q1, q2), k_total) # Translate noiseless gates to noisy gates. new_instrs = [_noisy_instruction(instruction) for instruction in prog] new_prog.inst(new_instrs) return new_prog
d_prog.inst(I(qubits[0]), I(qubits[1])) #print(qvm.wavefunction(d_prog)) # \psi_1: Put ancilla qubit into 1 d_prog.inst(X(qubits[1])) #print(qvm.wavefunction(d_prog)) # \psi_2: Apply Hadamard gates d_prog.inst(H(qubits[0]), H(qubits[1])) #print(qvm.wavefunction(d_prog)) # \psi_3: Apply Quantum Oracle # Quantum oracle ORACLE_GATE_NAME = "DEUTSCH_JOZSA_ORACLE" oracle = np.array([[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]) d_prog.defgate(ORACLE_GATE_NAME, oracle) d_prog.inst((ORACLE_GATE_NAME, qubits[0], qubits[1])) #print(qvm.wavefunction(d_prog)) # \psi_4: Apply Hadamard gate d_prog.inst(H(qubits[0])) #print(qvm.wavefunction(d_prog)) # \psi_5: Measure d_prog.measure(qubit_index=qubits[0], classical_reg=0) # Run ret = qvm.run(d_prog, classical_addresses=[0]) if ret[0][0] == 0: print("The function is constant") else:
def counterpoint(): pitch_index = int(request.args['pitch_index']) #print("pitch_index: ", pitch_index) if (pitch_index >= NUM_PITCHES): pitch_index %= (NUM_PITCHES - 1) melodic_degrees = request.args['melodic_degrees'].split(",") #print("melodic_degrees: ", melodic_degrees) harmonic_degrees = request.args['harmonic_degrees'].split(",") #print("harmonic_degrees: ", harmonic_degrees) if (len(melodic_degrees) == DEGREES_OF_FREEDOM and len(harmonic_degrees) == DEGREES_OF_FREEDOM and 0 <= pitch_index < NUM_PITCHES): melodic_gate_matrix = compute_matrix(melodic_degrees) harmonic_gate_matrix = compute_matrix(harmonic_degrees) qvm = api.QVMConnection() p = Program() p.defgate("MELODIC_GATE", melodic_gate_matrix) p.defgate("HARMONIC_GATE", harmonic_gate_matrix) # Convert the pitch index to a binary string, and use it to create # the initial gates on the three wires of the quantum circuit, # least significant qubit on the lowest number wire. # Also, place initial pitch into Lead Note #1 qubit_string = format(pitch_index, '03b') for idx, qubit_char in enumerate(qubit_string): if qubit_char == '0': p.inst(I(NUM_CIRCUIT_WIRES - 1 - idx)) p.inst(FALSE(NUM_CIRCUIT_WIRES - 1 - idx)) else: p.inst(X(NUM_CIRCUIT_WIRES - 1 - idx)) p.inst(TRUE(NUM_CIRCUIT_WIRES - 1 - idx)) p.inst( RawInstr(""" DEFCIRCUIT ACTIVE-RESET q scratch_bit: MEASURE q scratch_bit JUMP-UNLESS @END-ACTIVE-SET scratch_bit X q LABEL @END-ACTIVE-SET DEFCIRCUIT ACTIVE-SET q scratch_bit: MEASURE q scratch_bit JUMP-WHEN @END-ACTIVE-RESET scratch_bit X q LABEL @END-ACTIVE-RESET # == Produce melody == # ---- Produce pitch for Lead Note #2 and replicate measurement results into qubits ---- MELODIC_GATE 2 1 0 MEASURE 2 [5] MEASURE 1 [4] MEASURE 0 [3] JUMP-UNLESS @RESET-Q5 [5] ACTIVE-SET 2 [63] JUMP @END-Q5 LABEL @RESET-Q5 ACTIVE-RESET 5 [63] LABEL @END-Q5 JUMP-UNLESS @RESET-Q4 [4] ACTIVE-SET 1 [63] JUMP @END-Q4 LABEL @RESET-Q4 ACTIVE-RESET 4 [63] LABEL @END-Q4 JUMP-UNLESS @RESET-Q3 [3] ACTIVE-SET 0 [63] JUMP @END-Q3 LABEL @RESET-Q3 ACTIVE-RESET 3 [63] LABEL @END-Q3 # ---- Produce pitch for Lead Note #3 and replicate measurement results into qubits ---- MELODIC_GATE 2 1 0 MEASURE 2 [8] MEASURE 1 [7] MEASURE 0 [6] JUMP-UNLESS @RESET-Q8 [8] ACTIVE-SET 2 [63] JUMP @END-Q8 LABEL @RESET-Q8 ACTIVE-RESET 2 [63] LABEL @END-Q8 JUMP-UNLESS @RESET-Q7 [7] ACTIVE-SET 1 [63] JUMP @END-Q7 LABEL @RESET-Q7 ACTIVE-RESET 1 [63] LABEL @END-Q7 JUMP-UNLESS @RESET-Q6 [6] ACTIVE-SET 0 [63] JUMP @END-Q6 LABEL @RESET-Q6 ACTIVE-RESET 0 [63] LABEL @END-Q6 # ---- Produce pitch for Lead Note #4 and replicate measurement results into qubits ---- MELODIC_GATE 2 1 0 MEASURE 2 [11] MEASURE 1 [10] MEASURE 0 [9] JUMP-UNLESS @RESET-Q11 [11] ACTIVE-SET 2 [63] JUMP @END-Q11 LABEL @RESET-Q11 ACTIVE-RESET 2 [63] LABEL @END-Q11 JUMP-UNLESS @RESET-Q10 [10] ACTIVE-SET 1 [63] JUMP @END-Q10 LABEL @RESET-Q10 ACTIVE-RESET 1 [63] LABEL @END-Q10 JUMP-UNLESS @RESET-Q9 [9] ACTIVE-SET 0 [63] JUMP @END-Q9 LABEL @RESET-Q9 ACTIVE-RESET 0 [63] LABEL @END-Q9 # ---- Produce pitch for Lead Note #5 and replicate measurement results into qubits ---- MELODIC_GATE 2 1 0 MEASURE 2 [14] MEASURE 1 [13] MEASURE 0 [12] JUMP-UNLESS @RESET-Q14 [14] ACTIVE-SET 2 [63] JUMP @END-Q14 LABEL @RESET-Q14 ACTIVE-RESET 2 [63] LABEL @END-Q14 JUMP-UNLESS @RESET-Q13 [13] ACTIVE-SET 1 [63] JUMP @END-Q13 LABEL @RESET-Q13 ACTIVE-RESET 1 [63] LABEL @END-Q13 JUMP-UNLESS @RESET-Q12 [12] ACTIVE-SET 0 [63] JUMP @END-Q12 LABEL @RESET-Q12 ACTIVE-RESET 0 [63] LABEL @END-Q12 # ---- Produce pitch for Lead Note #6 and replicate measurement results into qubits ---- MELODIC_GATE 2 1 0 MEASURE 2 [17] MEASURE 1 [16] MEASURE 0 [15] JUMP-UNLESS @RESET-Q17 [17] ACTIVE-SET 2 [63] JUMP @END-Q17 LABEL @RESET-Q17 ACTIVE-RESET 2 [63] LABEL @END-Q17 JUMP-UNLESS @RESET-Q16 [16] ACTIVE-SET 1 [63] JUMP @END-Q16 LABEL @RESET-Q16 ACTIVE-RESET 1 [63] LABEL @END-Q16 JUMP-UNLESS @RESET-Q15 [15] ACTIVE-SET 0 [63] JUMP @END-Q15 LABEL @RESET-Q15 ACTIVE-RESET 0 [63] LABEL @END-Q15 # ---- Produce pitch for Lead Note #7 and replicate measurement results into qubits ---- MELODIC_GATE 2 1 0 MEASURE 2 [20] MEASURE 1 [19] MEASURE 0 [18] # == Produce harmony == # ---- Retrieve pitch for Lead Note #1, replicate it into qubits, and produce pitch for Harmony Note #1a ---- JUMP-UNLESS @RESET-Q2a [2] ACTIVE-SET 2 [63] JUMP @END-Q2a LABEL @RESET-Q2a ACTIVE-RESET 2 [63] LABEL @END-Q2a JUMP-UNLESS @RESET-Q1a [1] ACTIVE-SET 1 [63] JUMP @END-Q1a LABEL @RESET-Q1a ACTIVE-RESET 1 [63] LABEL @END-Q1a JUMP-UNLESS @RESET-Q0a [0] ACTIVE-SET 0 [63] JUMP @END-Q0a LABEL @RESET-Q0a ACTIVE-RESET 0 [63] LABEL @END-Q0a HARMONIC_GATE 2 1 0 MEASURE 2 [23] MEASURE 1 [22] MEASURE 0 [21] # ---- Replicate Harmony Note #1a into qubits, and produce pitch for Harmony Note #1b ---- JUMP-UNLESS @RESET-Q23 [23] ACTIVE-SET 2 [63] JUMP @END-Q23 LABEL @RESET-Q23 ACTIVE-RESET 2 [63] LABEL @END-Q23 JUMP-UNLESS @RESET-Q22 [22] ACTIVE-SET 1 [63] JUMP @END-Q22 LABEL @RESET-Q22 ACTIVE-RESET 1 [63] LABEL @END-Q22 JUMP-UNLESS @RESET-Q21 [21] ACTIVE-SET 0 [63] JUMP @END-Q21 LABEL @RESET-Q21 ACTIVE-RESET 0 [63] LABEL @END-Q21 MELODIC_GATE 2 1 0 MEASURE 2 [44] MEASURE 1 [43] MEASURE 0 [42] # ---- Retrieve pitch for Lead Note #2, replicate it into qubits, and produce pitch for Harmony Note #2a ---- JUMP-UNLESS @RESET-Q5a [5] ACTIVE-SET 2 [63] JUMP @END-Q5a LABEL @RESET-Q5a ACTIVE-RESET 2 [63] LABEL @END-Q5a JUMP-UNLESS @RESET-Q4a [4] ACTIVE-SET 1 [63] JUMP @END-Q4a LABEL @RESET-Q4a ACTIVE-RESET 1 [63] LABEL @END-Q4a JUMP-UNLESS @RESET-Q3a [3] ACTIVE-SET 0 [63] JUMP @END-Q3a LABEL @RESET-Q3a ACTIVE-RESET 0 [63] LABEL @END-Q3a HARMONIC_GATE 2 1 0 MEASURE 2 [26] MEASURE 1 [25] MEASURE 0 [24] # ---- Replicate Harmony Note #2a into qubits, and produce pitch for Harmony Note #2b ---- JUMP-UNLESS @RESET-Q26 [26] ACTIVE-SET 2 [63] JUMP @END-Q26 LABEL @RESET-Q26 ACTIVE-RESET 2 [63] LABEL @END-Q26 JUMP-UNLESS @RESET-Q25 [25] ACTIVE-SET 1 [63] JUMP @END-Q25 LABEL @RESET-Q25 ACTIVE-RESET 1 [63] LABEL @END-Q25 JUMP-UNLESS @RESET-Q24 [24] ACTIVE-SET 0 [63] JUMP @END-Q24 LABEL @RESET-Q24 ACTIVE-RESET 0 [63] LABEL @END-Q24 MELODIC_GATE 2 1 0 MEASURE 2 [47] MEASURE 1 [46] MEASURE 0 [45] # ---- Retrieve pitch for Lead Note #3, replicate it into qubits, and produce pitch for Harmony Note #3a ---- JUMP-UNLESS @RESET-Q8a [8] ACTIVE-SET 2 [63] JUMP @END-Q8a LABEL @RESET-Q8a ACTIVE-RESET 2 [63] LABEL @END-Q8a JUMP-UNLESS @RESET-Q7a [7] ACTIVE-SET 1 [63] JUMP @END-Q7a LABEL @RESET-Q7a ACTIVE-RESET 1 [63] LABEL @END-Q7a JUMP-UNLESS @RESET-Q6a [6] ACTIVE-SET 0 [63] JUMP @END-Q6a LABEL @RESET-Q6a ACTIVE-RESET 0 [63] LABEL @END-Q6a HARMONIC_GATE 2 1 0 MEASURE 2 [29] MEASURE 1 [28] MEASURE 0 [27] # ---- Replicate Harmony Note #3a into qubits, and produce pitch for Harmony Note #3b ---- JUMP-UNLESS @RESET-Q29 [29] ACTIVE-SET 2 [63] JUMP @END-Q29 LABEL @RESET-Q29 ACTIVE-RESET 2 [63] LABEL @END-Q29 JUMP-UNLESS @RESET-Q28 [28] ACTIVE-SET 1 [63] JUMP @END-Q28 LABEL @RESET-Q28 ACTIVE-RESET 1 [63] LABEL @END-Q28 JUMP-UNLESS @RESET-Q27 [27] ACTIVE-SET 0 [63] JUMP @END-Q27 LABEL @RESET-Q27 ACTIVE-RESET 0 [63] LABEL @END-Q27 MELODIC_GATE 2 1 0 MEASURE 2 [50] MEASURE 1 [49] MEASURE 0 [48] # ---- Retrieve pitch for Lead Note #4, replicate it into qubits, and produce pitch for Harmony Note #4a ---- JUMP-UNLESS @RESET-Q11a [11] ACTIVE-SET 2 [63] JUMP @END-Q11a LABEL @RESET-Q11a ACTIVE-RESET 2 [63] LABEL @END-Q11a JUMP-UNLESS @RESET-Q10a [10] ACTIVE-SET 1 [63] JUMP @END-Q10a LABEL @RESET-Q10a ACTIVE-RESET 1 [63] LABEL @END-Q10a JUMP-UNLESS @RESET-Q9a [9] ACTIVE-SET 0 [63] JUMP @END-Q9a LABEL @RESET-Q9a ACTIVE-RESET 0 [63] LABEL @END-Q9a HARMONIC_GATE 2 1 0 MEASURE 2 [32] MEASURE 1 [31] MEASURE 0 [30] # ---- Replicate Harmony Note #4a into qubits, and produce pitch for Harmony Note #4b ---- JUMP-UNLESS @RESET-Q32 [32] ACTIVE-SET 2 [63] JUMP @END-Q32 LABEL @RESET-Q32 ACTIVE-RESET 2 [63] LABEL @END-Q32 JUMP-UNLESS @RESET-Q31 [31] ACTIVE-SET 1 [63] JUMP @END-Q31 LABEL @RESET-Q31 ACTIVE-RESET 1 [63] LABEL @END-Q31 JUMP-UNLESS @RESET-Q30 [30] ACTIVE-SET 0 [63] JUMP @END-Q30 LABEL @RESET-Q30 ACTIVE-RESET 0 [63] LABEL @END-Q30 MELODIC_GATE 2 1 0 MEASURE 2 [53] MEASURE 1 [52] MEASURE 0 [51] # ---- Retrieve pitch for Lead Note #5, replicate it into qubits, and produce pitch for Harmony Note #5a ---- JUMP-UNLESS @RESET-Q14a [14] ACTIVE-SET 2 [63] JUMP @END-Q14a LABEL @RESET-Q14a ACTIVE-RESET 2 [63] LABEL @END-Q14a JUMP-UNLESS @RESET-Q13a [13] ACTIVE-SET 1 [63] JUMP @END-Q13a LABEL @RESET-Q13a ACTIVE-RESET 1 [63] LABEL @END-Q13a JUMP-UNLESS @RESET-Q12a [12] ACTIVE-SET 0 [63] JUMP @END-Q12a LABEL @RESET-Q12a ACTIVE-RESET 0 [63] LABEL @END-Q12a HARMONIC_GATE 2 1 0 MEASURE 2 [35] MEASURE 1 [34] MEASURE 0 [33] # ---- Replicate Harmony Note #5a into qubits, and produce pitch for Harmony Note #5b ---- JUMP-UNLESS @RESET-Q35 [35] ACTIVE-SET 2 [63] JUMP @END-Q35 LABEL @RESET-Q35 ACTIVE-RESET 2 [63] LABEL @END-Q35 JUMP-UNLESS @RESET-Q34 [34] ACTIVE-SET 1 [63] JUMP @END-Q34 LABEL @RESET-Q34 ACTIVE-RESET 1 [63] LABEL @END-Q34 JUMP-UNLESS @RESET-Q33 [33] ACTIVE-SET 0 [63] JUMP @END-Q33 LABEL @RESET-Q33 ACTIVE-RESET 0 [63] LABEL @END-Q33 MELODIC_GATE 2 1 0 MEASURE 2 [56] MEASURE 1 [55] MEASURE 0 [54] # ---- Retrieve pitch for Lead Note #6, replicate it into qubits, and produce pitch for Harmony Note #6a ---- JUMP-UNLESS @RESET-Q17a [17] ACTIVE-SET 2 [63] JUMP @END-Q17a LABEL @RESET-Q17a ACTIVE-RESET 2 [63] LABEL @END-Q17a JUMP-UNLESS @RESET-Q16a [16] ACTIVE-SET 1 [63] JUMP @END-Q16a LABEL @RESET-Q16a ACTIVE-RESET 1 [63] LABEL @END-Q16a JUMP-UNLESS @RESET-Q15a [15] ACTIVE-SET 0 [63] JUMP @END-Q15a LABEL @RESET-Q15a ACTIVE-RESET 0 [63] LABEL @END-Q15a HARMONIC_GATE 2 1 0 MEASURE 2 [38] MEASURE 1 [37] MEASURE 0 [36] # ---- Replicate Harmony Note #6a into qubits, and produce pitch for Harmony Note #6b ---- JUMP-UNLESS @RESET-Q38 [38] ACTIVE-SET 2 [63] JUMP @END-Q38 LABEL @RESET-Q38 ACTIVE-RESET 2 [63] LABEL @END-Q38 JUMP-UNLESS @RESET-Q37 [37] ACTIVE-SET 1 [63] JUMP @END-Q37 LABEL @RESET-Q37 ACTIVE-RESET 1 [63] LABEL @END-Q37 JUMP-UNLESS @RESET-Q36 [36] ACTIVE-SET 0 [63] JUMP @END-Q36 LABEL @RESET-Q36 ACTIVE-RESET 0 [63] LABEL @END-Q36 MELODIC_GATE 2 1 0 MEASURE 2 [59] MEASURE 1 [58] MEASURE 0 [57] # ---- Retrieve pitch for Lead Note #7, replicate it into qubits, and produce pitch for Harmony Note #7a ---- JUMP-UNLESS @RESET-Q20a [20] ACTIVE-SET 2 [63] JUMP @END-Q20a LABEL @RESET-Q20a ACTIVE-RESET 2 [63] LABEL @END-Q20a JUMP-UNLESS @RESET-Q19a [19] ACTIVE-SET 1 [63] JUMP @END-Q19a LABEL @RESET-Q19a ACTIVE-RESET 1 [63] LABEL @END-Q19a JUMP-UNLESS @RESET-Q18a [18] ACTIVE-SET 0 [63] JUMP @END-Q18a LABEL @RESET-Q18a ACTIVE-RESET 0 [63] LABEL @END-Q18a HARMONIC_GATE 2 1 0 MEASURE 2 [41] MEASURE 1 [40] MEASURE 0 [39] # ---- Replicate Harmony Note #7a into qubits, and produce pitch for Harmony Note #7b ---- JUMP-UNLESS @RESET-Q41 [41] ACTIVE-SET 2 [63] JUMP @END-Q41 LABEL @RESET-Q41 ACTIVE-RESET 2 [63] LABEL @END-Q41 JUMP-UNLESS @RESET-Q40 [40] ACTIVE-SET 1 [63] JUMP @END-Q40 LABEL @RESET-Q40 ACTIVE-RESET 1 [63] LABEL @END-Q40 JUMP-UNLESS @RESET-Q39 [39] ACTIVE-SET 0 [63] JUMP @END-Q39 LABEL @RESET-Q39 ACTIVE-RESET 0 [63] LABEL @END-Q39 MELODIC_GATE 2 1 0 MEASURE 2 [62] MEASURE 1 [61] MEASURE 0 [60] """)) #print(p) use_simulator = True if use_simulator: num_runs = 1 res = qvm.run(p, [ 2, 1, 0, 5, 4, 3, 8, 7, 6, 11, 10, 9, 14, 13, 12, 17, 16, 15, 20, 19, 18, 23, 22, 21, 44, 43, 42, 26, 25, 24, 47, 46, 45, 29, 28, 27, 50, 49, 48, 32, 31, 30, 53, 52, 51, 35, 34, 33, 56, 55, 54, 38, 37, 36, 59, 58, 57, 41, 40, 39, 62, 61, 60 ], num_runs) #print(res) all_note_nums = create_note_nums_array(res[0]) melody_note_nums = all_note_nums[0:7] harmony_note_nums = all_note_nums[7:21] else: melody_note_nums = [0, 1, 2, 3, 4, 5, 6] harmony_note_nums = [2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 4, 3, 2] ret_dict = { "melody": melody_note_nums, "harmony": harmony_note_nums, "lilypond": create_lilypond(melody_note_nums, harmony_note_nums), "toy_piano": create_toy_piano(melody_note_nums, harmony_note_nums) } return jsonify(ret_dict)
def counterpoint_degraded(): pitch_index = int(request.args['pitch_index']) if (pitch_index >= NUM_PITCHES): pitch_index %= (NUM_PITCHES - 1) #print("pitch_index: ", pitch_index) species = int(request.args['species']) #print("species: ", species) melodic_degrees = request.args['melodic_degrees'].split(",") #print("melodic_degrees: ", melodic_degrees) harmonic_degrees = request.args['harmonic_degrees'].split(",") #print("harmonic_degrees: ", harmonic_degrees) if (len(melodic_degrees) == DEGREES_OF_FREEDOM and len(harmonic_degrees) == DEGREES_OF_FREEDOM and 1 <= species <= 3 and 0 <= pitch_index < NUM_PITCHES): #TODO: Move/change this rot_melodic_circuit = compute_circuit(melodic_degrees) print("rot_melodic_circuit:") print(rot_melodic_circuit) rot_harmonic_circuit = compute_circuit(harmonic_degrees) melodic_gate_matrix = compute_matrix(melodic_degrees) harmonic_gate_matrix = compute_matrix(harmonic_degrees) harmony_notes_factor = 2**( species - 1) # Number of harmony notes for each melody note num_composition_bits = TOTAL_MELODY_NOTES * (harmony_notes_factor + 1) * NUM_CIRCUIT_WIRES qvm = api.QVMConnection() composition_bits = [0] * num_composition_bits # Convert the pitch index to a binary string, and place into the # composition_bits array, least significant bits in lowest elements of array qubit_string = format(pitch_index, '03b') for idx, qubit_char in enumerate(qubit_string): if qubit_char == '0': composition_bits[idx] = 0 else: composition_bits[idx] = 1 num_runs = 1 for melody_note_idx in range(0, TOTAL_MELODY_NOTES): # if (melody_note_idx < TOTAL_MELODY_NOTES - 1): p = Program() if USE_ROTATIONS_CIRCUITS: nop = 0 #p.inst(copy.deepcopy(rot_melodic_circuit)) else: p.defgate("MELODIC_GATE", melodic_gate_matrix) for bit_idx in range(0, NUM_CIRCUIT_WIRES): if (composition_bits[melody_note_idx * NUM_CIRCUIT_WIRES + bit_idx] == 0): p.inst(I(NUM_CIRCUIT_WIRES - 1 - bit_idx)) else: p.inst(X(NUM_CIRCUIT_WIRES - 1 - bit_idx)) if USE_ROTATIONS_CIRCUITS: p.inst(copy.deepcopy(rot_melodic_circuit)) p.inst().measure(0, 0).measure(1, 1) \ .measure(2, 2) print("rot_melodic_circuit:") #print(p) else: p.inst(("MELODIC_GATE", 2, 1, 0)) \ .measure(0, 0).measure(1, 1) \ .measure(2, 2) print("matrix_melodic_circuit:") #print(p) result = qvm.run(p, [2, 1, 0], num_runs) bits = result[0] for bit_idx in range(0, NUM_CIRCUIT_WIRES): composition_bits[(melody_note_idx + 1) * NUM_CIRCUIT_WIRES + bit_idx] = bits[bit_idx] #print(composition_bits) measured_pitch = bits[0] * 4 + bits[1] * 2 + bits[2] #print("melody melody_note_idx measured_pitch") #print(melody_note_idx) #print(measured_pitch) # Now compute a harmony note for the melody note print("Now compute a harmony note for the melody notev") p = Program() if USE_ROTATIONS_CIRCUITS: nop = 0 #p = copy.deepcopy(rot_harmonic_circuit) else: p.defgate("HARMONIC_GATE", harmonic_gate_matrix) for bit_idx in range(0, NUM_CIRCUIT_WIRES): if composition_bits[melody_note_idx * NUM_CIRCUIT_WIRES + bit_idx] == 0: p.inst(I(NUM_CIRCUIT_WIRES - 1 - bit_idx)) else: p.inst(X(NUM_CIRCUIT_WIRES - 1 - bit_idx)) if USE_ROTATIONS_CIRCUITS: p.inst(copy.deepcopy(rot_harmonic_circuit)) p.inst().measure(0, 0).measure(1, 1) \ .measure(2, 2) print("rot_harmonic_circuit:") #print(p) else: p.inst(("HARMONIC_GATE", 2, 1, 0)) \ .measure(0, 0).measure(1, 1) \ .measure(2, 2) print("matrix_harmonic_circuit:") #print(p) result = qvm.run(p, [2, 1, 0], num_runs) bits = result[0] for bit_idx in range(0, NUM_CIRCUIT_WIRES): composition_bits[(melody_note_idx * NUM_CIRCUIT_WIRES * harmony_notes_factor) + (TOTAL_MELODY_NOTES * NUM_CIRCUIT_WIRES) + bit_idx] = bits[bit_idx] #print(composition_bits) measured_pitch = bits[0] * 4 + bits[1] * 2 + bits[2] #print("harmony melody_note_idx measured_pitch") #print(melody_note_idx) #print(measured_pitch) # Now compute melody notes to follow the harmony note print("Now compute melody notes to follow the harmony note") for harmony_note_idx in range(1, harmony_notes_factor): p = Program() if USE_ROTATIONS_CIRCUITS: nop = 0 #p = copy.deepcopy(rot_melodic_circuit) else: p.defgate("MELODIC_GATE", melodic_gate_matrix) for bit_idx in range(0, NUM_CIRCUIT_WIRES): if (composition_bits[ (melody_note_idx * NUM_CIRCUIT_WIRES * harmony_notes_factor) + ((harmony_note_idx - 1) * NUM_CIRCUIT_WIRES) + (TOTAL_MELODY_NOTES * NUM_CIRCUIT_WIRES) + bit_idx] == 0): p.inst(I(NUM_CIRCUIT_WIRES - 1 - bit_idx)) else: p.inst(X(NUM_CIRCUIT_WIRES - 1 - bit_idx)) if USE_ROTATIONS_CIRCUITS: p.inst(copy.deepcopy(rot_melodic_circuit)) p.inst().measure(0, 0).measure(1, 1) \ .measure(2, 2) print("rot_melodic_circuit:") #print(p) else: p.inst(("MELODIC_GATE", 2, 1, 0)) \ .measure(0, 0).measure(1, 1) \ .measure(2, 2) print("matrix_melodic_circuit:") #print(p) result = qvm.run(p, [2, 1, 0], num_runs) bits = result[0] for bit_idx in range(0, NUM_CIRCUIT_WIRES): composition_bits[(melody_note_idx * NUM_CIRCUIT_WIRES * harmony_notes_factor) + ((harmony_note_idx) * NUM_CIRCUIT_WIRES) + (TOTAL_MELODY_NOTES * NUM_CIRCUIT_WIRES) + bit_idx] = bits[bit_idx] #print(composition_bits) measured_pitch = bits[0] * 4 + bits[1] * 2 + bits[2] #print("melody after harmony melody_note_idx measured_pitch") #print(melody_note_idx) #print(measured_pitch) all_note_nums = create_note_nums_array(composition_bits) melody_note_nums = all_note_nums[0:TOTAL_MELODY_NOTES] harmony_note_nums = all_note_nums[7:num_composition_bits] ret_dict = { "melody": melody_note_nums, "harmony": harmony_note_nums, "lilypond": create_lilypond(melody_note_nums, harmony_note_nums), "toy_piano": create_toy_piano(melody_note_nums, harmony_note_nums) } return jsonify(ret_dict)
#============================================================================== qvm = QVMConnection() gr_prog = Program() # \psi_0: Qubits initilization qubits = list(reversed(range(N))) gr_prog.inst([I(q) for q in qubits]) #print(qvm.wavefunction(gr_prog)) # \psi_1: Apply Hadamard gates gr_prog.inst([H(q) for q in qubits]) #print(qvm.wavefunction(gr_prog)) # Define quantum oracle ORACLE_GATE_NAME = "GROVER_ORACLE" gr_prog.defgate(ORACLE_GATE_NAME, oracle) # Define inversion around the mean DIFFUSION_GATE_NAME = "DIFFUSION" diffusion = 2.0 * np.full((2**N, 2**N), 1/(2**N)) - np.eye(2**N) gr_prog.defgate(DIFFUSION_GATE_NAME, diffusion) # Number of algorithm iterations N_ITER = int(np.pi / 4 * np.sqrt(2**N)) # Loop for i in range(N_ITER): # \psi_2^i: Apply Quantum Oracle gr_prog.inst(tuple([ORACLE_GATE_NAME] + qubits)) #print(qvm.wavefunction(gr_prog))
import numpy as np from pyquil.quil import Program from pyquil.api import QVMConnection from pyquil.gates import X, Z, Y, H, I from pyquilcompiler import compiletoquil # Invoking and renaming qvm = QVMConnection() p = Program() # Gate implementation p.inst(H(0), H(1)) # Assuming the given function give the matrix Ufma = np.diag([-1, 1, -1, 1]) p.defgate("Uf", Ufma) p.inst(("Uf", 0, 1)) p.inst(H(0), H(1)) # Measurements p.measure(0, 0) p.measure(1, 1) compiletoquil(p) # Running the program cr = [] results = qvm.run(p, cr, 4) print(results)
# make scren blue screen.fill(blue) # empty out results from dartboard_B if len(results_B) > 0: results_B.pop() # run the common parts of the program p = Program() if score < 10: a = np.sqrt(1 / 2.) elif (score >= 10) and (score < 20): a = np.sqrt(3 / 4.) else: a = np.sqrt(1.) b = np.sqrt(1 - np.square(a)) Uf_ = np.array([[a, b], [b, -a]]) p.defgate("Uf", Uf_) # set dartboard_A center, and calculate results_B in either case if results_A == [[0]]: dartboard_A_center = [size_x // 2, size_y // 2 - dartboard_offset] # run the program for this case p.inst(I(0)) p.inst(("Uf", 0)) p.measure(0, [0]) results_B = cxn.run(p, [0]) elif results_A == [[1]]: dartboard_A_center = [size_x // 2, size_y // 2 + dartboard_offset] # run the program for this case p.inst(X(0)) p.inst(("Uf", 0)) p.measure(0, [0]) results_B = cxn.run(p, [0])
# draw DESTRUCTION! log pygame.draw.rect(screen, (0, 0, 0), (0, dest_y, size_x, dest_width)) ### Carry out program # initialize program qvm = api.QVMConnection() p = Program() ##### Q's 1st stochastic move # set the parameters for the random move prob = Q_prob1 # create a dummy gate a = np.random.rand() b = np.sqrt(1 - np.square(a)) Uf_ = U_(a, b) # perform the random move p.defgate("Uf_Q1", Uf_) p.inst(("Uf_Q1", 0)) p.define_noisy_gate( "Uf_Q1", [0], [np.sqrt(prob) * X_, np.sqrt(1 - prob) * I_]) ##### Picard's quantum move p.defgate("P1", U_(P_a1, P_b1)) p.inst(("P1", 0)) ##### Q's 2nd stochastic move # set the parameters for the random move prob = Q_prob2 # create a dummy gate a = np.random.rand() b = np.sqrt(1 - np.square(a))
# draw DESTRUCTION! log pygame.draw.rect(screen, (0, 0, 0), (0, dest_y, size_x, dest_width)) ### Carry out program # initialize program qvm = api.QVMConnection() p = Program() ##### Q's 1st stochastic move # set the parameters for the random move prob = Q_prob1 # create a dummy gate a = np.random.rand() b = np.sqrt(1 - np.square(a)) Uf_ = U_(a, b) # perform the random move p.defgate("Uf_Q1", Uf_) p.inst(("Uf_Q1", 0)) p.define_noisy_gate( "Uf_Q1", [0], [np.sqrt(prob) * X_, np.sqrt(1 - prob) * I_]) ##### Picard's stochastic move # set the parameters for the random move prob = picard_prob # create a dummy gate a = np.random.rand() b = np.sqrt(1 - np.square(a)) Uf_ = U_(a, b) # perform the random move p.defgate("Uf_P", Uf_) p.inst(("Uf_P", 0))
# populate unitary matrix for k, v in d_bb.items(): unitary_rep += np.kron( projection_op(k), np.eye(2) + v * (-np.eye(2) + np.array([[0, 1], [1, 0]]))) return unitary_rep p = Program() # pick number of control qubits to be used n = 5 # Define U_f p.defgate("U_f", black_box(n, balanced=False)) # Prepare the starting state |0>^(\otimes n) x (1/sqrt[2])*(|0> - |1>) for n_ in range(1, n + 1): p.inst(I(n_)) p.inst(X(0)) p.inst(H(0)) # Apply H^(\otimes n) for n_ in range(1, n + 1): p.inst(H(n_)) # Apply U_f p.inst(("U_f", ) + tuple(range(n + 1)[::-1])) # Apply final H^(\otimes n)
print(qvm.wavefunction(grover_circuit)) # Step 2 of Grover's Algorithm - Define quantum oracle print("\nStep 2 : Define quantum oracle") print(printline1) oracle = np.zeros(shape=(2**N, 2**N)) for b in range(2**N): if np.binary_repr(b, N) == queen_position_binary: oracle[b, b] = -1 else: oracle[b, b] = 1 print("The corresponding ORACLE used is\n\n") print(oracle) ORACLE_GATE_NAME = "GROVER_ORACLE" grover_circuit.defgate(ORACLE_GATE_NAME, oracle) # Step 3 of Grover's Algorithm - Define inversion around the mean # Grover's Diffusion operator : D = 2A - I print("\nStep 3 : Define inversion around the mean") print(printline1) DIFFUSION_GATE_NAME = "DIFFUSION" diffusion = 2.0 * np.full((2**N, 2**N), 1 / (2**N)) - np.eye(2**N) print("Corresponding Grover's Diffusion Operator\n\n", diffusion) grover_circuit.defgate(DIFFUSION_GATE_NAME, diffusion) # Number of algorithm iterations N_ITER = int(np.pi / 4 * np.sqrt(2**N)) # O(sqrt(number_of_cards)) : Apply ORACLE and DIFFUSION operator N_ITER times count = 1
(0, 0, 0)) screen.blit(text_rect_Q_x, [size_x - 400, 50]) text_size_ = font.render("|a|^2: " + str(np.square(Q_a2)), True, (0, 0, 0)) screen.blit(text_size_, [size_x - 400, 20]) # program is now ready to be run run_quantum_program = True if run_quantum_program: ### Carry out program # initialize program qvm = api.QVMConnection() p = Program() ##### Q's 1st move p.defgate("Q1", U_(Q_a1, Q_b1)) p.inst(("Q1", 0)) ##### Picard's 1st move p.defgate("P1", U_(P_a1, P_b1)) p.inst(("P1", 0)) ##### Q's 2nd move p.defgate("Q2", U_(Q_a2, Q_b2)) p.inst(("Q2", 0)) ##### Measurement p.inst(MEASURE(0, [0])) result = qvm.run(p, [0], trials=100) result_1s = (len([i for i in result if i == [1]]))
text_size_ = font.render("|a|^2: " + str(np.square(a2)), True, (0, 0, 0)) screen.blit(text_size_, [size_x - 400, 20]) # program is now ready to be run run_quantum_program = True if run_quantum_program: # draw DESTRUCTION! log pygame.draw.rect(screen, (0, 0, 0), (0, dest_y, size_x, dest_width)) ### Carry out program # initialize program qvm = api.QVMConnection() p = Program() ##### Q's 1st move p.defgate("Q1", U_(a1, b1)) p.inst(("Q1", 0)) ##### Picard's random move # set the parameters for the random move prob = picard_prob # create a dummy gate a = np.random.rand() b = np.sqrt(1 - np.square(a)) Uf_ = U_(a, b) # perform the random move p.defgate("Uf", Uf_) p.inst(("Uf", 0)) p.define_noisy_gate( "Uf", [0], [np.sqrt(prob) * X_, np.sqrt(1 - prob) * I_])
def shor(N): # Check if number is even if N % 2 == 0: print('Even number.') return 2 # Step 1: Chose 1 < a < N uniformly at random a = np.random.randint(2, N - 1) a = 2 # Step 2: Compute b = gcd(a,N). If b > 1, output b and stop b = gcd(a, N) if b > 1: print('Factor found by guessing:', b) return b # Step 3: Find the order r of a modulo N for f(x) = a^x mod N # Quantum Part: using approximate periodicity to find r m = int(np.ceil(np.log2(N**2))) # Size of first register M = 2**m # M is the smallest power of 2 greater than N^2 n = int(np.ceil( np.log2(N - 1))) # Size of second register - need to represent 0 to N-1 # Set up connection and program qvm = QVMConnection() p = Program() # Labels for register 1 and 2 reg_1 = range(m) # First m qubits reg_2 = range(m, m + n) # Last n qubits reg_all = range(m + n) # Label for both registers # Apply QFT to first register for i in reg_1: p.inst(H(i)) # Apply the oracle to both registers - need superposition of |x>|f(x)> oracle_matrix = bit_oracle(a, N, m, n) p.defgate("oracle", oracle_matrix) p.inst(("oracle", ) + tuple(reg_all)) # Measure the second register for i in reg_2: p.measure(i, i) # Apply the qft to the first register p.inst(qft(reg_1)) # Measure the first register for i in reg_1: p.measure(i, i) # Run the approximate peridicity algorithm classical_addresses = list(reg_all) results = qvm.run(p, classical_addresses, trials=1) # Determine output y of algorithm y = 0 for i in reg_1: y = y + 2**i * results[0][i] # Use continued fraction expansion of z = y/M to find r r = Fraction(y, M).limit_denominator(N).denominator # If r is odd the algorithm fails if r % 2 == 1: print('Order r found is odd: algorithm failed') return 0 # Step 4: Find factor of N s = gcd(a**(r / 2) - 1, N) if s == 1 or s == N: print('Factor found is 1 or', N, ': algorithm failed') return N print('Factor found by Shor\'s algorithm is', s, 'using', m + n, 'qubits') return s