def test_unrolling_parameterized_composite_gates(self): """Verify unrolling circuits with parameterized composite gates.""" qr1 = QuantumRegister(2) subqc = QuantumCircuit(qr1) theta = Parameter('theta') subqc.rz(theta, qr1[0]) subqc.cx(qr1[0], qr1[1]) subqc.rz(theta, qr1[1]) # Expanding across register with shared parameter qr2 = QuantumRegister(4) qc = QuantumCircuit(qr2) qc.append(subqc.to_instruction(), [qr2[0], qr2[1]]) qc.append(subqc.to_instruction(), [qr2[2], qr2[3]]) dag = circuit_to_dag(qc) out_dag = Unroller(['u1', 'u3', 'cx']).run(dag) # Pick up -1 * theta / 2 global phase four twice (once for each RZ -> P # in each of the two sub_instr instructions). expected = QuantumCircuit(qr2, global_phase=-1 * 4 * theta / 2.0) expected.append(U1Gate(theta), [qr2[0]]) expected.cx(qr2[0], qr2[1]) expected.append(U1Gate(theta), [qr2[1]]) expected.append(U1Gate(theta), [qr2[2]]) expected.cx(qr2[2], qr2[3]) expected.append(U1Gate(theta), [qr2[3]]) self.assertEqual(circuit_to_dag(expected), out_dag) # Expanding across register with shared parameter qc = QuantumCircuit(qr2) phi = Parameter('phi') gamma = Parameter('gamma') qc.append(subqc.to_instruction({theta: phi}), [qr2[0], qr2[1]]) qc.append(subqc.to_instruction({theta: gamma}), [qr2[2], qr2[3]]) dag = circuit_to_dag(qc) out_dag = Unroller(['u1', 'u3', 'cx']).run(dag) expected = QuantumCircuit(qr2, global_phase=-1 * (2 * phi + 2 * gamma) / 2.0) expected.append(U1Gate(phi), [qr2[0]]) expected.cx(qr2[0], qr2[1]) expected.append(U1Gate(phi), [qr2[1]]) expected.append(U1Gate(gamma), [qr2[2]]) expected.cx(qr2[2], qr2[3]) expected.append(U1Gate(gamma), [qr2[3]]) self.assertEqual(circuit_to_dag(expected), out_dag)
def createQC(r): #parameter setting lis paraLis16 = [1.57e+00, 5.24e-01, -9.92e-07, 5.24e-01, -7.89e-07, 16] paraLis8 = [3.93, 1.31, -0.79, 1.31, 0.79, 8] paraLis4 = [1.18, 1.44, 1.18, 1.44, 1.96, 4] paraLis2 = [-3.34, 0.46, 2.16, 0.46, -3.73, 2] #paraLis16 =[0.196,0.379,0.981,0.589,1.178,16] #paraLis8 =[1.963,1.115,1.963,2.615,1.178,8] #paraLis4 =[-0.785,1.017,3.927,2.517,2.356,4] #paraLis2 =[-9.014*10**(-9),-0.75,1.571,0.75,-1.571,2] #paraLis = [paraLis16,paraLis8,paraLis4,paraLis2] paraLis = [[ 1.5707963049051756, 0.5235986332337932, -4.82404012048593e-08, 0.5235989479710231, -1.3335823001363274e-09, 16 ], [ 3.1415773715120245, 1.0471999995628776, 1.5707796550096538, 1.0471959121890322, -1.57079788886257, 8 ], [ -2.356204293590994, 1.3089929020124322, 5.497795996751179, 1.3090022941259296, 0.7853896298185202, 4 ], [ 1.178098234809345, -0.6544998552823452, 1.1780979112483747, -0.6544939363207527, -4.319687165797595, 2 ]] #Register and circuit s = QuantumRegister(1, name='s') j = QuantumRegister(4, name='j') q = QuantumRegister(2, name='q') cr = ClassicalRegister(1, name='cr') crtmp = ClassicalRegister(2, name='crtmp') qc = QuantumCircuit(s, j, q, cr, crtmp) #Gate preparation qft = QFT(4, inverse=False) iqft = QFT(4, inverse=True) gateLis = [] gateinvLis = [] for i in range(4): toPut = Agate(paraLis[i]).control() gateLis.append(toPut) qc.h(j) qc.h(q) for i in range(4): gate = gateLis[i] qc.append(gate, qargs=[j[i]] + q[:]) qc.append(iqft, qargs=j[:]) #qc.swap(j[1],j[3]) for i in range(4): angle = 2**(3 - i) * np.pi angle *= 2**(-r + 1) qc.cry(angle, j[i], s[0]) qc.append(qft, qargs=j[:]) for i in range(4): gate = gateLis[3 - i].inverse() qc.append(gate, qargs=[j[3 - i]] + q[:]) qc.barrier() qc.h(j) qc.measure(s, cr) qc.barrier() qc.measure(q, crtmp) #qc.snapshot('res',qubits=q) #print(qc) return qc
def make_circuit(n:int,f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n,"qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[0]) # number=38 prog.cz(input_qubit[1],input_qubit[0]) # number=39 prog.h(input_qubit[0]) # number=40 prog.cx(input_qubit[1],input_qubit[0]) # number=45 prog.z(input_qubit[1]) # number=46 prog.h(input_qubit[0]) # number=49 prog.cz(input_qubit[1],input_qubit[0]) # number=50 prog.h(input_qubit[0]) # number=51 prog.h(input_qubit[0]) # number=32 prog.cz(input_qubit[1],input_qubit[0]) # number=33 prog.h(input_qubit[0]) # number=34 prog.x(input_qubit[4]) # number=48 prog.h(input_qubit[4]) # number=21 Zf = build_oracle(n, f) repeat = floor(sqrt(2 ** n) * pi / 4) for i in range(repeat): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.cx(input_qubit[3],input_qubit[0]) # number=41 prog.z(input_qubit[3]) # number=42 prog.cx(input_qubit[3],input_qubit[0]) # number=43 prog.cx(input_qubit[1],input_qubit[3]) # number=44 prog.x(input_qubit[0]) # number=9 prog.x(input_qubit[1]) # number=10 prog.x(input_qubit[2]) # number=11 prog.cx(input_qubit[0],input_qubit[3]) # number=35 prog.x(input_qubit[3]) # number=36 prog.cx(input_qubit[0],input_qubit[3]) # number=37 if n>=2: prog.mcu1(pi,input_qubit[1:],input_qubit[0]) prog.cx(input_qubit[1],input_qubit[0]) # number=24 prog.x(input_qubit[0]) # number=25 prog.cx(input_qubit[1],input_qubit[0]) # number=26 prog.x(input_qubit[1]) # number=14 prog.x(input_qubit[2]) # number=15 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[3]) # number=20 prog.x(input_qubit[1]) # number=22 prog.x(input_qubit[1]) # number=23 # circuit end for i in range(n): prog.measure(input_qubit[i], classical[i]) return prog
def test_from_circuit(self): """Test initialization from a circuit.""" # random unitaries u0 = random_unitary(2).data u1 = random_unitary(2).data # add to circuit qr = QuantumRegister(2) circ = QuantumCircuit(qr) circ.unitary(u0, [qr[0]]) circ.unitary(u1, [qr[1]]) target = Statevector(np.kron(u1, u0).dot([1, 0, 0, 0])) vec = Statevector.from_instruction(circ) self.assertEqual(vec, target) # Test tensor product of 1-qubit gates circuit = QuantumCircuit(3) circuit.h(0) circuit.x(1) circuit.ry(np.pi / 2, 2) target = Statevector.from_label('000').evolve(Operator(circuit)) psi = Statevector.from_instruction(circuit) self.assertEqual(psi, target) # Test decomposition of Controlled-Phase gate lam = np.pi / 4 circuit = QuantumCircuit(2) circuit.h(0) circuit.h(1) circuit.cp(lam, 0, 1) target = Statevector.from_label('00').evolve(Operator(circuit)) psi = Statevector.from_instruction(circuit) self.assertEqual(psi, target) # Test decomposition of controlled-H gate circuit = QuantumCircuit(2) circ.x(0) circuit.ch(0, 1) target = Statevector.from_label('00').evolve(Operator(circuit)) psi = Statevector.from_instruction(circuit) self.assertEqual(psi, target) # Test custom controlled gate qc = QuantumCircuit(2) qc.x(0) qc.h(1) gate = qc.to_gate() gate_ctrl = gate.control() circuit = QuantumCircuit(3) circuit.x(0) circuit.append(gate_ctrl, range(3)) target = Statevector.from_label('000').evolve(Operator(circuit)) psi = Statevector.from_instruction(circuit) self.assertEqual(psi, target) # Test initialize instruction target = Statevector([1, 0, 0, 1j]) / np.sqrt(2) circuit = QuantumCircuit(2) circuit.initialize(target.data, [0, 1]) psi = Statevector.from_instruction(circuit) self.assertEqual(psi, target) # Test reset instruction target = Statevector([1, 0]) circuit = QuantumCircuit(1) circuit.h(0) circuit.reset(0) psi = Statevector.from_instruction(circuit) self.assertEqual(psi, target)
def make_circuit(n:int,f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n,"qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[0]) # number=57 prog.cz(input_qubit[4],input_qubit[0]) # number=58 prog.h(input_qubit[0]) # number=59 prog.z(input_qubit[4]) # number=55 prog.cx(input_qubit[4],input_qubit[0]) # number=56 prog.h(input_qubit[2]) # number=50 prog.cz(input_qubit[4],input_qubit[2]) # number=51 prog.h(input_qubit[2]) # number=52 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 Zf = build_oracle(n, f) repeat = floor(sqrt(2 ** n) * pi / 4) for i in range(repeat): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.h(input_qubit[0]) # number=28 prog.cx(input_qubit[3],input_qubit[0]) # number=60 prog.z(input_qubit[3]) # number=61 prog.cx(input_qubit[3],input_qubit[0]) # number=62 prog.cz(input_qubit[1],input_qubit[0]) # number=29 prog.h(input_qubit[0]) # number=30 prog.h(input_qubit[0]) # number=43 prog.cz(input_qubit[1],input_qubit[0]) # number=44 prog.h(input_qubit[0]) # number=45 prog.cx(input_qubit[1],input_qubit[0]) # number=35 prog.h(input_qubit[0]) # number=66 prog.cz(input_qubit[1],input_qubit[0]) # number=67 prog.h(input_qubit[0]) # number=68 prog.x(input_qubit[0]) # number=39 prog.cx(input_qubit[1],input_qubit[0]) # number=40 prog.cx(input_qubit[1],input_qubit[0]) # number=37 prog.h(input_qubit[0]) # number=46 prog.cz(input_qubit[1],input_qubit[0]) # number=47 prog.h(input_qubit[0]) # number=48 prog.h(input_qubit[0]) # number=63 prog.cz(input_qubit[1],input_qubit[0]) # number=64 prog.h(input_qubit[0]) # number=65 prog.x(input_qubit[1]) # number=10 prog.x(input_qubit[2]) # number=11 prog.x(input_qubit[3]) # number=12 if n>=2: prog.mcu1(pi,input_qubit[1:],input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.cx(input_qubit[0],input_qubit[1]) # number=22 prog.y(input_qubit[2]) # number=41 prog.x(input_qubit[1]) # number=23 prog.cx(input_qubit[0],input_qubit[1]) # number=24 prog.rx(1.0398671683382215,input_qubit[2]) # number=31 prog.x(input_qubit[2]) # number=15 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[3]) # number=20 # circuit end for i in range(n): prog.measure(input_qubit[i], classical[i]) return prog
def calculate_excited_states(self, wave_fn, excitations_list=None, quantum_instance=None): """Calculate energy gap of excited states from the reference state. Args: wave_fn (Union(QuantumCircuit, numpy.ndarray)): wavefunction of reference state excitations_list (list): excitation list for calculating the excited states quantum_instance (QuantumInstance): a quantum instance with configured settings Returns: list: energy gaps to the reference state dict: information of qeom matrices Raises: ValueError: wrong setting for wave_fn and quantum_instance """ if isinstance(wave_fn, QuantumCircuit): if quantum_instance is None: raise ValueError( "quantum_instance is required when wavn_fn is a QuantumCircuit." ) temp_quantum_instance = copy.deepcopy(quantum_instance) if temp_quantum_instance.is_statevector and temp_quantum_instance.noise_config == {}: initial_statevector = quantum_instance.execute( wave_fn).get_statevector(wave_fn) q = QuantumRegister(self._operator.num_qubits, name='q') tmp_wave_fn = QuantumCircuit(q) tmp_wave_fn.append(wave_fn.to_instruction(), q) logger.info( "Under noise-free and statevector simulation, " "the wave_fn is reused and set in initial_statevector " "for faster simulation.") temp_quantum_instance.set_config( initial_statevector=initial_statevector) wave_fn = QuantumCircuit(q) else: temp_quantum_instance = None # this is required to assure paulis mode is there regardless how you compute VQE # it might be slow if you calculate vqe through matrix mode and then convert # it back to paulis self._operator = op_converter.to_weighted_pauli_operator( self._operator) self._untapered_op = op_converter.to_weighted_pauli_operator( self._untapered_op) excitations_list = self._de_list + self._se_list if excitations_list is None \ else excitations_list # build all hopping operators hopping_operators, type_of_commutativities = self.build_hopping_operators( excitations_list) # build all commutators q_commutators, w_commutators, m_commutators, v_commutators, available_entry = \ self.build_all_commutators(excitations_list, hopping_operators, type_of_commutativities) # build qeom matrices (the step involves quantum) m_mat, v_mat, q_mat, w_mat, m_mat_std, v_mat_std, q_mat_std, w_mat_std = \ self.build_eom_matrices(excitations_list, q_commutators, w_commutators, m_commutators, v_commutators, available_entry, wave_fn, temp_quantum_instance) excitation_energies_gap = self.compute_excitation_energies( m_mat, v_mat, q_mat, w_mat) logger.info('Net excited state values (gap to reference state): %s', excitation_energies_gap) eom_matrices = { 'm_mat': m_mat, 'v_mat': v_mat, 'q_mat': q_mat, 'w_mat': w_mat, 'm_mat_std': m_mat_std, 'v_mat_std': v_mat_std, 'q_mat_std': q_mat_std, 'w_mat_std': w_mat_std } return excitation_energies_gap, eom_matrices
def get_output(self, quantum_instance, qc_state_in=None, params=None, shots=None): """ Get data samples from the generator. Args: quantum_instance (QuantumInstance): Quantum Instance, used to run the generator circuit. qc_state_in (QuantumCircuit): deprecated params (numpy.ndarray): array or None, parameters which should be used to run the generator, if None use self._params shots (int): if not None use a number of shots that is different from the number set in quantum_instance Returns: list: generated samples, array: sample occurrence in percentage """ instance_shots = quantum_instance.run_config.shots q = QuantumRegister(sum(self._num_qubits), name='q') qc = QuantumCircuit(q) qc.append(self.construct_circuit(params), q) if quantum_instance.is_statevector: pass else: c = ClassicalRegister(sum(self._num_qubits), name='c') qc.add_register(c) qc.measure(q, c) if shots is not None: quantum_instance.set_config(shots=shots) result = quantum_instance.execute(qc) generated_samples = [] if quantum_instance.is_statevector: result = result.get_statevector(qc) values = np.multiply(result, np.conj(result)) values = list(values.real) keys = [] for j in range(len(values)): keys.append(np.binary_repr(j, int(sum(self._num_qubits)))) else: result = result.get_counts(qc) keys = list(result) values = list(result.values()) values = [float(v) / np.sum(values) for v in values] generated_samples_weights = values for i, _ in enumerate(keys): index = 0 temp = [] for k, p in enumerate(self._num_qubits): bin_rep = 0 j = 0 while j < p: bin_rep += int(keys[i][index]) * 2**(int(p) - j - 1) j += 1 index += 1 if len(self._num_qubits) > 1: temp.append(self._data_grid[k][int(bin_rep)]) else: temp.append(self._data_grid[int(bin_rep)]) generated_samples.append(temp) self.generator_circuit._probabilities = generated_samples_weights if shots is not None: # Restore the initial quantum_instance configuration quantum_instance.set_config(shots=instance_shots) return generated_samples, generated_samples_weights
# Create QuantumCircuit t = 4 # no. of counting qubits n = 4 # no. of searching qubits qc = QuantumCircuit(n + t, t) # Circuit with n+t qubits and t classical bits # Initialise all qubits to |+> for qubit in range(t + n): qc.h(qubit) # Create controlled-Grover gi = grover_iteration_5_16().to_gate() cgi = gi.control() cgi.label = "ControlGroverIteration" # If Include registered 0-3 bits qc.append(gi, range(t)) # Compute Energy # Measure counting qubits qc.measure(range(t), range(t)) # Display the circuit qc.draw() # # 3 » # ┌───┐┌─────────────┐┌─┐ #q_0: ┤ H ├┤0 ├┤M├───────── # ├───┤│ │└╥┘┌─┐ #q_1: ┤ H ├┤1 ├─╫─┤M├────── # ├───┤│ circuit561 │ ║ └╥┘┌─┐ #q_2: ┤ H ├┤2 ├─╫──╫─┤M├───
def make_circuit(n:int,f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n,"qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[1]) # number=29 prog.cz(input_qubit[3],input_qubit[1]) # number=30 prog.h(input_qubit[1]) # number=31 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 Zf = build_oracle(n, f) repeat = floor(sqrt(2 ** n) * pi / 4) for i in range(repeat): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.h(input_qubit[0]) # number=38 prog.cz(input_qubit[1],input_qubit[0]) # number=39 prog.h(input_qubit[0]) # number=40 prog.h(input_qubit[0]) # number=51 prog.cz(input_qubit[1],input_qubit[0]) # number=52 prog.h(input_qubit[0]) # number=53 prog.h(input_qubit[0]) # number=64 prog.cz(input_qubit[1],input_qubit[0]) # number=65 prog.h(input_qubit[0]) # number=66 prog.x(input_qubit[0]) # number=49 prog.h(input_qubit[0]) # number=57 prog.cz(input_qubit[1],input_qubit[0]) # number=58 prog.h(input_qubit[0]) # number=59 prog.h(input_qubit[0]) # number=54 prog.cz(input_qubit[1],input_qubit[0]) # number=55 prog.h(input_qubit[0]) # number=56 prog.h(input_qubit[4]) # number=41 prog.h(input_qubit[0]) # number=61 prog.cz(input_qubit[1],input_qubit[0]) # number=62 prog.h(input_qubit[0]) # number=63 prog.cx(input_qubit[0],input_qubit[1]) # number=68 prog.x(input_qubit[1]) # number=69 prog.cx(input_qubit[0],input_qubit[1]) # number=70 prog.h(input_qubit[2]) # number=25 prog.cz(input_qubit[0],input_qubit[2]) # number=26 prog.h(input_qubit[2]) # number=27 prog.x(input_qubit[2]) # number=23 prog.cx(input_qubit[0],input_qubit[2]) # number=24 prog.cx(input_qubit[0],input_qubit[3]) # number=32 prog.x(input_qubit[1]) # number=67 prog.x(input_qubit[3]) # number=33 prog.h(input_qubit[3]) # number=42 prog.cz(input_qubit[0],input_qubit[3]) # number=43 prog.h(input_qubit[3]) # number=44 if n>=2: prog.mcu1(pi,input_qubit[1:],input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.rx(0.6157521601035993,input_qubit[1]) # number=60 prog.x(input_qubit[1]) # number=14 prog.x(input_qubit[2]) # number=15 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[3]) # number=20 # circuit end for i in range(n): prog.measure(input_qubit[i], classical[i]) return prog
class Automaton: """Partitioned Quantum Cellular Automaton. Use `next(automaton)` to advance and return the new state. Has an internal state that is updated by applying the update circuit. The update circuit is formed by sequentially applying the update frames, and then measuring the qubits. The evaluation of the circuit is performed by the supplied backend. """ def __init__(self, initial_state: List[int], frames: List[UpdateFrame], backend: Callable[[QuantumCircuit], List[int]]): """Automaton with a given initial state, update frames, and backend. Use `next(automaton)` to advance and return the new state. Args: initial_state (List[int]): List of 0s and 1s indicating starting state. frames (List[UpdateFrame]): List of update frames to be applied in sequence as the update step. backend (Callable[[QuantumCircuit], List[int]]): A function that evaluates a quantum circuit once and returns the resulting list of classical bits. """ self.frames = frames self.backend = backend frame_instructions = map( lambda f: f.full_circuit_instructions, self.frames) self.update_instruction = [instruction for instructions in frame_instructions for instruction in instructions] size = len(initial_state) self.state = initial_state self.update_circuit = QuantumCircuit(size) for instruction, qargs, cargs in self.update_instruction: self.update_circuit.append(instruction, qargs, cargs) @property def preparation_circuit(self) -> qiskit.QuantumCircuit: """Circuit for preparing a register of qubits into the current state.""" return _pattern_preparation_circuit(self.state) @property def combined_circuit(self) -> qiskit.QuantumCircuit: """Combine preparation and update circuit.""" return self.preparation_circuit + self.update_circuit def _tick(self) -> None: """Update the state without returning anything.""" assert self.backend, "Backend not yet assigned" next_pattern = self.backend(self.combined_circuit) self.state = next_pattern def __next__(self) -> List[int]: """Yield the next state after applying the update circuit. Returns: List[int]: The new state of the Automaton """ self._tick() return self.state def __str__(self) -> str: """Represent as string.""" frame_string = f"[{','.join([str(frame) for frame in self.frames])}]" return f"PQCA(state={self.state}, frames={frame_string})"
def test_u_gates(self): """Test U 1, 2, & 3 gates""" filename = self._get_resource_path('test_latex_u_gates.tex') from qiskit.circuit.library import U1Gate, U2Gate, U3Gate, CU1Gate, CU3Gate qr = QuantumRegister(4, 'q') circuit = QuantumCircuit(qr) circuit.append(U1Gate(3 * pi / 2), [0]) circuit.append(U2Gate(3 * pi / 2, 2 * pi / 3), [1]) circuit.append(U3Gate(3 * pi / 2, 4.5, pi / 4), [2]) circuit.append(CU1Gate(pi / 4), [0, 1]) circuit.append(U2Gate(pi / 2, 3 * pi / 2).control(1), [2, 3]) circuit.append(CU3Gate(3 * pi / 2, -3 * pi / 4, -pi / 2), [0, 1]) circuit_drawer(circuit, filename=filename, output='latex_source') self.assertEqualToReference(filename)
def make_circuit(n:int,f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n,"qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 prog.rx(-0.03141592653589796,input_qubit[1]) # number=37 Zf = build_oracle(n, f) repeat = floor(sqrt(2 ** n) * pi / 4) for i in range(1): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[4]) # number=27 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.cx(input_qubit[1],input_qubit[0]) # number=28 prog.x(input_qubit[0]) # number=29 prog.cx(input_qubit[1],input_qubit[0]) # number=30 prog.x(input_qubit[1]) # number=10 prog.h(input_qubit[2]) # number=31 prog.cz(input_qubit[0],input_qubit[2]) # number=32 prog.h(input_qubit[2]) # number=33 prog.x(input_qubit[2]) # number=23 prog.cx(input_qubit[0],input_qubit[2]) # number=24 prog.cx(input_qubit[0],input_qubit[3]) # number=38 prog.x(input_qubit[3]) # number=39 prog.cx(input_qubit[0],input_qubit[3]) # number=40 if n>=2: prog.mcu1(pi,input_qubit[1:],input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.x(input_qubit[1]) # number=14 prog.cx(input_qubit[0],input_qubit[2]) # number=34 prog.x(input_qubit[2]) # number=35 prog.cx(input_qubit[0],input_qubit[2]) # number=36 prog.y(input_qubit[1]) # number=26 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.cx(input_qubit[4],input_qubit[2]) # number=25 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[3]) # number=20 prog.h(input_qubit[0]) prog.h(input_qubit[1]) prog.h(input_qubit[2]) prog.h(input_qubit[3]) # circuit end for i in range(n): prog.measure(input_qubit[i], classical[i]) return prog
def test_unroll_1q_chain_conditional(self): """Test unroll chain of 1-qubit gates interrupted by conditional. """ qr = QuantumRegister(1, 'qr') cr = ClassicalRegister(1, 'cr') circuit = QuantumCircuit(qr, cr) circuit.h(qr) circuit.tdg(qr) circuit.z(qr) circuit.t(qr) circuit.ry(0.5, qr) circuit.rz(0.3, qr) circuit.rx(0.1, qr) circuit.measure(qr, cr) circuit.x(qr).c_if(cr, 1) circuit.y(qr).c_if(cr, 1) circuit.z(qr).c_if(cr, 1) dag = circuit_to_dag(circuit) pass_ = Unroller(['u1', 'u2', 'u3']) unrolled_dag = pass_.run(dag) # Pick up -1 * 0.3 / 2 global phase for one RZ -> U1. ref_circuit = QuantumCircuit(qr, cr, global_phase=-0.3 / 2) ref_circuit.append(U2Gate(0, pi), [qr[0]]) ref_circuit.append(U1Gate(-pi / 4), [qr[0]]) ref_circuit.append(U1Gate(pi), [qr[0]]) ref_circuit.append(U1Gate(pi / 4), [qr[0]]) ref_circuit.append(U3Gate(0.5, 0, 0), [qr[0]]) ref_circuit.append(U1Gate(0.3), [qr[0]]) ref_circuit.append(U3Gate(0.1, -pi / 2, pi / 2), [qr[0]]) ref_circuit.measure(qr[0], cr[0]) ref_circuit.append(U3Gate(pi, 0, pi), [qr[0]]).c_if(cr, 1) ref_circuit.append(U3Gate(pi, pi / 2, pi / 2), [qr[0]]).c_if(cr, 1) ref_circuit.append(U1Gate(pi), [qr[0]]).c_if(cr, 1) ref_dag = circuit_to_dag(ref_circuit) self.assertEqual(unrolled_dag, ref_dag)
class TestUnrollAllInstructions(QiskitTestCase): """Test unrolling a circuit containing all standard instructions.""" def setUp(self): super().setUp() qr = self.qr = QuantumRegister(3, 'qr') cr = self.cr = ClassicalRegister(3, 'cr') self.circuit = QuantumCircuit(qr, cr) self.ref_circuit = QuantumCircuit(qr, cr) self.pass_ = Unroller(basis=['u3', 'cx', 'id']) def compare_dags(self): """compare dags in class tests""" dag = circuit_to_dag(self.circuit) unrolled_dag = self.pass_.run(dag) ref_dag = circuit_to_dag(self.ref_circuit) self.assertEqual(unrolled_dag, ref_dag) def test_unroll_crx(self): """test unroll crx""" self.circuit.crx(0.5, 1, 2) self.ref_circuit.append(U3Gate(0, 0, pi / 2), [2]) self.ref_circuit.cx(1, 2) self.ref_circuit.append(U3Gate(-0.25, 0, 0), [2]) self.ref_circuit.cx(1, 2) self.ref_circuit.append(U3Gate(0.25, -pi / 2, 0), [2]) self.compare_dags() def test_unroll_cry(self): """test unroll cry""" self.circuit.cry(0.5, 1, 2) self.ref_circuit.append(U3Gate(0.25, 0, 0), [2]) self.ref_circuit.cx(1, 2) self.ref_circuit.append(U3Gate(-0.25, 0, 0), [2]) self.ref_circuit.cx(1, 2) self.compare_dags() def test_unroll_ccx(self): """test unroll ccx""" self.circuit.ccx(0, 1, 2) self.ref_circuit.append(U3Gate(pi / 2, 0, pi), [2]) self.ref_circuit.cx(1, 2) self.ref_circuit.append(U3Gate(0, 0, -pi / 4), [2]) self.ref_circuit.cx(0, 2) self.ref_circuit.append(U3Gate(0, 0, pi / 4), [2]) self.ref_circuit.cx(1, 2) self.ref_circuit.append(U3Gate(0, 0, pi / 4), [1]) self.ref_circuit.append(U3Gate(0, 0, -pi / 4), [2]) self.ref_circuit.cx(0, 2) self.ref_circuit.cx(0, 1) self.ref_circuit.append(U3Gate(0, 0, pi / 4), [0]) self.ref_circuit.append(U3Gate(0, 0, -pi / 4), [1]) self.ref_circuit.cx(0, 1) self.ref_circuit.append(U3Gate(0, 0, pi / 4), [2]) self.ref_circuit.append(U3Gate(pi / 2, 0, pi), [2]) self.compare_dags() def test_unroll_ch(self): """test unroll ch""" self.circuit.ch(0, 2) self.ref_circuit.append(U3Gate(0, 0, pi / 2), [2]) self.ref_circuit.append(U3Gate(pi / 2, 0, pi), [2]) self.ref_circuit.append(U3Gate(0, 0, pi / 4), [2]) self.ref_circuit.cx(0, 2) self.ref_circuit.append(U3Gate(0, 0, -pi / 4), [2]) self.ref_circuit.append(U3Gate(pi / 2, 0, pi), [2]) self.ref_circuit.append(U3Gate(0, 0, -pi / 2), [2]) self.compare_dags() def test_unroll_crz(self): """test unroll crz""" self.circuit.crz(0.5, 1, 2) self.ref_circuit.append(U3Gate(0, 0, 0.25), [2]) self.ref_circuit.cx(1, 2) self.ref_circuit.append(U3Gate(0, 0, -0.25), [2]) self.ref_circuit.cx(1, 2) def test_unroll_cswap(self): """test unroll cswap""" self.circuit.cswap(1, 0, 2) self.ref_circuit.cx(2, 0) self.ref_circuit.append(U3Gate(pi / 2, 0, pi), [2]) self.ref_circuit.cx(0, 2) self.ref_circuit.append(U3Gate(0, 0, -pi / 4), [2]) self.ref_circuit.cx(1, 2) self.ref_circuit.append(U3Gate(0, 0, pi / 4), [2]) self.ref_circuit.cx(0, 2) self.ref_circuit.append(U3Gate(0, 0, pi / 4), [0]) self.ref_circuit.append(U3Gate(0, 0, -pi / 4), [2]) self.ref_circuit.cx(1, 2) self.ref_circuit.cx(1, 0) self.ref_circuit.append(U3Gate(0, 0, -pi / 4), [0]) self.ref_circuit.append(U3Gate(0, 0, pi / 4), [1]) self.ref_circuit.cx(1, 0) self.ref_circuit.append(U3Gate(0, 0, pi / 4), [2]) self.ref_circuit.append(U3Gate(pi / 2, 0, pi), [2]) self.ref_circuit.cx(2, 0) self.compare_dags() def test_unroll_cu1(self): """test unroll cu1""" self.circuit.append(CU1Gate(0.1), [0, 2]) self.ref_circuit.append(U3Gate(0, 0, 0.05), [0]) self.ref_circuit.cx(0, 2) self.ref_circuit.append(U3Gate(0, 0, -0.05), [2]) self.ref_circuit.cx(0, 2) self.ref_circuit.append(U3Gate(0, 0, 0.05), [2]) self.compare_dags() def test_unroll_cu3(self): """test unroll cu3""" self.circuit.append(CU3Gate(0.2, 0.1, 0.0), [1, 2]) self.ref_circuit.append(U3Gate(0, 0, 0.05), [1]) self.ref_circuit.append(U3Gate(0, 0, -0.05), [2]) self.ref_circuit.cx(1, 2) self.ref_circuit.append(U3Gate(-0.1, 0, -0.05), [2]) self.ref_circuit.cx(1, 2) self.ref_circuit.append(U3Gate(0.1, 0.1, 0), [2]) self.compare_dags() def test_unroll_cx(self): """test unroll cx""" self.circuit.cx(1, 0) self.ref_circuit.cx(1, 0) self.compare_dags() def test_unroll_cy(self): """test unroll cy""" self.circuit.cy(1, 2) self.ref_circuit.append(U3Gate(0, 0, -pi / 2), [2]) self.ref_circuit.cx(1, 2) self.ref_circuit.append(U3Gate(0, 0, pi / 2), [2]) self.compare_dags() def test_unroll_cz(self): """test unroll cz""" self.circuit.cz(2, 0) self.ref_circuit.append(U3Gate(pi / 2, 0, pi), [0]) self.ref_circuit.cx(2, 0) self.ref_circuit.append(U3Gate(pi / 2, 0, pi), [0]) self.compare_dags() def test_unroll_h(self): """test unroll h""" self.circuit.h(1) self.ref_circuit.append(U3Gate(pi / 2, 0, pi), [1]) self.compare_dags() def test_unroll_i(self): """test unroll i""" self.circuit.i(0) self.ref_circuit.i(0) self.compare_dags() def test_unroll_rx(self): """test unroll rx""" self.circuit.rx(0.1, 0) self.ref_circuit.append(U3Gate(0.1, -pi / 2, pi / 2), [0]) self.compare_dags() def test_unroll_ry(self): """test unroll ry""" self.circuit.ry(0.2, 1) self.ref_circuit.append(U3Gate(0.2, 0, 0), [1]) self.compare_dags() def test_unroll_rz(self): """test unroll rz""" self.circuit.rz(0.3, 2) self.ref_circuit.global_phase = -1 * 0.3 / 2 self.ref_circuit.append(U3Gate(0, 0, 0.3), [2]) self.compare_dags() def test_unroll_rzz(self): """test unroll rzz""" self.circuit.rzz(0.6, 1, 0) self.ref_circuit.global_phase = -1 * 0.6 / 2 self.ref_circuit.cx(1, 0) self.ref_circuit.append(U3Gate(0, 0, 0.6), [0]) self.ref_circuit.cx(1, 0) self.compare_dags() def test_unroll_s(self): """test unroll s""" self.circuit.s(0) self.ref_circuit.append(U3Gate(0, 0, pi / 2), [0]) self.compare_dags() def test_unroll_sdg(self): """test unroll sdg""" self.circuit.sdg(1) self.ref_circuit.append(U3Gate(0, 0, -pi / 2), [1]) self.compare_dags() def test_unroll_swap(self): """test unroll swap""" self.circuit.swap(1, 2) self.ref_circuit.cx(1, 2) self.ref_circuit.cx(2, 1) self.ref_circuit.cx(1, 2) self.compare_dags() def test_unroll_t(self): """test unroll t""" self.circuit.t(2) self.ref_circuit.append(U3Gate(0, 0, pi / 4), [2]) self.compare_dags() def test_unroll_tdg(self): """test unroll tdg""" self.circuit.tdg(0) self.ref_circuit.append(U3Gate(0, 0, -pi / 4), [0]) self.compare_dags() def test_unroll_u1(self): """test unroll u1""" self.circuit.append(U1Gate(0.1), [1]) self.ref_circuit.append(U3Gate(0, 0, 0.1), [1]) self.compare_dags() def test_unroll_u2(self): """test unroll u2""" self.circuit.append(U2Gate(0.2, -0.1), [0]) self.ref_circuit.append(U3Gate(pi / 2, 0.2, -0.1), [0]) self.compare_dags() def test_unroll_u3(self): """test unroll u3""" self.circuit.append(U3Gate(0.3, 0.0, -0.1), [2]) self.ref_circuit.append(U3Gate(0.3, 0.0, -0.1), [2]) self.compare_dags() def test_unroll_x(self): """test unroll x""" self.circuit.x(2) self.ref_circuit.append(U3Gate(pi, 0, pi), [2]) self.compare_dags() def test_unroll_y(self): """test unroll y""" self.circuit.y(1) self.ref_circuit.append(U3Gate(pi, pi / 2, pi / 2), [1]) self.compare_dags() def test_unroll_z(self): """test unroll z""" self.circuit.z(0) self.ref_circuit.append(U3Gate(0, 0, pi), [0]) self.compare_dags() def test_unroll_snapshot(self): """test unroll snapshot""" num_qubits = self.circuit.num_qubits instr = Snapshot('0', num_qubits=num_qubits) self.circuit.append(instr, range(num_qubits)) self.ref_circuit.append(instr, range(num_qubits)) self.compare_dags() def test_unroll_measure(self): """test unroll measure""" self.circuit.measure(self.qr, self.cr) self.ref_circuit.measure(self.qr, self.cr) self.compare_dags()
def test_multi_control_u3(self): """Test the matrix representation of the controlled and controlled-controlled U3 gate.""" import qiskit.extensions.standard.u3 as u3 num_ctrl = 3 # U3 gate params alpha, beta, gamma = 0.2, 0.3, 0.4 # cnu3 gate u3gate = u3.U3Gate(alpha, beta, gamma) cnu3 = u3gate.control(num_ctrl) width = cnu3.num_qubits qr = QuantumRegister(width) qcnu3 = QuantumCircuit(qr) qcnu3.append(cnu3, qr, []) # U3 gate qu3 = QuantumCircuit(1) qu3.u3(alpha, beta, gamma, 0) # CU3 gate qcu3 = QuantumCircuit(2) qcu3.cu3(alpha, beta, gamma, 0, 1) # c-cu3 gate width = 3 qr = QuantumRegister(width) qc_cu3 = QuantumCircuit(qr) cu3gate = u3.CU3Gate(alpha, beta, gamma) c_cu3 = cu3gate.control(1) qc_cu3.append(c_cu3, qr, []) job = execute([qcnu3, qu3, qcu3, qc_cu3], BasicAer.get_backend('unitary_simulator'), basis_gates=['u1', 'u2', 'u3', 'id', 'cx']) result = job.result() # Circuit unitaries mat_cnu3 = result.get_unitary(0) mat_u3 = result.get_unitary(1) mat_cu3 = result.get_unitary(2) mat_c_cu3 = result.get_unitary(3) # Target Controlled-U3 unitary target_cnu3 = _compute_control_matrix(mat_u3, num_ctrl) target_cu3 = np.kron(mat_u3, np.diag([0, 1])) + np.kron( np.eye(2), np.diag([1, 0])) target_c_cu3 = np.kron(mat_cu3, np.diag([0, 1])) + np.kron( np.eye(4), np.diag([1, 0])) tests = [ ('check unitary of u3.control against tensored unitary of u3', target_cu3, mat_cu3), ('check unitary of cu3.control against tensored unitary of cu3', target_c_cu3, mat_c_cu3), ('check unitary of cnu3 against tensored unitary of u3', target_cnu3, mat_cnu3) ] for itest in tests: info, target, decomp = itest[0], itest[1], itest[2] with self.subTest(i=info): self.log.info(info) self.assertTrue(matrix_equal(target, decomp, ignore_phase=True))
def make_circuit(n: int, f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n, "qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.rx(-1.3603096190043806, input_qubit[2]) # number=28 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 Zf = build_oracle(n, f) repeat = floor(sqrt(2**n) * pi / 4) for i in range(repeat): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.h(input_qubit[3]) # number=34 prog.cz(input_qubit[4], input_qubit[3]) # number=35 prog.h(input_qubit[3]) # number=36 prog.h(input_qubit[0]) # number=38 prog.cz(input_qubit[1], input_qubit[0]) # number=39 prog.h(input_qubit[0]) # number=40 prog.x(input_qubit[0]) # number=32 prog.cx(input_qubit[1], input_qubit[0]) # number=33 prog.cx(input_qubit[0], input_qubit[1]) # number=24 prog.x(input_qubit[1]) # number=25 prog.x(input_qubit[1]) # number=41 prog.cx(input_qubit[0], input_qubit[1]) # number=26 prog.x(input_qubit[2]) # number=11 prog.cx(input_qubit[2], input_qubit[3]) # number=30 prog.x(input_qubit[3]) # number=12 prog.h(input_qubit[2]) # number=42 if n >= 2: prog.mcu1(pi, input_qubit[1:], input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.x(input_qubit[1]) # number=14 prog.x(input_qubit[2]) # number=15 prog.x(input_qubit[4]) # number=46 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=47 prog.cz(input_qubit[0], input_qubit[2]) # number=48 prog.h(input_qubit[2]) # number=49 prog.x(input_qubit[2]) # number=44 prog.cx(input_qubit[0], input_qubit[2]) # number=45 prog.rx(-1.9697785938008003, input_qubit[1]) # number=37 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[3]) # number=20 prog.x(input_qubit[1]) # number=22 prog.x(input_qubit[1]) # number=23 # circuit end return prog
def test_multi_control_u1(self): """Test the matrix representation of the controlled and controlled-controlled U1 gate.""" import qiskit.extensions.standard.u1 as u1 num_ctrl = 3 # U1 gate params theta = 0.2 # cnu1 gate u1gate = u1.U1Gate(theta) cnu1 = u1gate.control(num_ctrl) width = cnu1.num_qubits qr = QuantumRegister(width) qcnu1 = QuantumCircuit(qr) qcnu1.append(cnu1, qr, []) # U1 gate qu1 = QuantumCircuit(1) qu1.u1(theta, 0) # CU1 gate qcu1 = QuantumCircuit(2) qcu1.cu1(theta, 0, 1) # c-cu1 gate width = 3 qr = QuantumRegister(width) qc_cu1 = QuantumCircuit(qr) cu1gate = u1.CU1Gate(theta) c_cu1 = cu1gate.control(1) qc_cu1.append(c_cu1, qr, []) job = execute([qcnu1, qu1, qcu1, qc_cu1], BasicAer.get_backend('unitary_simulator'), basis_gates=['u1', 'u2', 'u3', 'id', 'cx']) result = job.result() # Circuit unitaries mat_cnu1 = result.get_unitary(0) # trace out ancillae mat_u1 = result.get_unitary(1) mat_cu1 = result.get_unitary(2) mat_c_cu1 = result.get_unitary(3) # Target Controlled-U1 unitary target_cnu1 = _compute_control_matrix(mat_u1, num_ctrl) target_cu1 = np.kron(mat_u1, np.diag([0, 1])) + np.kron( np.eye(2), np.diag([1, 0])) target_c_cu1 = np.kron(mat_cu1, np.diag([0, 1])) + np.kron( np.eye(4), np.diag([1, 0])) tests = [ ('check unitary of u1.control against tensored unitary of u1', target_cu1, mat_cu1), ('check unitary of cu1.control against tensored unitary of cu1', target_c_cu1, mat_c_cu1), ('check unitary of cnu1 against tensored unitary of u1', target_cnu1, mat_cnu1) ] for itest in tests: info, target, decomp = itest[0], itest[1], itest[2] with self.subTest(i=info): self.log.info(info) self.assertTrue(matrix_equal(target, decomp, ignore_phase=True))
def test_rotation_gates(self): """Test controlled rotation gates""" import qiskit.extensions.standard.u1 as u1 import qiskit.extensions.standard.rx as rx import qiskit.extensions.standard.ry as ry import qiskit.extensions.standard.rz as rz num_ctrl = 2 num_target = 1 qreg = QuantumRegister(num_ctrl + num_target) theta = pi/2 gu1 = u1.U1Gate(theta) grx = rx.RXGate(theta) gry = ry.RYGate(theta) grz = rz.RZGate(theta) ugu1 = ac._unroll_gate(gu1, ['u1', 'u3', 'cx']) ugrx = ac._unroll_gate(grx, ['u1', 'u3', 'cx']) ugry = ac._unroll_gate(gry, ['u1', 'u3', 'cx']) ugrz = ac._unroll_gate(grz, ['u1', 'u3', 'cx']) ugrz.params = grz.params cgu1 = ugu1.control(num_ctrl) cgrx = ugrx.control(num_ctrl) cgry = ugry.control(num_ctrl) cgrz = ugrz.control(num_ctrl) for gate, cgate in zip([gu1, grx, gry, grz], [cgu1, cgrx, cgry, cgrz]): with self.subTest(i=gate.name): if gate.name == 'rz': iden = Operator.from_label('I') zgen = Operator.from_label('Z') op_mat = (np.cos(0.5 * theta) * iden - 1j * np.sin(0.5 * theta) * zgen).data else: op_mat = Operator(gate).data ref_mat = Operator(cgate).data cop_mat = _compute_control_matrix(op_mat, num_ctrl) self.assertTrue(matrix_equal(cop_mat, ref_mat, ignore_phase=True)) cqc = QuantumCircuit(num_ctrl + num_target) cqc.append(cgate, cqc.qregs[0]) dag = circuit_to_dag(cqc) unroller = Unroller(['u3', 'cx']) uqc = dag_to_circuit(unroller.run(dag)) self.log.info('%s gate count: %d', cgate.name, uqc.size()) self.log.info('\n%s', str(uqc)) # these limits could be changed if gate.name == 'ry': self.assertTrue(uqc.size() <= 32) elif gate.name == 'rz': self.assertTrue(uqc.size() <= 40) else: self.assertTrue(uqc.size() <= 20) qc = QuantumCircuit(qreg, name='composite') qc.append(grx.control(num_ctrl), qreg) qc.append(gry.control(num_ctrl), qreg) qc.append(gry, qreg[0:gry.num_qubits]) qc.append(grz.control(num_ctrl), qreg) dag = circuit_to_dag(qc) unroller = Unroller(['u3', 'cx']) uqc = dag_to_circuit(unroller.run(dag)) self.log.info('%s gate count: %d', uqc.name, uqc.size()) self.assertTrue(uqc.size() <= 93) # this limit could be changed
def build_circuit(n: int, f: Callable[[str], str]) -> QuantumCircuit: # implement the Bernstein-Vazirani circuit zero = np.binary_repr(0, n) b = f(zero) # initial n + 1 bits input_qubit = QuantumRegister(n + 1, "qc") classicals = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classicals) # inverse last one (can be omitted if using O_f^\pm) prog.x(input_qubit[n]) # circuit begin prog.h(input_qubit[1]) # number=1 prog.h(input_qubit[2]) # number=38 prog.cz(input_qubit[0], input_qubit[2]) # number=39 prog.h(input_qubit[2]) # number=40 prog.cx(input_qubit[0], input_qubit[2]) # number=31 prog.h(input_qubit[2]) # number=42 prog.cz(input_qubit[0], input_qubit[2]) # number=43 prog.h(input_qubit[2]) # number=44 prog.h(input_qubit[2]) # number=48 prog.cz(input_qubit[0], input_qubit[2]) # number=49 prog.h(input_qubit[2]) # number=50 prog.x(input_qubit[2]) # number=46 prog.cx(input_qubit[0], input_qubit[2]) # number=47 prog.cx(input_qubit[0], input_qubit[2]) # number=37 prog.cx(input_qubit[0], input_qubit[2]) # number=33 prog.h(input_qubit[2]) # number=25 prog.cz(input_qubit[0], input_qubit[2]) # number=26 prog.h(input_qubit[2]) # number=27 prog.h(input_qubit[1]) # number=7 prog.cz(input_qubit[2], input_qubit[1]) # number=8 prog.rx(0.17592918860102857, input_qubit[2]) # number=34 prog.rx(-0.3989822670059037, input_qubit[1]) # number=30 prog.h(input_qubit[1]) # number=9 prog.h(input_qubit[1]) # number=18 prog.cz(input_qubit[2], input_qubit[1]) # number=19 prog.h(input_qubit[1]) # number=20 prog.y(input_qubit[1]) # number=14 prog.h(input_qubit[1]) # number=22 prog.cz(input_qubit[2], input_qubit[1]) # number=23 prog.h(input_qubit[1]) # number=24 prog.z(input_qubit[2]) # number=3 prog.z(input_qubit[1]) # number=41 prog.x(input_qubit[1]) # number=17 prog.y(input_qubit[2]) # number=5 prog.x(input_qubit[2]) # number=21 # apply H to get superposition for i in range(n): prog.h(input_qubit[i]) prog.h(input_qubit[n]) prog.barrier() # apply oracle O_f oracle = build_oracle(n, f) prog.append(oracle.to_gate(), [input_qubit[i] for i in range(n)] + [input_qubit[n]]) # apply H back (QFT on Z_2^n) for i in range(n): prog.h(input_qubit[i]) prog.barrier() # measure return prog
def test_parameterized_circuits(self): """Parameters should be treated as opaque gates.""" qr = QuantumRegister(1) qc = QuantumCircuit(qr) theta = Parameter('theta') qc.append(U1Gate(0.3), [qr]) qc.append(U1Gate(0.4), [qr]) qc.append(U1Gate(theta), [qr]) qc.append(U1Gate(0.1), [qr]) qc.append(U1Gate(0.2), [qr]) qc.append(U1Gate(theta), [qr]) qc.append(U1Gate(0.3), [qr]) qc.append(U1Gate(0.2), [qr]) dag = circuit_to_dag(qc) expected = QuantumCircuit(qr) expected.append(U1Gate(0.7), [qr]) expected.append(U1Gate(theta), [qr]) expected.append(U1Gate(0.3), [qr]) expected.append(U1Gate(theta), [qr]) expected.append(U1Gate(0.5), [qr]) after = Optimize1qGates().run(dag) self.assertEqual(circuit_to_dag(expected), after)
def make_circuit(n: int, f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n, "qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 Zf = build_oracle(n, f) repeat = floor(sqrt(2**n) * pi / 4) for i in range(1): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.h(input_qubit[0]) # number=33 prog.cz(input_qubit[1], input_qubit[0]) # number=34 prog.h(input_qubit[0]) # number=35 prog.rx(-0.7822565707438585, input_qubit[2]) # number=31 prog.x(input_qubit[0]) # number=29 prog.cx(input_qubit[1], input_qubit[0]) # number=30 prog.h(input_qubit[1]) # number=40 prog.cz(input_qubit[0], input_qubit[1]) # number=41 prog.h(input_qubit[1]) # number=42 prog.x(input_qubit[1]) # number=26 prog.cx(input_qubit[0], input_qubit[1]) # number=27 prog.cx(input_qubit[0], input_qubit[2]) # number=22 prog.x(input_qubit[2]) # number=23 prog.cx(input_qubit[0], input_qubit[2]) # number=24 prog.x(input_qubit[3]) # number=12 if n >= 2: prog.mcu1(pi, input_qubit[1:], input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.x(input_qubit[1]) # number=14 prog.x(input_qubit[2]) # number=15 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[3]) # number=37 prog.cz(input_qubit[2], input_qubit[3]) # number=38 prog.h(input_qubit[3]) # number=39 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.rx(2.5761059759436304, input_qubit[3]) # number=32 prog.h(input_qubit[3]) # number=20 prog.h(input_qubit[0]) prog.h(input_qubit[1]) prog.h(input_qubit[2]) prog.h(input_qubit[3]) # circuit end return prog
def test_parameterized_expressions_in_circuits(self): """Expressions of Parameters should be treated as opaque gates.""" qr = QuantumRegister(1) qc = QuantumCircuit(qr) theta = Parameter('theta') phi = Parameter('phi') sum_ = theta + phi product_ = theta * phi qc.append(U1Gate(0.3), [qr]) qc.append(U1Gate(0.4), [qr]) qc.append(U1Gate(theta), [qr]) qc.append(U1Gate(phi), [qr]) qc.append(U1Gate(sum_), [qr]) qc.append(U1Gate(product_), [qr]) qc.append(U1Gate(0.3), [qr]) qc.append(U1Gate(0.2), [qr]) dag = circuit_to_dag(qc) expected = QuantumCircuit(qr) expected.append(U1Gate(0.7), [qr]) expected.append(U1Gate(theta), [qr]) expected.append(U1Gate(phi), [qr]) expected.append(U1Gate(sum_), [qr]) expected.append(U1Gate(product_), [qr]) expected.append(U1Gate(0.5), [qr]) after = Optimize1qGates().run(dag) self.assertEqual(circuit_to_dag(expected), after)
def make_circuit(n: int, f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n, "qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.z(input_qubit[2]) # number=28 prog.h(input_qubit[1]) # number=4 prog.rx(2.664070570244145, input_qubit[1]) # number=39 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 Zf = build_oracle(n, f) repeat = floor(sqrt(2**n) * pi / 4) for i in range(repeat): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.h(input_qubit[3]) # number=40 prog.y(input_qubit[4]) # number=35 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.h(input_qubit[0]) # number=25 prog.cz(input_qubit[1], input_qubit[0]) # number=26 prog.h(input_qubit[0]) # number=27 prog.h(input_qubit[0]) # number=36 prog.cz(input_qubit[1], input_qubit[0]) # number=37 prog.h(input_qubit[0]) # number=38 prog.cx(input_qubit[1], input_qubit[0]) # number=41 prog.cx(input_qubit[1], input_qubit[0]) # number=45 prog.x(input_qubit[0]) # number=46 prog.cx(input_qubit[1], input_qubit[0]) # number=47 prog.cx(input_qubit[1], input_qubit[0]) # number=43 prog.cx(input_qubit[1], input_qubit[0]) # number=34 prog.cx(input_qubit[1], input_qubit[0]) # number=24 prog.cx(input_qubit[0], input_qubit[1]) # number=29 prog.cx(input_qubit[2], input_qubit[3]) # number=44 prog.x(input_qubit[1]) # number=30 prog.cx(input_qubit[0], input_qubit[1]) # number=31 prog.x(input_qubit[2]) # number=11 prog.x(input_qubit[3]) # number=12 if n >= 2: prog.mcu1(pi, input_qubit[1:], input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.x(input_qubit[1]) # number=14 prog.x(input_qubit[2]) # number=15 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[3]) # number=20 # circuit end return prog
qc.add_register(q) qc.add_register(c) # create initial superposition qc.h(q[0]) qc.h(q[1]) qc.h(q[2]) qc.h(q[3]) qc.h(q[4]) # start Grover iterations (4 required for 5 qubits) ####### iteration 1 ####### qc.barrier() # area to insert oracle qc.barrier() qc.append(diffuser(n), [0, 1, 2, 3, 4]) ####### iteration 2 ####### qc.barrier() # area to insert oracle qc.barrier() qc.append(diffuser(n), [0, 1, 2, 3, 4]) ####### iteration 3 ####### qc.barrier() # area to insert oracle qc.barrier() qc.append(diffuser(n), [0, 1, 2, 3, 4]) ####### iteration 4 ####### qc.barrier()
def createQC2(r): #parameter setting lis paraLis16 = [0.196, 0.379, 0.981, 0.589, 1.178, 16] paraLis8 = [1.963, 1.115, 1.963, 2.615, 1.178, 8] paraLis4 = [-0.785, 1.017, 3.927, 2.517, 2.356, 4] paraLis2 = [-9.014 * 10**(-9), -0.75, 1.571, 0.75, -1.571, 2] paraLis = [paraLis16, paraLis8, paraLis4, paraLis2] #Register and circuit s = QuantumRegister(1, name='s') j = QuantumRegister(4, name='j') q = QuantumRegister(2, name='q') #cr = ClassicalRegister(1,name='cr') #crtmp= ClassicalRegister(2,name='crtmp') qc = QuantumCircuit(s, j, q) #Gate preparation qft = QFT(4, inverse=False) iqft = QFT(4, inverse=True) gateLis = [] gateinvLis = [] for i in range(4): toPut = Agate(paraLis[i]).control() gateLis.append(toPut) qc.h(j) qc.h(q) for i in range(4): gate = gateLis[i] qc.append(gate, qargs=[j[i]] + q[:]) qc.append(iqft, qargs=j[:]) #qc.swap(j[1],j[3]) for i in range(4): angle = 2**(3 - i) * np.pi angle *= 2**(-r + 1) qc.cry(angle, j[i], s[0]) qc.append(qft, qargs=j[:]) for i in range(4): gate = gateLis[3 - i].inverse() qc.append(gate, qargs=[j[3 - i]] + q[:]) qc.barrier() qc.h(j) #qc.measure(s,cr) qc.barrier() print(qc) tomo_circuits = state_tomography_circuits(qc, q) tomo_circuits_noanc = deepcopy(tomo_circuits) to_put = ClassicalRegister(1) for i in tomo_circuits: i.add_register(to_put) i.measure(s, to_put[0]) print(i) backend = Aer.get_backend('qasm_simulator') results = execute(tomo_circuits, backend, shots=10**5).result() print(results.get_counts()) probs = [] for circ in tomo_circuits: counts = results.get_counts(circ) s, f = 0, 0 for k, v in counts.items(): if k[0] == "1": s += v else: f += v probs.append(s / (f + s)) #results_noanc = tomo_postselect(results) data = StateTomographyFitter(results, tomo_circuits) print(data) #omo_data = StateTomographyFitter(results_noanc,tomo_circuits_noanc) rho_fit = data.fit() print(rho_fit) '''
class QCircuitMachine(RuleBasedStateMachine): """Build a Hypothesis rule based state machine for constructing, transpiling and simulating a series of random QuantumCircuits. Build circuits with up to QISKIT_RANDOM_QUBITS qubits, apply a random selection of gates from qiskit.extensions.standard with randomly selected qargs, cargs, and parameters. At random intervals, transpile the circuit for a random backend with a random optimization level and simulate both the initial and the transpiled circuits to verify that their counts are the same. """ qubits = Bundle('qubits') clbits = Bundle('clbits') backend = Aer.get_backend('qasm_simulator') max_qubits = int(backend.configuration().n_qubits / 2) def __init__(self): super().__init__() self.qc = QuantumCircuit() @precondition(lambda self: len(self.qc.qubits) < self.max_qubits) @rule(target=qubits, n=st.integers(min_value=1, max_value=max_qubits)) def add_qreg(self, n): """Adds a new variable sized qreg to the circuit, up to max_qubits.""" n = min(n, self.max_qubits - len(self.qc.qubits)) qreg = QuantumRegister(n) self.qc.add_register(qreg) return multiple(*list(qreg)) @rule(target=clbits, n=st.integers(1, 5)) def add_creg(self, n): """Add a new variable sized creg to the circuit.""" creg = ClassicalRegister(n) self.qc.add_register(creg) return multiple(*list(creg)) # Gates of various shapes @rule(gate=st.sampled_from(oneQ_gates), qarg=qubits) def add_1q_gate(self, gate, qarg): """Append a random 1q gate on a random qubit.""" self.qc.append(gate(), [qarg], []) @rule(gate=st.sampled_from(twoQ_gates), qargs=st.lists(qubits, max_size=2, min_size=2, unique=True)) def add_2q_gate(self, gate, qargs): """Append a random 2q gate across two random qubits.""" self.qc.append(gate(), qargs) @rule(gate=st.sampled_from(threeQ_gates), qargs=st.lists(qubits, max_size=3, min_size=3, unique=True)) def add_3q_gate(self, gate, qargs): """Append a random 3q gate across three random qubits.""" self.qc.append(gate(), qargs) @rule(gate=st.sampled_from(oneQ_oneP_gates), qarg=qubits, param=st.floats(allow_nan=False, allow_infinity=False, min_value=-10*pi, max_value=10*pi)) def add_1q1p_gate(self, gate, qarg, param): """Append a random 1q gate with 1 random float parameter.""" self.qc.append(gate(param), [qarg]) @rule(gate=st.sampled_from(oneQ_twoP_gates), qarg=qubits, params=st.lists( st.floats(allow_nan=False, allow_infinity=False, min_value=-10*pi, max_value=10*pi), min_size=2, max_size=2)) def add_1q2p_gate(self, gate, qarg, params): """Append a random 1q gate with 2 random float parameters.""" self.qc.append(gate(*params), [qarg]) @rule(gate=st.sampled_from(oneQ_threeP_gates), qarg=qubits, params=st.lists( st.floats(allow_nan=False, allow_infinity=False, min_value=-10*pi, max_value=10*pi), min_size=3, max_size=3)) def add_1q3p_gate(self, gate, qarg, params): """Append a random 1q gate with 3 random float parameters.""" self.qc.append(gate(*params), [qarg]) @rule(gate=st.sampled_from(twoQ_oneP_gates), qargs=st.lists(qubits, max_size=2, min_size=2, unique=True), param=st.floats(allow_nan=False, allow_infinity=False, min_value=-10*pi, max_value=10*pi)) def add_2q1p_gate(self, gate, qargs, param): """Append a random 2q gate with 1 random float parameter.""" self.qc.append(gate(param), qargs) @rule(gate=st.sampled_from(twoQ_threeP_gates), qargs=st.lists(qubits, max_size=2, min_size=2, unique=True), params=st.lists( st.floats(allow_nan=False, allow_infinity=False, min_value=-10*pi, max_value=10*pi), min_size=3, max_size=3)) def add_2q3p_gate(self, gate, qargs, params): """Append a random 2q gate with 3 random float parameters.""" self.qc.append(gate(*params), qargs) @rule(gate=st.sampled_from(oneQ_oneC_gates), qarg=qubits, carg=clbits) def add_1q1c_gate(self, gate, qarg, carg): """Append a random 1q, 1c gate.""" self.qc.append(gate(), [qarg], [carg]) @rule(gate=st.sampled_from(variadic_gates), qargs=st.lists(qubits, min_size=1, unique=True)) def add_variQ_gate(self, gate, qargs): """Append a gate with a variable number of qargs.""" self.qc.append(gate(len(qargs)), qargs) @precondition(lambda self: len(self.qc.data) > 0) @rule(carg=clbits, data=st.data()) def add_c_if_last_gate(self, carg, data): """Modify the last gate to be conditional on a classical register.""" creg = carg.register val = data.draw(st.integers(min_value=0, max_value=2**len(creg)-1)) last_gate = self.qc.data[-1] # Conditional instructions are not supported assume(isinstance(last_gate[0], Gate)) last_gate[0].c_if(creg, val) # Properties to check @invariant() def qasm(self): """After each circuit operation, it should be possible to build QASM.""" self.qc.qasm() @precondition(lambda self: any(isinstance(d[0], Measure) for d in self.qc.data)) @rule( backend=st.one_of( st.none(), st.sampled_from(mock_backends)), opt_level=st.integers(min_value=0, max_value=3)) def equivalent_transpile(self, backend, opt_level): """Simulate, transpile and simulate the present circuit. Verify that the counts are not significantly different before and after transpilation. """ print('Evaluating circuit at level {} on {}:\n{}'.format( opt_level, backend, self.qc.qasm())) assume(backend is None or backend.configuration().n_qubits >= len(self.qc.qubits)) shots = 4096 aer_counts = execute(self.qc, backend=self.backend, shots=shots).result().get_counts() try: xpiled_qc = transpile(self.qc, backend=backend, optimization_level=opt_level) except Exception as e: failed_qasm = 'Exception caught during transpilation of circuit: \n{}'.format( self.qc.qasm()) raise RuntimeError(failed_qasm) from e xpiled_aer_counts = execute(xpiled_qc, backend=self.backend, shots=shots).result().get_counts() count_differences = dicts_almost_equal(aer_counts, xpiled_aer_counts, 0.05 * shots) assert count_differences == '', 'Counts not equivalent: {}\nFailing QASM: \n{}'.format( count_differences, self.qc.qasm())
def make_circuit(n:int,f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n,"qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 prog.h(input_qubit[0]) # number=44 prog.cz(input_qubit[3],input_qubit[0]) # number=45 prog.h(input_qubit[0]) # number=46 prog.z(input_qubit[3]) # number=33 prog.cx(input_qubit[3],input_qubit[0]) # number=34 prog.rx(0.11938052083641225,input_qubit[1]) # number=36 Zf = build_oracle(n, f) repeat = floor(sqrt(2 ** n) * pi / 4) for i in range(repeat): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.rx(1.4765485471872026,input_qubit[2]) # number=35 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.cx(input_qubit[1],input_qubit[0]) # number=41 prog.x(input_qubit[0]) # number=42 prog.cx(input_qubit[1],input_qubit[0]) # number=43 prog.x(input_qubit[4]) # number=30 prog.cx(input_qubit[0],input_qubit[1]) # number=47 prog.x(input_qubit[1]) # number=48 prog.cx(input_qubit[0],input_qubit[1]) # number=49 prog.x(input_qubit[2]) # number=11 prog.rx(0.45238934211692994,input_qubit[3]) # number=38 prog.y(input_qubit[1]) # number=39 prog.rx(-2.5258404934861938,input_qubit[1]) # number=25 prog.h(input_qubit[3]) # number=29 prog.cx(input_qubit[0],input_qubit[3]) # number=22 prog.x(input_qubit[3]) # number=23 prog.cx(input_qubit[0],input_qubit[3]) # number=24 if n>=2: prog.mcu1(pi,input_qubit[1:],input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.rx(-0.0722566310325653,input_qubit[4]) # number=37 prog.x(input_qubit[1]) # number=14 prog.cx(input_qubit[0],input_qubit[2]) # number=26 prog.x(input_qubit[2]) # number=27 prog.h(input_qubit[4]) # number=40 prog.cx(input_qubit[0],input_qubit[2]) # number=28 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[3]) # number=20 # circuit end return prog
def make_circuit(n: int, f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n, "qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.h(input_qubit[1]) # number=4 prog.cx(input_qubit[0], input_qubit[1]) # number=52 prog.x(input_qubit[1]) # number=53 prog.cx(input_qubit[0], input_qubit[1]) # number=54 prog.h(input_qubit[1]) # number=26 prog.cz(input_qubit[4], input_qubit[1]) # number=27 prog.h(input_qubit[1]) # number=28 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 prog.h(input_qubit[1]) # number=34 prog.cz(input_qubit[4], input_qubit[1]) # number=35 prog.z(input_qubit[4]) # number=46 prog.rx(0.8011061266653969, input_qubit[2]) # number=37 prog.h(input_qubit[1]) # number=36 prog.z(input_qubit[3]) # number=51 Zf = build_oracle(n, f) repeat = floor(sqrt(2**n) * pi / 4) for i in range(repeat): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.cx(input_qubit[1], input_qubit[0]) # number=38 prog.x(input_qubit[0]) # number=39 prog.cx(input_qubit[1], input_qubit[0]) # number=40 prog.cx(input_qubit[0], input_qubit[1]) # number=42 prog.rx(-1.928937889304133, input_qubit[2]) # number=49 prog.x(input_qubit[1]) # number=43 prog.cx(input_qubit[0], input_qubit[1]) # number=44 prog.x(input_qubit[2]) # number=11 prog.y(input_qubit[1]) # number=45 prog.x(input_qubit[3]) # number=12 prog.h(input_qubit[2]) # number=41 if n >= 2: prog.mcu1(pi, input_qubit[1:], input_qubit[0]) prog.cx(input_qubit[1], input_qubit[0]) # number=22 prog.x(input_qubit[4]) # number=47 prog.x(input_qubit[0]) # number=23 prog.cx(input_qubit[1], input_qubit[0]) # number=24 prog.cx(input_qubit[0], input_qubit[1]) # number=30 prog.x(input_qubit[1]) # number=31 prog.cx(input_qubit[0], input_qubit[1]) # number=32 prog.x(input_qubit[2]) # number=15 prog.h(input_qubit[4]) # number=29 prog.x(input_qubit[3]) # number=16 prog.z(input_qubit[3]) # number=50 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[3]) # number=20 # circuit end for i in range(n): prog.measure(input_qubit[i], classical[i]) return prog
def make_circuit(n: int, f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n, "qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 prog.h(input_qubit[0]) # number=43 prog.cz(input_qubit[4], input_qubit[0]) # number=44 prog.h(input_qubit[0]) # number=45 prog.cx(input_qubit[4], input_qubit[0]) # number=46 prog.z(input_qubit[4]) # number=47 prog.cx(input_qubit[4], input_qubit[0]) # number=48 prog.h(input_qubit[0]) # number=37 prog.cz(input_qubit[4], input_qubit[0]) # number=38 prog.h(input_qubit[0]) # number=39 Zf = build_oracle(n, f) repeat = floor(sqrt(2**n) * pi / 4) for i in range(repeat): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.rx(-1.0430087609918113, input_qubit[4]) # number=36 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.cx(input_qubit[1], input_qubit[0]) # number=40 prog.cx(input_qubit[1], input_qubit[0]) # number=52 prog.x(input_qubit[0]) # number=53 prog.cx(input_qubit[1], input_qubit[0]) # number=54 prog.h(input_qubit[0]) # number=49 prog.cz(input_qubit[1], input_qubit[0]) # number=50 prog.h(input_qubit[0]) # number=51 prog.x(input_qubit[1]) # number=10 prog.rx(-0.06597344572538572, input_qubit[3]) # number=27 prog.cx(input_qubit[0], input_qubit[2]) # number=22 prog.x(input_qubit[2]) # number=23 prog.h(input_qubit[2]) # number=28 prog.cz(input_qubit[0], input_qubit[2]) # number=29 prog.h(input_qubit[2]) # number=30 prog.x(input_qubit[3]) # number=12 if n >= 2: prog.mcu1(pi, input_qubit[1:], input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.x(input_qubit[1]) # number=14 prog.x(input_qubit[2]) # number=15 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[4]) # number=35 prog.h(input_qubit[0]) # number=17 prog.rx(2.4912829742967055, input_qubit[2]) # number=26 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[2]) # number=25 prog.h(input_qubit[3]) # number=20 # circuit end return prog
def to_circuit(self) -> QuantumCircuit: """ Returns a ``QuantumCircuit`` equivalent to this Operator. """ qc = QuantumCircuit(self.num_qubits) qc.append(self.to_instruction(), qargs=range(self.primitive.num_qubits)) # type: ignore return qc.decompose()