class TestStandard3Q(StandardExtensionTest): """Standard Extension Test. Gates with three Qubits""" def setUp(self): self.q = QuantumRegister(3, "q") self.r = QuantumRegister(3, "r") self.s = QuantumRegister(3, "s") self.c = ClassicalRegister(3, "c") self.circuit = QuantumCircuit(self.q, self.r, self.s, self.c) self.c_header = 80 # lenght of the header def test_barrier_None(self): self.circuit.barrier() qasm_txt = 'barrier q[0],q[1],q[2],r[0],r[1],r[2],s[0],s[1],s[2];' self.assertResult(Barrier, qasm_txt, qasm_txt) def test_ccx_reg_reg_reg(self): qasm_txt = 'ccx q[0],r[0],s[0];\nccx q[1],r[1],s[1];\nccx q[2],r[2],s[2];' instruction_set = self.circuit.ccx(self.q, self.r, self.s) self.assertStmtsType(instruction_set.instructions, ToffoliGate) self.assertQasm(qasm_txt) def test_ccx_reg_reg_inv(self): qasm_txt = 'ccx q[0],r[0],s[0];\nccx q[1],r[1],s[1];\nccx q[2],r[2],s[2];' instruction_set = self.circuit.ccx(self.q, self.r, self.s).inverse() self.assertStmtsType(instruction_set.instructions, ToffoliGate) self.assertQasm(qasm_txt) def test_cswap_reg_reg_reg(self): qasm_txt = 'cswap q[0],r[0],s[0];\n' \ 'cswap q[1],r[1],s[1];\n' \ 'cswap q[2],r[2],s[2];' instruction_set = self.circuit.cswap(self.q, self.r, self.s) self.assertStmtsType(instruction_set.instructions, FredkinGate) self.assertQasm(qasm_txt) def test_cswap_reg_reg_inv(self): qasm_txt = 'cswap q[0],r[0],s[0];\n' \ 'cswap q[1],r[1],s[1];\n' \ 'cswap q[2],r[2],s[2];' instruction_set = self.circuit.cswap(self.q, self.r, self.s).inverse() self.assertStmtsType(instruction_set.instructions, FredkinGate) self.assertQasm(qasm_txt)
def qram(qc: QuantumCircuit): # 01 qc.x(qram_q[0]) qc.ccx(qram_q[0], qram_q[1], sticks_q[0]) qc.x(qram_q[0]) # 10 qc.x(qram_q[1]) qc.ccx(qram_q[0], qram_q[1], sticks_q[0]) qc.ccx(qram_q[0], qram_q[1], sticks_q[1]) qc.x(qram_q[1]) # 11 qc.ccx(qram_q[0], qram_q[1], sticks_q[0]) qc.ccx(qram_q[0], qram_q[1], sticks_q[1]) qc.ccx(qram_q[0], qram_q[1], sticks_q[2])
def test_user_style(self): """Tests loading a user style""" circuit = QuantumCircuit(7) circuit.h(0) circuit.append(HGate(label="H2"), [1]) circuit.x(0) circuit.cx(0, 1) circuit.ccx(0, 1, 2) circuit.swap(0, 1) circuit.cswap(0, 1, 2) circuit.append(SwapGate().control(2), [0, 1, 2, 3]) circuit.dcx(0, 1) circuit.append(DCXGate().control(1), [0, 1, 2]) circuit.append(DCXGate().control(2), [0, 1, 2, 3]) circuit.z(4) circuit.append(SGate(label="S1"), [4]) circuit.sdg(4) circuit.t(4) circuit.tdg(4) circuit.p(pi / 2, 4) circuit.u1(pi / 2, 4) circuit.cz(5, 6) circuit.cu1(pi / 2, 5, 6) circuit.cp(pi / 2, 5, 6) circuit.y(5) circuit.rx(pi / 3, 5) circuit.rzx(pi / 2, 5, 6) circuit.u2(pi / 2, pi / 2, 5) circuit.barrier(5, 6) circuit.reset(5) self.circuit_drawer( circuit, style={ "name": "user_style", "displaytext": {"H2": "H_2"}, "displaycolor": {"H2": ("#EEDD00", "#FF0000")}, }, filename="user_style.png", )
def main(): ################################################## ################## Make circuit ################## ################################################## circ = QuantumCircuit(4, 4) circ.h(0) circ.h(1) circ.barrier() circ.ccx(0, 1, 2) circ.cx(0, 3) circ.cx(1, 3) circ.barrier() circ.measure([0,1,2,3], [3,2,1,0]) ################################################## ################# Print circuit ################## ################################################## circ_trans = transpile(circ) # circ_trans.draw(output="mpl", filename="./circuit.png", plot_barriers=True) style = {"dpi":200, "showindex":True, "cregbundle":True, "margin":[1.5,1,0.5,1]} circ_trans.draw(output="mpl", filename="./circuit.png", style=style, initial_state=True, plot_barriers=True, fold=20) ################################################## #################### Run job ##################### ################################################## backend = Aer.get_backend("qasm_simulator") shots = 4096 job = execute(circ_trans, backend=backend, shots=shots) ################################################## ################## Print result ################## ################################################## result = job.result() result_dict = result.get_counts(circ_trans) ########## Export result ########## with open("result.ssv", "w") as file: file.write("# qubit probability\n") for i in result_dict: file.write("{0} {1:.8E}\n".format(i, result_dict[i]/shots))
def _carry_body(constant: int, n: int, x_qreg: QuantumRegister, g_qreg: QuantumRegister) -> Gate: constant_bits = as_bits_reversed(constant, n) circuit = QuantumCircuit(x_qreg, g_qreg) for i in reversed(range(2, n)): if constant_bits[i] == '1': circuit.x(x_qreg[i]) circuit.ccx(g_qreg[i - 2], x_qreg[i], g_qreg[i - 1]) if constant_bits[i] == '1': circuit.x(x_qreg[i]) if constant_bits[1] == '1': circuit.cx(x_qreg[1], g_qreg[0]) circuit.x(x_qreg[1]) if constant_bits[0] == '1': circuit.ccx(x_qreg[0], x_qreg[1], g_qreg[0]) for i in range(2, n): if constant_bits[i] == '1': circuit.cx(x_qreg[i], g_qreg[i - 1]) circuit.x(x_qreg[i]) circuit.ccx(g_qreg[i - 2], x_qreg[i], g_qreg[i - 1]) return circuit.to_gate()
def build_circuit(): q = QuantumRegister(3) c = ClassicalRegister(3) qc = QuantumCircuit(q, c) qc.x(q[0]) qc.x(q[1]) qc.h(q[0]) qc.h(q[1]) # oracle compute qc.ccx(q[0], q[1], q[2]) qc.z(q[2]) # oracle uncompute qc.ccx(q[0], q[1], q[2]) # diffusion util.cx0(qc, q[0], q[1]) # oracle compute qc.ccx(q[0], q[1], q[2]) qc.z(q[2]) return qc, q, c
def create_circuit(self, angles): qc = QuantumCircuit(self.q, self.c) qc.h(self.ancilla_qubit) qc.h(self.index_qubit) qc.cx(self.ancilla_qubit, self.data_qubit) qc.u3(-angles[0], 0, 0, self.data_qubit) qc.cx(self.ancilla_qubit, self.data_qubit) qc.u3(angles[0], 0, 0, self.data_qubit) qc.barrier() qc.x(self.ancilla_qubit) qc.barrier() qc.ccx(self.ancilla_qubit, self.index_qubit, self.data_qubit) qc.barrier() qc.x(self.index_qubit) qc.barrier() qc.ccx(self.ancilla_qubit, self.index_qubit, self.data_qubit) qc.cx(self.index_qubit, self.data_qubit) qc.u3(angles[1], 0, 0, self.data_qubit) qc.cx(self.index_qubit, self.data_qubit) qc.u3(-angles[1], 0, 0, self.data_qubit) qc.ccx(self.ancilla_qubit, self.index_qubit, self.data_qubit) qc.cx(self.index_qubit, self.data_qubit) qc.u3(-angles[1], 0, 0, self.data_qubit) qc.cx(self.index_qubit, self.data_qubit) qc.u3(angles[1], 0, 0, self.data_qubit) qc.barrier() qc.cx(self.index_qubit, self.class_qubit) qc.barrier() qc.h(self.ancilla_qubit) qc.barrier() qc.measure(self.q, self.c) return qc
def sample_circuit(self): """Generate a sample circuit that includes the most common elements of quantum circuits. """ qr = QuantumRegister(3, 'q') cr = ClassicalRegister(3, 'c') circuit = QuantumCircuit(qr, cr) circuit.x(qr[0]) circuit.y(qr[0]) circuit.z(qr[0]) circuit.barrier(qr[0]) circuit.barrier(qr[1]) circuit.barrier(qr[2]) circuit.h(qr[0]) circuit.s(qr[0]) circuit.sdg(qr[0]) circuit.t(qr[0]) circuit.tdg(qr[0]) circuit.iden(qr[0]) circuit.reset(qr[0]) circuit.rx(pi, qr[0]) circuit.ry(pi, qr[0]) circuit.rz(pi, qr[0]) circuit.u0(pi, qr[0]) circuit.u1(pi, qr[0]) circuit.u2(pi, pi, qr[0]) circuit.u3(pi, pi, pi, qr[0]) circuit.swap(qr[0], qr[1]) circuit.cx(qr[0], qr[1]) circuit.cy(qr[0], qr[1]) circuit.cz(qr[0], qr[1]) circuit.ch(qr[0], qr[1]) circuit.cu1(pi, qr[0], qr[1]) circuit.cu3(pi, pi, pi, qr[0], qr[1]) circuit.crz(pi, qr[0], qr[1]) circuit.ccx(qr[0], qr[1], qr[2]) circuit.cswap(qr[0], qr[1], qr[2]) circuit.measure(qr, cr) return circuit
def Event(A): Damage = [0]*n qc = QuantumCircuit() q = QuantumRegister(2*(n+l+m)+1+n, 'q') c = ClassicalRegister(n, 'c') qc.add_register(q) qc.add_register(c) for i in range (2*n+m+l+1): if i <n: qc.u3(A[i]*np.pi, 0, 0, q[i]) qc.x(q[i+n]) qc.u3(A[i+n]*np.pi, 0, 0, q[i+n]) if n<=i<n+m: qc.x(q[i+n]) qc.u3(A[i+n]*Dam[i-n]*np.pi, 0, 0, q[i+n]) if n+m<=i<n+m+l: qc.x(q[i+n]) qc.u3(A[i+n]*np.pi, 0, 0, q[i+n]) if i == n+m+l: qc.mct(q[2*n:2*n+l+m], q[2*n+m+l+1], q[3*n+m+l+2:3*n+2*l+2*m+1]) if n+m+l<i<2*n+m+l+1: qc.ccx(q[i-(n+m+l+1)], q[i-(m+l+1)], q[2*n+m+l]) qc.ccx(q[2*n+m+l], q[2*n+m+l+1], q[i+n+1]) qc.ccx(q[i-(n+m+l+1)], q[i-(m+l+1)], q[2*n+m+l]) qc.measure(q[i+1+n], c[2*n+m+l-i]) backend = Aer.get_backend('qasm_simulator') job = execute(qc, backend=backend) job_result = job.result() A = list(job_result.get_counts(qc).keys()) for i in A: B = list(i) for j in range (n): if B[j] == '1': Damage[j]+= int(job_result.get_counts(qc).get(i)) return Damage
def create_oracle(oracle_type,size): from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister global qr, cr qr = QuantumRegister(size) cr = ClassicalRegister(size) oracleCircuit=QuantumCircuit(qr,cr) oracle_type_rev=oracle_type[::-1] for n in range(size-1,-1,-1): if oracle_type_rev[n] =="0": oracleCircuit.x(qr[n]) oracleCircuit.h(qr[size-1]) if size==2: oracleCircuit.cx(qr[size-2],qr[size-1]); if size==3: oracleCircuit.ccx(qr[size-3],qr[size-2],qr[size-1]) if size>=4: cccx(oracleCircuit,size) oracleCircuit.h(qr[size-1]) for n in range(size-1,-1,-1): if oracle_type_rev[n] =="0": oracleCircuit.x(qr[n]) return(oracleCircuit)
class TestAstToDag(QiskitTestCase): """Test AST to DAG.""" def setUp(self): qr = QuantumRegister(3) cr = ClassicalRegister(3) self.circuit = QuantumCircuit(qr, cr) self.circuit.ccx(qr[0], qr[1], qr[2]) self.circuit.measure(qr, cr) self.dag = circuit_to_dag(self.circuit) def test_from_ast_to_dag(self): """Test Unroller.execute()""" ast = qasm.Qasm(filename=self._get_resource_path( 'example.qasm', Path.QASMS)).parse() dag_circuit = ast_to_dag(ast) expected_result = """\ OPENQASM 2.0; include "qelib1.inc"; qreg q[3]; qreg r[3]; creg c[3]; creg d[3]; h q[0]; h q[1]; h q[2]; cx q[0],r[0]; cx q[1],r[1]; cx q[2],r[2]; barrier q[0],q[1],q[2]; measure q[0] -> c[0]; measure q[1] -> c[1]; measure q[2] -> c[2]; measure r[0] -> d[0]; measure r[1] -> d[1]; measure r[2] -> d[2]; """ expected_dag = circuit_to_dag( QuantumCircuit.from_qasm_str(expected_result)) self.assertEqual(dag_circuit, expected_dag)
def Qand(First_bool,Second_bool): a = int(First_bool) b = int(Second_bool) q = QuantumRegister(3) qc = QuantumCircuit(q) if a is 1: qc.x(0) if b is 1: qc.x(1) qc.ccx(q[0], q[1], q[2]) qc.draw() backend = Aer.get_backend('statevector_simulator') job = execute(qc, backend) result = job.result() outputstate = result.get_statevector(qc, decimals=8) Q_and = bool(int(np.real(outputstate[7]))) return Q_and
def _double_controlled_modular_adder(constant: int, N: int, n: int, qft: Gate, iqft: Gate) -> Gate: ctrl_qreg = QuantumRegister(2, name='ctrl') x_qreg = QuantumRegister(n, name='x') g_qreg = QuantumRegister(n - 1 if n >= 2 else 1, name='g') flag_qreg = QuantumRegister(1, name='flag') circuit = QuantumCircuit(ctrl_qreg, x_qreg, g_qreg, flag_qreg, name=f'CC-MA_({constant})_Mod_{N}') adder_regs = list(chain(flag_qreg, x_qreg)) circuit.append( double_controlled_comparator(N - constant, n), circuit.qubits ) circuit.append(qft, x_qreg) circuit.append( phi_constant_adder(get_angles(constant, n)).control(1), adder_regs ) circuit.ccx(ctrl_qreg[0], ctrl_qreg[1], flag_qreg[0]) circuit.append( phi_constant_adder(get_angles(N - constant, n)).control(1).inverse(), adder_regs ) circuit.append(iqft, x_qreg) circuit.append( double_controlled_comparator(constant, n), circuit.qubits ) return circuit.to_gate()
def ccx_gate_circuits_nondeterministic(final_measure=True): """CCX-gate test circuits with non-deterministic counts.""" circuits = [] qr = QuantumRegister(3) if final_measure: cr = ClassicalRegister(3) regs = (qr, cr) else: regs = (qr, ) # (I^X^I).CCX(0,1,2).(I^X^H) -> |000> + |101> circuit = QuantumCircuit(*regs) circuit.h(qr[0]) circuit.barrier(qr) circuit.x(qr[1]) circuit.barrier(qr) circuit.ccx(qr[0], qr[1], qr[2]) circuit.barrier(qr) circuit.x(qr[1]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) # (X^I^I).CCX(2,1,0).(X^H^I) -> |000> + |011> circuit = QuantumCircuit(*regs) circuit.h(qr[1]) circuit.barrier(qr) circuit.x(qr[2]) circuit.barrier(qr) circuit.ccx(qr[2], qr[1], qr[0]) circuit.barrier(qr) circuit.x(qr[2]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) return circuits
class TestQobjToCircuits(QiskitTestCase): """Test Qobj to Circuits.""" def setUp(self): qr = QuantumRegister(3) cr = ClassicalRegister(3) self.circuit = QuantumCircuit(qr, cr) self.circuit.ccx(qr[0], qr[1], qr[2]) self.circuit.measure(qr, cr) self.dag = circuit_to_dag(self.circuit) def test_qobj_to_circuits_single(self): """Check that qobj_to_circuits's result matches the qobj ini.""" backend = Aer.get_backend('qasm_simulator_py') qobj_in = compile(self.circuit, backend, pass_manager=PassManager()) out_circuit = qobj_to_circuits(qobj_in) self.assertEqual(circuit_to_dag(out_circuit[0]), self.dag) def test_qobj_to_circuits_multiple(self): """Check that qobj_to_circuits's result with multiple circuits""" backend = Aer.get_backend('qasm_simulator_py') qreg1 = QuantumRegister(2) qreg2 = QuantumRegister(3) creg1 = ClassicalRegister(2) creg2 = ClassicalRegister(2) circuit_b = QuantumCircuit(qreg1, qreg2, creg1, creg2) circuit_b.x(qreg1) circuit_b.h(qreg2) circuit_b.measure(qreg1, creg1) circuit_b.measure(qreg2[0], creg2[1]) qobj = compile([self.circuit, circuit_b], backend, pass_manager=PassManager()) dag_list = [circuit_to_dag(x) for x in qobj_to_circuits(qobj)] self.assertEqual(dag_list, [self.dag, circuit_to_dag(circuit_b)]) def test_qobj_to_circuits_with_qobj_no_qasm(self): """Verify that qobj_to_circuits returns None without QASM.""" qobj = Qobj('abc123', {}, {}, {}) self.assertIsNone(qobj_to_circuits(qobj))
def simple_adder(lhs, rhs): # string of bits assert(len(lhs) == len(rhs)) len_arg = len(lhs) assert(len_arg < 5) print(len_arg) q = QuantumRegister(len_arg * 4 + 1) # input1 + input2 + result + carry over + 1 (overflow) c = ClassicalRegister(len_arg + 1) qc = QuantumCircuit(q, c) input1_index = 0 input2_index = len_arg carryover_index = input2_index + len_arg result_index = carryover_index + len_arg for ii, yesno in enumerate(lhs): if yesno == '1': qc.x(ii) for ii, yesno in enumerate(rhs): if yesno == '1': qc.x(ii + len_arg) qc.barrier() for i in range(0, len_arg): # XOR Gate qc.cx(q[input1_index + i], q[result_index + i]) qc.cx(q[input2_index + i], q[result_index + i]) # apply carry over if i > 0: qc.cx(q[carryover_index + i - 1], q[input2_index + i]) # carry over (NAND Gate) qc.ccx(q[input1_index + i], q[input2_index + i], q[carryover_index + i]) qc.ccx(q[input1_index + i], q[carryover_index + i - 1], q[carryover_index + i]) qc.ccx(q[input2_index + i], q[carryover_index + i - 1], q[carryover_index + i]) qc.barrier() for i in range(result_index, result_index + len_arg + 1): qc.measure(q[i], c[i - result_index]) return qc
def _add_2_bit_oracle_with_ancilla_1_0(qc: QuantumCircuit, register: QuantumRegister, ancilla: Qubit) -> None: """ Add a Grover oracle for the state |10> on a 2-qubit QuantumRegister using a 1-qubit ancilla. When acting on a completely mixed state in this register, this will flip the amplitude of the state |10>. The circuit will look like the following:: | TODO :param qc: Underlying QuantumCircuit. :param register: QuantumRegister containing exactly two qubits with the qubits ordered in the usual ascending order. :param ancilla: Ancillary qubit. """ if len(list(register)) != 2: raise ValueError( f"Need QuantumRegister with exactly 2 qubits, but got {len(list(register))} instead." ) qc.x(register[0]) qc.ccx(register[1], register[0], ancilla) qc.x(register[0])
class TestQobj2Circuits(QiskitTestCase): """Wrapper test case.""" def setUp(self): qr = QuantumRegister(3) cr = ClassicalRegister(3) self.circuit = QuantumCircuit(qr, cr) self.circuit.ccx(qr[0], qr[1], qr[2]) self.circuit.measure(qr, cr) def test_qobj_to_circuits_single(self): """Check that qobj_to_circuits's result matches the qobj ini.""" backend = Aer.get_backend('qasm_simulator_py') qobj_in = compile(self.circuit, backend, skip_transpiler=True) out_circuit = qobj_to_circuits(qobj_in) self.assertEqual(out_circuit[0].qasm(), self.circuit.qasm()) def test_qobj_to_circuits_multiple(self): """Check that qobj_to_circuits's result with multiple circuits""" backend = Aer.get_backend('qasm_simulator_py') qreg1 = QuantumRegister(2) qreg2 = QuantumRegister(3) creg1 = ClassicalRegister(2) creg2 = ClassicalRegister(2) circuit_b = QuantumCircuit(qreg1, qreg2, creg1, creg2) circuit_b.x(qreg1) circuit_b.h(qreg2) circuit_b.measure(qreg1, creg1) circuit_b.measure(qreg2[0], creg2[1]) qobj = compile([self.circuit, circuit_b], backend, skip_transpiler=True) qasm_list = [x.qasm() for x in qobj_to_circuits(qobj)] self.assertEqual(qasm_list, [self.circuit.qasm(), circuit_b.qasm()]) def test_qobj_to_circuits_with_qobj_no_qasm(self): """Verify that qobj_to_circuits returns None without QASM.""" qobj = Qobj('abc123', {}, {}, {}) self.assertIsNone(qobj_to_circuits(qobj))
def grover11_ancilla(): q = QuantumRegister(3) c = ClassicalRegister(3) circ = QuantumCircuit() circ.add_register(q) circ.add_register(c) circ.x(q[2]) # X on ancilla qbit # H circ.h(q[0:2]) # Oracle circ.x(q[0]) circ.h(q[2]) circ.ccx(q[0], q[1], q[2]) circ.h(q[2]) inversion_about_average(circ, q) circ.measure(q, c) # print(circ) return circ
def build_control_rotation(self, phi): """Build the controlled rotation gate.""" qr = QuantumRegister(self.n_sig_qubit + self.n_be_qubit) qc_crot = QuantumCircuit(qr, name='CR\n%.1f' % (phi)) # Add the X gate to perform control-0. if self.n_be_qubit == 1: qc_crot.x(qr[1]) qc_crot.cx(qr[1], qr[0]) qc_crot.rz(phi * 2., qr[0]) qc_crot.cx(qr[1], qr[0]) qc_crot.x(qr[1]) elif self.n_be_qubit == 2: qc_crot.x(qr[1]) qc_crot.x(qr[2]) qc_crot.ccx(qr[1], qr[2], qr[0]) qc_crot.rz(phi * 2., qr[0]) qc_crot.ccx(qr[1], qr[2], qr[0]) qc_crot.x(qr[1]) qc_crot.x(qr[2]) return qc_crot
def Result(a,a1,b,b1,d,g,g1,h,h1,j): qc = QuantumCircuit() q = QuantumRegister(9, 'q') c = ClassicalRegister(2, 'c') qc.add_register(q) qc.add_register(c) qc.u3(a*np.pi, 0, 0, q[0]) qc.u3((-1)*a1*a*np.pi, 0, 0, q[0]) qc.u3(b*2, 0, 0, q[1]) qc.u3(b1*b*(-2), 0, 0, q[1]) qc.u3(d*2, 0, 0, q[2]) qc.x(q[4]) qc.u3(g*np.pi, 0, 0, q[5]) qc.u3((-1)*g1*g*np.pi,0, 0, q[5]) qc.u3(h*2, 0, 0, q[6]) qc.u3(h1*h*(-2), 0, 0, q[6]) qc.u3(j*2, 0, 0, q[7]) qc.cx(q[1], q[3]) qc.cx(q[6], q[8]) qc.cx(q[2], q[3]) qc.cx(q[7], q[8]) qc.ccx(q[2], q[1], q[3]) qc.ccx(q[7], q[6], q[8]) qc.cswap(q[0], q[4], q[3]) qc.cswap(q[5], q[4], q[8]) qc.measure(q[8], c[1]) qc.measure(q[3], c[0]) backend = Aer.get_backend('qasm_simulator') job = execute(qc, backend=backend) job_result = job.result() data1 = int(job_result.get_counts(qc).get("11", "0"))+int(job_result.get_counts(qc).get("10", "0")) data2 = int(job_result.get_counts(qc).get("01", "0"))+int(job_result.get_counts(qc).get("11", "0")) print(job_result.get_counts(qc)) return data1,data2
def dj_problem_oracle(problem): """Returns a 5-qubit Deutsch-Joza Oracle""" qc = QuantumCircuit(5) int(problem) if problem == 1: for q in range(4): qc.cx(q, 4) elif problem == 2: qc.cx(0, 4) qc.cx(0, 4) elif problem == 3: qc.ccx(0, 2, 4) qc.ccx(1, 2, 4) for q in range(3): qc.x(q) qc.ccx(0, 2, 4) qc.ccx(1, 3, 4) elif problem == 4: qc.cx(2, 4) else: print( "There are only currently 4 oracles in this problem set, returning empty (balanced) gate" ) return qc.to_gate()
def test_circuit_count_ops(self): """Tet circuit count ops """ size = 6 q = QuantumRegister(size, 'q') qc = QuantumCircuit(q) ans = {} num_gates = np.random.randint(50) # h = 0, x = 1, y = 2, z = 3, cx = 4, ccx = 5 lookup = {0: 'h', 1: 'x', 2: 'y', 3: 'z', 4: 'cx', 5: 'ccx'} for _ in range(num_gates): item = np.random.randint(6) if item in [0, 1, 2, 3]: idx = np.random.randint(size) if item == 0: qc.h(q[idx]) elif item == 1: qc.x(q[idx]) elif item == 2: qc.y(q[idx]) elif item == 3: qc.z(q[idx]) else: idx = np.random.permutation(size) if item == 4: qc.cx(q[int(idx[0])], q[int(idx[1])]) elif item == 5: qc.ccx(q[int(idx[0])], q[int(idx[1])], q[int(idx[2])]) if lookup[item] not in ans.keys(): ans[lookup[item]] = 1 else: ans[lookup[item]] += 1 self.assertEqual(ans, qc.count_ops())
def test_multi_control(self): """ Tests entanglement with more than one control qubit. Note that Qiskit doesn't support arbitrarily controlled operations, so we have to explicitly write out a decomposition into Toffoli gates. """ # Construct the circuit valid_states = ["0000", "0100", "0010", "0110", "0001", "0101", "0011", "1111"] qubits = QuantumRegister(len(valid_states[0])) circuit = QuantumCircuit(qubits) # Hadamard the first three qubits - these will be the controls circuit.h(qubits[0]) circuit.h(qubits[1]) circuit.h(qubits[2]) # Qiskit supports Toffoli gates, which we can use to do arbitrary controlled # operations. We just need an ancilla qubit to contain the CCNOT of the first # two control qubits, then we can CCNOT that ancilla with the third control # qubit on the target. # For a more thorough example, take a look at this post: # https://quantumcomputing.stackexchange.com/questions/2177/how-can-i-implement-an-n-bit-toffoli-gate # # Note that I'm adding the ancilla explicitly as a separate register, so the # run_test method can still just grab the original register for the measurement # without touching the ancilla. ancilla = QuantumRegister(1) circuit.add_register(ancilla) circuit.ccx(qubits[0], qubits[1], ancilla[0]) circuit.ccx(qubits[2], ancilla[0], qubits[3]) circuit.ccx(qubits[0], qubits[1], ancilla[0]) # Run the test self.run_test("multi-controlled operation", circuit, 1000, valid_states)
def Result(a, b, d): qc = QuantumCircuit() q = QuantumRegister(7, 'q') c = ClassicalRegister(1, 'c') qc.add_register(q) qc.add_register(c) print("a,b,d", a, b, d) qc.u3(a * np.pi, 0, 0, q[0]) qc.u3(b * 2, 0, 0, q[1]) qc.u3(d * 2, 0, 0, q[2]) qc.cx(q[1], q[3]) qc.cx(q[2], q[3]) qc.ccx(q[2], q[1], q[3]) qc.x(q[4]) qc.cswap(q[0], q[4], q[3]) qc.measure(q[3], c[0]) backend = Aer.get_backend('qasm_simulator') job = execute(qc, backend=backend) job_result = job.result() data = job_result.get_counts(qc).get("1", "") print(job_result.get_counts(qc)) return data
def test_post_processing(self): """Test post_processing""" # For the Oracle class q_v = QuantumRegister(2, name='v') q_o = QuantumRegister(1, name='o') circuit = QuantumCircuit(q_v, q_o) circuit.ccx(q_v[0], q_v[1], q_o[0]) oracle = CustomCircuitOracle(variable_register=q_v, output_register=q_o, circuit=circuit, evaluate_classically_callback=lambda m: (m == '11', [1, 2])) grover = Grover(oracle) self.assertListEqual(grover.post_processing("11"), [1, 2]) # For the specified post_processing oracle = QuantumCircuit(2) oracle.cz(0, 1) grover = Grover(oracle, post_processing=lambda bitstr: [idx for idx, x_i in enumerate(bitstr) if x_i == '1']) self.assertEqual(grover.post_processing("11"), [0, 1]) # When Not specified grover = Grover(oracle) self.assertEqual(grover.post_processing("11"), "11")
def create_amplifier(size): from qiskit import QuantumCircuit # Let's create the amplifier circuit for two qubits. amplifierCircuit = QuantumCircuit(qr, cr) amplifierCircuit.barrier(qr) amplifierCircuit.h(qr) amplifierCircuit.x(qr) amplifierCircuit.h(qr[size - 1]) if size == 2: amplifierCircuit.cx(qr[size - 2], qr[size - 1]) if size == 3: amplifierCircuit.ccx(qr[size - 3], qr[size - 2], qr[size - 1]) if size == 4: amplifierCircuit.mcx([qr[size - 4], qr[size - 3], qr[size - 2]], qr[size - 1]) if size >= 5: amplifierCircuit.mcx( [qr[size - 5], qr[size - 4], qr[size - 3], qr[size - 2]], qr[size - 1]) amplifierCircuit.h(qr[size - 1]) amplifierCircuit.barrier(qr) amplifierCircuit.x(qr) amplifierCircuit.h(qr) return (amplifierCircuit)
def create_circuit_comparator(self): qr = QuantumRegister(self.n) qref=QuantumRegister(self.n) qout = QuantumRegister(1) carry=QuantumRegister(1) cr = ClassicalRegister(1) qc = QuantumCircuit(qr, qref,qout,carry,cr,name='Grover') for valueref in self.vet: for j,valores in enumerate(valueref): if valores=='1': qc.x(qr[j]) for i,value in enumerate(self.vet_ref): if value=='1': qc.x(qref[i]) for t in range(0,self.n): #XOR qc.cx(qr[t],qref[t]) qc.x(qref) #NOT XOR if self.n==2: qc.ccx(qref[0],qref[1],qout[0]) qc.reset(qr) qc.reset(qref) if self.n>=3: for k in range(0,self.n-2): qc.cx(qref[k+1],carry[0]) qc.ccx(qref[k],qref[k+1],carry[0]) qc.cx(carry[0],qref[k+1]) qc.cx(carry[0],qref[k]) qc.reset(carry[0]) qc.ccx(qref[int(self.n-2)],qref[int(self.n-1)],qout[0]) qc.reset(qr) qc.reset(qref) qc.h(qout[0]) qc.x(qout[0]) qc.u1(math.pi/16,qout[0]) qc.x(qout[0]) qc.h(qout[0]) qc.barrier(qout) qc.measure(qout[0], cr[0]) return qc
def CCXDecomposition(): circuit = QuantumCircuit(3) circuit.x(0) circuit.x(1) circuit.ccx(0, 1, 2) circuit.x(0) circuit.x(1) nb_qb_mi = circuit.num_qubits nb_gates_mi = circuit.decompose().decompose().decompose().decompose().decompose().count_ops() print("not, arity 1, controls 0+2; " + str(nb_gates_mi['cx'] + nb_gates_mi['u3']) + ';' + str(nb_gates_mi['cx'])) circuit = QuantumCircuit(3) circuit.x(1) circuit.ccx(0, 1, 2) circuit.x(1) nb_qb_mi = circuit.num_qubits nb_gates_mi = circuit.decompose().decompose().decompose().decompose().decompose().count_ops() print("not, arity 1, controls 1+1; " + str(nb_gates_mi['cx'] + nb_gates_mi['u3']) + ';' + str(nb_gates_mi['cx'])) circuit = QuantumCircuit(3) circuit.ccx(0, 1, 2) nb_qb_mi = circuit.num_qubits nb_gates_mi = circuit.decompose().decompose().decompose().decompose().decompose().count_ops() print("not, arity 1, controls 2; " + str(nb_gates_mi['cx'] + nb_gates_mi['u3']) + ';' + str(nb_gates_mi['cx'])) circuit = QuantumCircuit(2) circuit.cx(0, 1) nb_qb_mi = circuit.num_qubits nb_gates_mi = circuit.decompose().decompose().decompose().decompose().decompose().count_ops() if(not nb_gates_mi.get('u3')): nb_gates_mi['u3'] = 0 print("not, arity 1, controls 1; " + str(nb_gates_mi['cx'] + nb_gates_mi['u3']) + ';' + str(nb_gates_mi['cx'])) circuit = QuantumCircuit(2) circuit.x(0) circuit.cx(0, 1) circuit.x(1) nb_qb_mi = circuit.num_qubits nb_gates_mi = circuit.decompose().decompose().decompose().decompose().decompose().count_ops() print("not, arity 1, controls 0+1; " + str(nb_gates_mi['cx'] + nb_gates_mi['u3']) + ';' + str(nb_gates_mi['cx'])) print("Init1; 1; 0") print("Term1; 1; 0") print("H, arity 1; 1; 0") print("not, arity 1; 1; 0")
def test_apply_ccx_to_slice(self): """test applying ccx to register slice""" qcontrol = QuantumRegister(10) qcontrol2 = QuantumRegister(10) qtarget = QuantumRegister(5) qtarget2 = QuantumRegister(10) qc = QuantumCircuit(qcontrol, qtarget) # test slice with skip and full register target qc.ccx(qcontrol[1::2], qcontrol[0::2], qtarget) self.assertEqual(len(qc.data), 5) for i, ictl, (gate, qargs, _) in zip(range(len(qc.data)), range(0, 10, 2), qc.data): self.assertEqual(gate.name, 'ccx') self.assertEqual(len(qargs), 3) self.assertIn(qargs[0][1], [ictl, ictl + 1]) self.assertIn(qargs[1][1], [ictl, ictl + 1]) self.assertEqual(qargs[2][1], i) # test decrementing slice qc = QuantumCircuit(qcontrol, qtarget) qc.ccx(qcontrol[2:0:-1], qcontrol[4:6], qtarget[0:2]) self.assertEqual(len(qc.data), 2) for (gate, qargs, _), ictl1, ictl2, itgt in zip(qc.data, range(2, 0, -1), range(4, 6), range(0, 2)): self.assertEqual(gate.name, 'ccx') self.assertEqual(len(qargs), 3) self.assertEqual(qargs[0][1], ictl1) self.assertEqual(qargs[1][1], ictl2) self.assertEqual(qargs[2][1], itgt) # test register expansion in ccx qc = QuantumCircuit(qcontrol, qcontrol2, qtarget2) qc.ccx(qcontrol, qcontrol2, qtarget2) for i, (gate, qargs, _) in enumerate(qc.data): self.assertEqual(gate.name, 'ccx') self.assertEqual(len(qargs), 3) self.assertEqual(qargs[0][1], i) self.assertEqual(qargs[1][1], i) self.assertEqual(qargs[2][1], i)
def _add_and_4(qc: QuantumCircuit, qubits: List[Qubit], ancillas: List[Qubit], target: Qubit) -> None: """ Combine four qubits via an AND operation using two ancilla qubits and saving the result into the `target` qubit. Note: This is worse than the built-in Multi-Toffoli gate, so prefer that. :param qc: Underlying QuantumCircuit. :param qubits: Qubits to combine via an AND operation. :param ancillas: List of 2 ancillary qubits to use for temporary results. :param target: If |0> beforehand, this qubit will be set to AND of the other qubits. """ if len(qubits) != 4: raise ValueError(f"Expected list of 4 qubits, but got {len(qubits)}.") if len(ancillas) != 2: raise ValueError( f"Expected list of 2 ancilla qubits, but got {len(ancillas)}.") qc.ccx(qubits[0], qubits[1], ancillas[0]) qc.ccx(qubits[2], qubits[3], ancillas[1]) qc.ccx(ancillas[0], ancillas[1], target) qc.ccx(qubits[2], qubits[3], ancillas[1]) qc.ccx(qubits[0], qubits[1], ancillas[0])
class TestStandard1Q(StandardExtensionTest): """Standard Extension Test. Gates with a single Qubit""" def setUp(self): self.q = QuantumRegister(3, "q") self.r = QuantumRegister(3, "r") self.c = ClassicalRegister(3, "c") self.circuit = QuantumCircuit(self.q, self.r, self.c) self.c_header = 69 # lenght of the header def test_barrier(self): self.circuit.barrier(self.q[1]) qasm_txt = 'barrier q[1];' self.assertResult(Barrier, qasm_txt, qasm_txt) def test_barrier_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.barrier, self.c[0]) self.assertRaises(QISKitError, c.barrier, self.c) self.assertRaises(QISKitError, c.barrier, (self.q, 3)) self.assertRaises(QISKitError, c.barrier, (self.q, 'a')) self.assertRaises(QISKitError, c.barrier, 0) def test_barrier_reg(self): self.circuit.barrier(self.q) qasm_txt = 'barrier q[0],q[1],q[2];' self.assertResult(Barrier, qasm_txt, qasm_txt) def test_barrier_None(self): self.circuit.barrier() qasm_txt = 'barrier q[0],q[1],q[2],r[0],r[1],r[2];' self.assertResult(Barrier, qasm_txt, qasm_txt) def test_ccx(self): self.circuit.ccx(self.q[0], self.q[1], self.q[2]) qasm_txt = 'ccx q[0],q[1],q[2];' self.assertResult(ToffoliGate, qasm_txt, qasm_txt) def test_ccx_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.ccx, self.c[0], self.c[1], self.c[2]) self.assertRaises(QISKitError, c.ccx, self.q[0], self.q[0], self.q[2]) self.assertRaises(QISKitError, c.ccx, 0, self.q[0], self.q[2]) self.assertRaises(QISKitError, c.ccx, (self.q, 3), self.q[1], self.q[2]) self.assertRaises(QISKitError, c.ccx, self.c, self.q, self.q) self.assertRaises(QISKitError, c.ccx, 'a', self.q[1], self.q[2]) def test_ch(self): self.circuit.ch(self.q[0], self.q[1]) qasm_txt = 'ch q[0],q[1];' self.assertResult(CHGate, qasm_txt, qasm_txt) def test_ch_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.ch, self.c[0], self.c[1]) self.assertRaises(QISKitError, c.ch, self.q[0], self.q[0]) self.assertRaises(QISKitError, c.ch, 0, self.q[0]) self.assertRaises(QISKitError, c.ch, (self.q, 3), self.q[0]) self.assertRaises(QISKitError, c.ch, self.c, self.q) self.assertRaises(QISKitError, c.ch, 'a', self.q[1]) def test_crz(self): self.circuit.crz(1, self.q[0], self.q[1]) self.assertResult(CrzGate, 'crz(1) q[0],q[1];', 'crz(-1) q[0],q[1];') def test_crz_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.crz, 0, self.c[0], self.c[1]) self.assertRaises(QISKitError, c.crz, 0, self.q[0], self.q[0]) self.assertRaises(QISKitError, c.crz, 0, 0, self.q[0]) # TODO self.assertRaises(QISKitError, c.crz, self.q[2], self.q[1], self.q[0]) self.assertRaises(QISKitError, c.crz, 0, self.q[1], self.c[2]) self.assertRaises(QISKitError, c.crz, 0, (self.q, 3), self.q[1]) self.assertRaises(QISKitError, c.crz, 0, self.c, self.q) # TODO self.assertRaises(QISKitError, c.crz, 'a', self.q[1], self.q[2]) def test_cswap(self): self.circuit.cswap(self.q[0], self.q[1], self.q[2]) qasm_txt = 'cx q[2],q[1];\nccx q[0],q[1],q[2];\ncx q[2],q[1];' self.assertResult(FredkinGate, qasm_txt, qasm_txt) def test_cswap_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.cswap, self.c[0], self.c[1], self.c[2]) self.assertRaises(QISKitError, c.cswap, self.q[1], self.q[0], self.q[0]) self.assertRaises(QISKitError, c.cswap, self.q[1], 0, self.q[0]) self.assertRaises(QISKitError, c.cswap, self.c[0], self.c[1], self.q[0]) self.assertRaises(QISKitError, c.cswap, self.q[0], self.q[0], self.q[1]) self.assertRaises(QISKitError, c.cswap, 0, self.q[0], self.q[1]) self.assertRaises(QISKitError, c.cswap, (self.q, 3), self.q[0], self.q[1]) self.assertRaises(QISKitError, c.cswap, self.c, self.q[0], self.q[1]) self.assertRaises(QISKitError, c.cswap, 'a', self.q[1], self.q[2]) def test_cu1(self): self.circuit.cu1(1, self.q[1], self.q[2]) self.assertResult(Cu1Gate, 'cu1(1) q[1],q[2];', 'cu1(-1) q[1],q[2];') def test_cu1_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.cu1, self.c[0], self.c[1], self.c[2]) self.assertRaises(QISKitError, c.cu1, 1, self.q[0], self.q[0]) self.assertRaises(QISKitError, c.cu1, self.q[1], 0, self.q[0]) self.assertRaises(QISKitError, c.cu1, 0, self.c[0], self.c[1]) self.assertRaises(QISKitError, c.cu1, 0, self.q[0], self.q[0]) self.assertRaises(QISKitError, c.cu1, 0, 0, self.q[0]) # TODO self.assertRaises(QISKitError, c.cu1, self.q[2], self.q[1], self.q[0]) self.assertRaises(QISKitError, c.cu1, 0, self.q[1], self.c[2]) self.assertRaises(QISKitError, c.cu1, 0, (self.q, 3), self.q[1]) self.assertRaises(QISKitError, c.cu1, 0, self.c, self.q) # TODO self.assertRaises(QISKitError, c.cu1, 'a', self.q[1], self.q[2]) def test_cu3(self): self.circuit.cu3(1, 2, 3, self.q[1], self.q[2]) self.assertResult(Cu3Gate, 'cu3(1,2,3) q[1],q[2];', 'cu3(-1,-3,-2) q[1],q[2];') def test_cu3_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.cu3, 0, 0, self.q[0], self.q[1], self.c[2]) self.assertRaises(QISKitError, c.cu3, 0, 0, 0, self.q[0], self.q[0]) self.assertRaises(QISKitError, c.cu3, 0, 0, self.q[1], 0, self.q[0]) self.assertRaises(QISKitError, c.cu3, 0, 0, 0, self.q[0], self.q[0]) self.assertRaises(QISKitError, c.cu3, 0, 0, 0, 0, self.q[0]) self.assertRaises(QISKitError, c.cu3, 0, 0, 0, (self.q, 3), self.q[1]) self.assertRaises(QISKitError, c.cu3, 0, 0, 0, self.c, self.q) # TODO self.assertRaises(QISKitError, c.cu3, 0, 0, 'a', self.q[1], self.q[2]) def test_cx(self): self.circuit.cx(self.q[1], self.q[2]) qasm_txt = 'cx q[1],q[2];' self.assertResult(CnotGate, qasm_txt, qasm_txt) def test_cx_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.cx, self.c[1], self.c[2]) self.assertRaises(QISKitError, c.cx, self.q[0], self.q[0]) self.assertRaises(QISKitError, c.cx, 0, self.q[0]) self.assertRaises(QISKitError, c.cx, (self.q, 3), self.q[0]) self.assertRaises(QISKitError, c.cx, self.c, self.q) self.assertRaises(QISKitError, c.cx, 'a', self.q[1]) def test_cxbase(self): qasm_txt = 'CX q[1],q[2];' self.circuit.cx_base(self.q[1], self.q[2]) self.assertResult(CXBase, qasm_txt, qasm_txt) def test_cxbase_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.cx_base, self.c[1], self.c[2]) self.assertRaises(QISKitError, c.cx_base, self.q[0], self.q[0]) self.assertRaises(QISKitError, c.cx_base, 0, self.q[0]) self.assertRaises(QISKitError, c.cx_base, (self.q, 3), self.q[0]) self.assertRaises(QISKitError, c.cx_base, self.c, self.q) self.assertRaises(QISKitError, c.cx_base, 'a', self.q[1]) def test_cy(self): qasm_txt = 'cy q[1],q[2];' self.circuit.cy(self.q[1], self.q[2]) self.assertResult(CyGate, qasm_txt, qasm_txt) def test_cy_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.cy, self.c[1], self.c[2]) self.assertRaises(QISKitError, c.cy, self.q[0], self.q[0]) self.assertRaises(QISKitError, c.cy, 0, self.q[0]) self.assertRaises(QISKitError, c.cy, (self.q, 3), self.q[0]) self.assertRaises(QISKitError, c.cy, self.c, self.q) self.assertRaises(QISKitError, c.cy, 'a', self.q[1]) def test_cz(self): qasm_txt = 'cz q[1],q[2];' self.circuit.cz(self.q[1], self.q[2]) self.assertResult(CzGate, qasm_txt, qasm_txt) def test_cz_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.cz, self.c[1], self.c[2]) self.assertRaises(QISKitError, c.cz, self.q[0], self.q[0]) self.assertRaises(QISKitError, c.cz, 0, self.q[0]) self.assertRaises(QISKitError, c.cz, (self.q, 3), self.q[0]) self.assertRaises(QISKitError, c.cz, self.c, self.q) self.assertRaises(QISKitError, c.cz, 'a', self.q[1]) def test_h(self): qasm_txt = 'h q[1];' self.circuit.h(self.q[1]) self.assertResult(HGate, qasm_txt, qasm_txt) def test_h_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.h, self.c[0]) self.assertRaises(QISKitError, c.h, self.c) self.assertRaises(QISKitError, c.h, (self.q, 3)) self.assertRaises(QISKitError, c.h, (self.q, 'a')) self.assertRaises(QISKitError, c.h, 0) def test_h_reg(self): qasm_txt = 'h q[0];\nh q[1];\nh q[2];' instruction_set = self.circuit.h(self.q) self.assertStmtsType(instruction_set.instructions, HGate) self.assertQasm(qasm_txt) def test_h_reg_inv(self): qasm_txt = 'h q[0];\nh q[1];\nh q[2];' instruction_set = self.circuit.h(self.q).inverse() self.assertStmtsType(instruction_set.instructions, HGate) self.assertQasm(qasm_txt, offset=len(qasm_txt) - 22) def test_iden(self): self.circuit.iden(self.q[1]) self.assertResult(IdGate, 'id q[1];', 'id q[1];') def test_iden_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.iden, self.c[0]) self.assertRaises(QISKitError, c.iden, self.c) self.assertRaises(QISKitError, c.iden, (self.q, 3)) self.assertRaises(QISKitError, c.iden, (self.q, 'a')) self.assertRaises(QISKitError, c.iden, 0) def test_iden_reg(self): qasm_txt = 'id q[0];\nid q[1];\nid q[2];' instruction_set = self.circuit.iden(self.q) self.assertStmtsType(instruction_set.instructions, IdGate) self.assertQasm(qasm_txt) def test_iden_reg_inv(self): qasm_txt = 'id q[0];\nid q[1];\nid q[2];' instruction_set = self.circuit.iden(self.q).inverse() self.assertStmtsType(instruction_set.instructions, IdGate) self.assertQasm(qasm_txt, offset=len(qasm_txt) - 25) def test_rx(self): self.circuit.rx(1, self.q[1]) self.assertResult(RXGate, 'rx(1) q[1];', 'rx(-1) q[1];') def test_rx_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.rx, self.c[0], self.c[1]) self.assertRaises(QISKitError, c.rx, self.q[1], 0) self.assertRaises(QISKitError, c.rx, 0, self.c[0]) self.assertRaises(QISKitError, c.rx, 0, 0) # TODO self.assertRaises(QISKitError, c.rx, self.q[2], self.q[1]) self.assertRaises(QISKitError, c.rx, 0, (self.q, 3)) self.assertRaises(QISKitError, c.rx, 0, self.c) # TODO self.assertRaises(QISKitError, c.rx, 'a', self.q[1]) self.assertRaises(QISKitError, c.rx, 0, 'a') def test_rx_reg(self): qasm_txt = 'rx(1) q[0];\nrx(1) q[1];\nrx(1) q[2];' instruction_set = self.circuit.rx(1, self.q) self.assertStmtsType(instruction_set.instructions, RXGate) self.assertQasm(qasm_txt) def test_rx_reg_inv(self): qasm_txt = 'rx(-1) q[0];\nrx(-1) q[1];\nrx(-1) q[2];' instruction_set = self.circuit.rx(1, self.q).inverse() self.assertStmtsType(instruction_set.instructions, RXGate) self.assertQasm(qasm_txt, offset=len(qasm_txt) - 37) def test_rx_pi(self): c = self.circuit c.rx(pi / 2, self.q[1]) self.assertResult(RXGate, 'rx(pi/2) q[1];', 'rx(-pi/2) q[1];') def test_ry(self): self.circuit.ry(1, self.q[1]) self.assertResult(RYGate, 'ry(1) q[1];', 'ry(-1) q[1];') def test_ry_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.ry, self.c[0], self.c[1]) self.assertRaises(QISKitError, c.ry, self.q[1], 0) self.assertRaises(QISKitError, c.ry, 0, self.c[0]) self.assertRaises(QISKitError, c.ry, 0, 0) # TODO self.assertRaises(QISKitError, c.ry, self.q[2], self.q[1]) self.assertRaises(QISKitError, c.ry, 0, (self.q, 3)) self.assertRaises(QISKitError, c.ry, 0, self.c) # TODO self.assertRaises(QISKitError, c.ry, 'a', self.q[1]) self.assertRaises(QISKitError, c.ry, 0, 'a') def test_ry_reg(self): qasm_txt = 'ry(1) q[0];\nry(1) q[1];\nry(1) q[2];' instruction_set = self.circuit.ry(1, self.q) self.assertStmtsType(instruction_set.instructions, RYGate) self.assertQasm(qasm_txt) def test_ry_reg_inv(self): qasm_txt = 'ry(-1) q[0];\nry(-1) q[1];\nry(-1) q[2];' instruction_set = self.circuit.ry(1, self.q).inverse() self.assertStmtsType(instruction_set.instructions, RYGate) self.assertQasm(qasm_txt, offset=len(qasm_txt) - 37) def test_ry_pi(self): c = self.circuit c.ry(pi / 2, self.q[1]) self.assertResult(RYGate, 'ry(pi/2) q[1];', 'ry(-pi/2) q[1];') def test_rz(self): self.circuit.rz(1, self.q[1]) self.assertResult(RZGate, 'rz(1) q[1];', 'rz(-1) q[1];') def test_rz_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.rz, self.c[0], self.c[1]) self.assertRaises(QISKitError, c.rz, self.q[1], 0) self.assertRaises(QISKitError, c.rz, 0, self.c[0]) self.assertRaises(QISKitError, c.rz, 0, 0) # TODO self.assertRaises(QISKitError, c.rz, self.q[2], self.q[1]) self.assertRaises(QISKitError, c.rz, 0, (self.q, 3)) self.assertRaises(QISKitError, c.rz, 0, self.c) # TODO self.assertRaises(QISKitError, c.rz, 'a', self.q[1]) self.assertRaises(QISKitError, c.rz, 0, 'a') def test_rz_reg(self): qasm_txt = 'rz(1) q[0];\nrz(1) q[1];\nrz(1) q[2];' instruction_set = self.circuit.rz(1, self.q) self.assertStmtsType(instruction_set.instructions, RZGate) self.assertQasm(qasm_txt) def test_rz_reg_inv(self): qasm_txt = 'rz(-1) q[0];\nrz(-1) q[1];\nrz(-1) q[2];' instruction_set = self.circuit.rz(1, self.q).inverse() self.assertStmtsType(instruction_set.instructions, RZGate) self.assertQasm(qasm_txt, offset=len(qasm_txt) - 37) def test_rz_pi(self): c = self.circuit c.rz(pi / 2, self.q[1]) self.assertResult(RZGate, 'rz(pi/2) q[1];', 'rz(-pi/2) q[1];') def test_s(self): self.circuit.s(self.q[1]) self.assertResult(SGate, 's q[1];', 'sdg q[1];') def test_s_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.s, self.c[0]) self.assertRaises(QISKitError, c.s, self.c) self.assertRaises(QISKitError, c.s, (self.q, 3)) self.assertRaises(QISKitError, c.s, (self.q, 'a')) self.assertRaises(QISKitError, c.s, 0) def test_s_reg(self): qasm_txt = 's q[0];\ns q[1];\ns q[2];' instruction_set = self.circuit.s(self.q) self.assertStmtsType(instruction_set.instructions, SGate) self.assertQasm(qasm_txt) def test_s_reg_inv(self): qasm_txt = 'sdg q[0];\nsdg q[1];\nsdg q[2];' instruction_set = self.circuit.s(self.q).inverse() self.assertStmtsType(instruction_set.instructions, SGate) self.assertQasm(qasm_txt, offset=len(qasm_txt) - 28) def test_sdg(self): self.circuit.sdg(self.q[1]) self.assertResult(SGate, 'sdg q[1];', 's q[1];') def test_sdg_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.sdg, self.c[0]) self.assertRaises(QISKitError, c.sdg, self.c) self.assertRaises(QISKitError, c.sdg, (self.q, 3)) self.assertRaises(QISKitError, c.sdg, (self.q, 'a')) self.assertRaises(QISKitError, c.sdg, 0) def test_sdg_reg(self): qasm_txt = 'sdg q[0];\nsdg q[1];\nsdg q[2];' instruction_set = self.circuit.sdg(self.q) self.assertStmtsType(instruction_set.instructions, SGate) self.assertQasm(qasm_txt) def test_sdg_reg_inv(self): qasm_txt = 's q[0];\ns q[1];\ns q[2];' instruction_set = self.circuit.sdg(self.q).inverse() self.assertStmtsType(instruction_set.instructions, SGate) self.assertQasm(qasm_txt, offset=len(qasm_txt) - 22) def test_swap(self): self.circuit.swap(self.q[1], self.q[2]) self.assertResult(SwapGate, 'swap q[1],q[2];', 'swap q[1],q[2];') def test_swap_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.swap, self.c[1], self.c[2]) self.assertRaises(QISKitError, c.swap, self.q[0], self.q[0]) self.assertRaises(QISKitError, c.swap, 0, self.q[0]) self.assertRaises(QISKitError, c.swap, (self.q, 3), self.q[0]) self.assertRaises(QISKitError, c.swap, self.c, self.q) self.assertRaises(QISKitError, c.swap, 'a', self.q[1]) self.assertRaises(QISKitError, c.swap, self.q, self.r[1]) self.assertRaises(QISKitError, c.swap, self.q[1], self.r) def test_t(self): c = self.circuit self.assertRaises(QISKitError, c.t, self.c[0]) # TODO self.assertRaises(QISKitError, c.t, 1) c.t(self.q[1]) self.assertResult(TGate, 't q[1];', 'tdg q[1];') def test_t_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.t, self.c[0]) self.assertRaises(QISKitError, c.t, self.c) self.assertRaises(QISKitError, c.t, (self.q, 3)) self.assertRaises(QISKitError, c.t, (self.q, 'a')) self.assertRaises(QISKitError, c.t, 0) def test_t_reg(self): qasm_txt = 't q[0];\nt q[1];\nt q[2];' instruction_set = self.circuit.t(self.q) self.assertStmtsType(instruction_set.instructions, TGate) self.assertQasm(qasm_txt) def test_t_reg_inv(self): qasm_txt = 'tdg q[0];\ntdg q[1];\ntdg q[2];' instruction_set = self.circuit.t(self.q).inverse() self.assertStmtsType(instruction_set.instructions, TGate) self.assertQasm(qasm_txt, offset=len(qasm_txt) - 28) def test_tdg(self): c = self.circuit self.assertRaises(QISKitError, c.tdg, self.c[0]) # TODO self.assertRaises(QISKitError, c.tdg, 1) c.tdg(self.q[1]) self.assertResult(TGate, 'tdg q[1];', 't q[1];') def test_tdg_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.tdg, self.c[0]) self.assertRaises(QISKitError, c.tdg, self.c) self.assertRaises(QISKitError, c.tdg, (self.q, 3)) self.assertRaises(QISKitError, c.tdg, (self.q, 'a')) self.assertRaises(QISKitError, c.tdg, 0) def test_tdg_reg(self): qasm_txt = 'tdg q[0];\ntdg q[1];\ntdg q[2];' instruction_set = self.circuit.tdg(self.q) self.assertStmtsType(instruction_set.instructions, TGate) self.assertQasm(qasm_txt) def test_tdg_reg_inv(self): qasm_txt = 't q[0];\nt q[1];\nt q[2];' instruction_set = self.circuit.tdg(self.q).inverse() self.assertStmtsType(instruction_set.instructions, TGate) self.assertQasm(qasm_txt, offset=len(qasm_txt) - 22) def test_u1(self): self.circuit.u1(1, self.q[1]) self.assertResult(U1Gate, 'u1(1) q[1];', 'u1(-1) q[1];') def test_u1_invalid(self): c = self.circuit # CHECKME? self.assertRaises(QISKitError, c.u1, self.c[0], self.q[0]) self.assertRaises(QISKitError, c.u1, self.c[0], self.c[1]) self.assertRaises(QISKitError, c.u1, self.q[1], 0) self.assertRaises(QISKitError, c.u1, 0, self.c[0]) self.assertRaises(QISKitError, c.u1, 0, 0) # TODO self.assertRaises(QISKitError, c.u1, self.q[2], self.q[1]) self.assertRaises(QISKitError, c.u1, 0, (self.q, 3)) self.assertRaises(QISKitError, c.u1, 0, self.c) # TODO self.assertRaises(QISKitError, c.u1, 'a', self.q[1]) self.assertRaises(QISKitError, c.u1, 0, 'a') def test_u1_reg(self): qasm_txt = 'u1(1) q[0];\nu1(1) q[1];\nu1(1) q[2];' instruction_set = self.circuit.u1(1, self.q) self.assertStmtsType(instruction_set.instructions, U1Gate) self.assertQasm(qasm_txt) def test_u1_reg_inv(self): qasm_txt = 'u1(-1) q[0];\nu1(-1) q[1];\nu1(-1) q[2];' instruction_set = self.circuit.u1(1, self.q).inverse() self.assertStmtsType(instruction_set.instructions, U1Gate) self.assertQasm(qasm_txt) def test_u1_pi(self): c = self.circuit c.u1(pi / 2, self.q[1]) self.assertResult(U1Gate, 'u1(pi/2) q[1];', 'u1(-pi/2) q[1];') def test_u2(self): self.circuit.u2(1, 2, self.q[1]) self.assertResult(U2Gate, 'u2(1,2) q[1];', 'u2(-pi - 2,-1 + pi) q[1];') def test_u2_invalid(self): c = self.circuit # CHECKME? self.assertRaises(QISKitError, c.u2, 0, self.c[0], self.q[0]) self.assertRaises(QISKitError, c.u2, 0, self.c[0], self.c[1]) self.assertRaises(QISKitError, c.u2, 0, self.q[1], 0) self.assertRaises(QISKitError, c.u2, 0, 0, self.c[0]) self.assertRaises(QISKitError, c.u2, 0, 0, 0) # TODO self.assertRaises(QISKitError, c.u2, 0, self.q[2], self.q[1]) self.assertRaises(QISKitError, c.u2, 0, 0, (self.q, 3)) self.assertRaises(QISKitError, c.u2, 0, 0, self.c) # TODO self.assertRaises(QISKitError, c.u2, 0, 'a', self.q[1]) self.assertRaises(QISKitError, c.u2, 0, 0, 'a') def test_u2_reg(self): qasm_txt = 'u2(1,2) q[0];\nu2(1,2) q[1];\nu2(1,2) q[2];' instruction_set = self.circuit.u2(1, 2, self.q) self.assertStmtsType(instruction_set.instructions, U2Gate) self.assertQasm(qasm_txt) def test_u2_reg_inv(self): qasm_txt = 'u2(-pi - 2,-1 + pi) q[0];\nu2(-pi - 2,-1 + pi) q[1];\nu2(-pi - 2,-1 + pi) q[2];' instruction_set = self.circuit.u2(1, 2, self.q).inverse() self.assertStmtsType(instruction_set.instructions, U2Gate) self.assertQasm(qasm_txt) def test_u2_pi(self): c = self.circuit c.u2(pi / 2, 0.3 * pi, self.q[1]) self.assertResult(U2Gate, 'u2(pi/2,0.3*pi) q[1];', 'u2(-1.3*pi,pi/2) q[1];') def test_u3(self): self.circuit.u3(1, 2, 3, self.q[1]) self.assertResult(U3Gate, 'u3(1,2,3) q[1];', 'u3(-1,-3,-2) q[1];') def test_u3_invalid(self): c = self.circuit # CHECKME? self.assertRaises(QISKitError, c.u3, 0, self.c[0], self.q[0]) self.assertRaises(QISKitError, c.u3, 0, 0, self.c[0], self.c[1]) self.assertRaises(QISKitError, c.u3, 0, 0, self.q[1], 0) self.assertRaises(QISKitError, c.u3, 0, 0, 0, self.c[0]) self.assertRaises(QISKitError, c.u3, 0, 0, 0, 0) # TODO self.assertRaises(QISKitError, c.u3, 0, 0, self.q[2], self.q[1]) self.assertRaises(QISKitError, c.u3, 0, 0, 0, (self.q, 3)) self.assertRaises(QISKitError, c.u3, 0, 0, 0, self.c) # TODO self.assertRaises(QISKitError, c.u3, 0, 0, 'a', self.q[1]) self.assertRaises(QISKitError, c.u3, 0, 0, 0, 'a') def test_u3_reg(self): qasm_txt = 'u3(1,2,3) q[0];\nu3(1,2,3) q[1];\nu3(1,2,3) q[2];' instruction_set = self.circuit.u3(1, 2, 3, self.q) self.assertStmtsType(instruction_set.instructions, U3Gate) self.assertQasm(qasm_txt) def test_u3_reg_inv(self): qasm_txt = 'u3(-1,-3,-2) q[0];\nu3(-1,-3,-2) q[1];\nu3(-1,-3,-2) q[2];' instruction_set = self.circuit.u3(1, 2, 3, self.q).inverse() self.assertStmtsType(instruction_set.instructions, U3Gate) self.assertQasm(qasm_txt) def test_u3_pi(self): c = self.circuit c.u3(pi, pi / 2, 0.3 * pi, self.q[1]) self.assertResult(U3Gate, 'u3(pi,pi/2,0.3*pi) q[1];', 'u3(-pi,-0.3*pi,-pi/2) q[1];') def test_ubase(self): self.circuit.u_base(1, 2, 3, self.q[1]) self.assertResult(UBase, 'U(1,2,3) q[1];', 'U(-1,-3,-2) q[1];') def test_ubase_invalid(self): c = self.circuit # CHECKME? self.assertRaises(QISKitError, c.u_base, 0, self.c[0], self.q[0]) self.assertRaises(QISKitError, c.u_base, 0, 0, self.c[0], self.c[1]) self.assertRaises(QISKitError, c.u_base, 0, 0, self.q[1], 0) self.assertRaises(QISKitError, c.u_base, 0, 0, 0, self.c[0]) self.assertRaises(QISKitError, c.u_base, 0, 0, 0, 0) # TODO self.assertRaises(QISKitError, c.u_base, 0, 0, self.q[2], self.q[1]) self.assertRaises(QISKitError, c.u_base, 0, 0, 0, (self.q, 3)) self.assertRaises(QISKitError, c.u_base, 0, 0, 0, self.c) # TODO self.assertRaises(QISKitError, c.u_base, 0, 0, 'a', self.q[1]) self.assertRaises(QISKitError, c.u_base, 0, 0, 0, 'a') def test_ubase_reg(self): qasm_txt = 'U(1,2,3) q[0];\nU(1,2,3) q[1];\nU(1,2,3) q[2];' instruction_set = self.circuit.u_base(1, 2, 3, self.q) self.assertStmtsType(instruction_set.instructions, UBase) self.assertQasm(qasm_txt) def test_ubase_reg_inv(self): qasm_txt = 'U(-1,-3,-2) q[0];\nU(-1,-3,-2) q[1];\nU(-1,-3,-2) q[2];' instruction_set = self.circuit.u_base(1, 2, 3, self.q).inverse() self.assertStmtsType(instruction_set.instructions, UBase) self.assertQasm(qasm_txt) def test_ubase_pi(self): c = self.circuit c.u_base(pi, pi / 2, 0.3 * pi, self.q[1]) self.assertResult(UBase, 'U(pi,pi/2,0.3*pi) q[1];', 'U(-pi,-0.3*pi,-pi/2) q[1];') def test_x(self): self.circuit.x(self.q[1]) self.assertResult(XGate, 'x q[1];', 'x q[1];') def test_x_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.x, self.c[0]) self.assertRaises(QISKitError, c.x, self.c) self.assertRaises(QISKitError, c.x, (self.q, 3)) self.assertRaises(QISKitError, c.x, (self.q, 'a')) self.assertRaises(QISKitError, c.x, 0) def test_x_reg(self): qasm_txt = 'x q[0];\nx q[1];\nx q[2];' instruction_set = self.circuit.x(self.q) self.assertStmtsType(instruction_set.instructions, XGate) self.assertQasm(qasm_txt) def test_x_reg_inv(self): qasm_txt = 'x q[0];\nx q[1];\nx q[2];' instruction_set = self.circuit.x(self.q).inverse() self.assertStmtsType(instruction_set.instructions, XGate) self.assertQasm(qasm_txt) def test_y(self): self.circuit.y(self.q[1]) self.assertResult(YGate, 'y q[1];', 'y q[1];') def test_y_invalid(self): c = self.circuit self.assertRaises(QISKitError, c.y, self.c[0]) self.assertRaises(QISKitError, c.y, self.c) self.assertRaises(QISKitError, c.y, (self.q, 3)) self.assertRaises(QISKitError, c.y, (self.q, 'a')) self.assertRaises(QISKitError, c.y, 0) def test_y_reg(self): qasm_txt = 'y q[0];\ny q[1];\ny q[2];' instruction_set = self.circuit.y(self.q) self.assertStmtsType(instruction_set.instructions, YGate) self.assertQasm(qasm_txt) def test_y_reg_inv(self): qasm_txt = 'y q[0];\ny q[1];\ny q[2];' instruction_set = self.circuit.y(self.q).inverse() self.assertStmtsType(instruction_set.instructions, YGate) self.assertQasm(qasm_txt) def test_z(self): self.circuit.z(self.q[1]) self.assertResult(ZGate, 'z q[1];', 'z q[1];') def test_rzz(self): c = self.circuit self.assertRaises(QISKitError, c.rzz, 0.1, self.c[1], self.c[2]) self.assertRaises(QISKitError, c.rzz, 0.1, self.q[0], self.q[0]) c.rzz(pi/2, self.q[1], self.q[2]) self.assertResult(RZZGate, 'rzz(pi/2) q[1],q[2];', 'rzz(-pi/2) q[1],q[2];') def assertResult(self, t, qasm_txt, qasm_txt_): """ t: type qasm_txt: qasm representation qasm_txt_: qasm representation of inverse """ c = self.circuit self.assertRaises(QISKitError, c.z, self.c[0]) self.assertRaises(QISKitError, c.z, self.c) self.assertRaises(QISKitError, c.z, (self.q, 3)) self.assertRaises(QISKitError, c.z, (self.q, 'a')) self.assertRaises(QISKitError, c.z, 0) def test_z_reg(self): qasm_txt = 'z q[0];\nz q[1];\nz q[2];' instruction_set = self.circuit.z(self.q) self.assertStmtsType(instruction_set.instructions, ZGate) self.assertQasm(qasm_txt) def test_z_reg_inv(self): qasm_txt = 'z q[0];\nz q[1];\nz q[2];' instruction_set = self.circuit.z(self.q).inverse() self.assertStmtsType(instruction_set.instructions, ZGate) self.assertQasm(qasm_txt)
class CircuitBackend(UnrollerBackend): """Backend for the unroller that produces a QuantumCircuit. By default, basis gates are the QX gates. """ def __init__(self, basis=None): """Setup this backend. basis is a list of operation name strings. """ super().__init__(basis) self.creg = None self.cval = None if basis: self.basis = basis else: self.basis = ["cx", "u1", "u2", "u3"] self.gates = {} self.listen = True self.in_gate = "" self.circuit = QuantumCircuit() def set_basis(self, basis): """Declare the set of user-defined gates to emit. basis is a list of operation name strings. """ self.basis = basis def version(self, version): """Ignore the version string. v is a version number. """ pass def new_qreg(self, name, size): """Create a new quantum register. name = name of the register sz = size of the register """ assert size >= 0, "invalid qreg size" q_register = QuantumRegister(size, name) self.circuit.add(q_register) def new_creg(self, name, size): """Create a new classical register. name = name of the register sz = size of the register """ assert size >= 0, "invalid creg size" c_register = ClassicalRegister(size, name) self.circuit.add(c_register) def define_gate(self, name, gatedata): """Define a new quantum gate. We don't check that the definition and name agree. name is a string. gatedata is the AST node for the gate. """ self.gates[name] = gatedata def _map_qubit(self, qubit): """Map qubit tuple (regname, index) to (QuantumRegister, index).""" qregs = self.circuit.get_qregs() if qubit[0] not in qregs: raise BackendError("qreg %s does not exist" % qubit[0]) return (qregs[qubit[0]], qubit[1]) def _map_bit(self, bit): """Map bit tuple (regname, index) to (ClassicalRegister, index).""" cregs = self.circuit.get_cregs() if bit[0] not in cregs: raise BackendError("creg %s does not exist" % bit[0]) return (cregs[bit[0]], bit[1]) def _map_creg(self, creg): """Map creg name to ClassicalRegister.""" cregs = self.circuit.get_cregs() if creg not in cregs: raise BackendError("creg %s does not exist" % creg) return cregs[creg] def u(self, arg, qubit, nested_scope=None): """Fundamental single qubit gate. arg is 3-tuple of Node expression objects. qubit is (regname,idx) tuple. nested_scope is a list of dictionaries mapping expression variables to Node expression objects in order of increasing nesting depth. """ if self.listen: if "U" not in self.basis: self.basis.append("U") (theta, phi, lam) = list(map(lambda x: x.sym(nested_scope), arg)) this_gate = self.circuit.u_base(theta, phi, lam, self._map_qubit(qubit)) if self.creg is not None: this_gate.c_if(self._map_creg(self.creg), self.cval) def cx(self, qubit0, qubit1): """Fundamental two qubit gate. qubit0 is (regname,idx) tuple for the control qubit. qubit1 is (regname,idx) tuple for the target qubit. """ if self.listen: if "CX" not in self.basis: self.basis.append("CX") this_gate = self.circuit.cx_base(self._map_qubit(qubit0), self._map_qubit(qubit1)) if self.creg is not None: this_gate.c_if(self._map_creg(self.creg), self.cval) def measure(self, qubit, bit): """Measurement operation. qubit is (regname, idx) tuple for the input qubit. bit is (regname, idx) tuple for the output bit. """ if "measure" not in self.basis: self.basis.append("measure") this_op = self.circuit.measure(self._map_qubit(qubit), self._map_bit(bit)) if self.creg is not None: this_op.c_if(self._map_creg(self.creg), self.cval) def barrier(self, qubitlists): """Barrier instruction. qubitlists is a list of lists of (regname, idx) tuples. """ if self.listen: if "barrier" not in self.basis: self.basis.append("barrier") flatlist = map(self._map_qubit, [qubit for qubitlist in qubitlists for qubit in qubitlist]) self.circuit.barrier(*list(flatlist)) def reset(self, qubit): """Reset instruction. qubit is a (regname, idx) tuple. """ if "reset" not in self.basis: self.basis.append("reset") this_op = self.circuit.reset(self._map_qubit(qubit)) if self.creg is not None: this_op.c_if(self._map_creg(self.creg), self.cval) def set_condition(self, creg, cval): """Attach a current condition. creg is a name string. cval is the integer value for the test. """ self.creg = creg self.cval = cval def drop_condition(self): """Drop the current condition.""" self.creg = None self.cval = None def start_gate(self, name, args, qubits, nested_scope=None): """Begin a custom gate. name is name string. args is list of Node expression objects. qubits is list of (regname, idx) tuples. nested_scope is a list of dictionaries mapping expression variables to Node expression objects in order of increasing nesting depth. """ if self.listen and name not in self.basis \ and self.gates[name]["opaque"]: raise BackendError("opaque gate %s not in basis" % name) if self.listen and name in self.basis: self.in_gate = name self.listen = False # Gate names mapped to number of arguments and qubits # and method to invoke on [args, qubits] lut = {"ccx": [(0, 3), lambda x: self.circuit.ccx(x[1][0], x[1][1], x[1][2])], "ch": [(0, 2), lambda x: self.circuit.ch(x[1][0], x[1][1])], "crz": [(1, 2), lambda x: self.circuit.crz(x[0][0], x[1][0], x[1][1])], "cswap": [(0, 3), lambda x: self.circuit.cswap(x[1][0], x[1][1], x[1][2])], "cu1": [(1, 2), lambda x: self.circuit.cu1(x[0][0], x[1][0], x[1][1])], "cu3": [(3, 2), lambda x: self.circuit.cu3(x[0][0], x[0][1], x[0][2], x[1][0], x[1][1])], "cx": [(0, 2), lambda x: self.circuit.cx(x[1][0], x[1][1])], "cy": [(0, 2), lambda x: self.circuit.cy(x[1][0], x[1][1])], "cz": [(0, 2), lambda x: self.circuit.cz(x[1][0], x[1][1])], "swap": [(0, 2), lambda x: self.circuit.swap(x[1][0], x[1][1])], "h": [(0, 1), lambda x: self.circuit.h(x[1][0])], "id": [(0, 1), lambda x: self.circuit.iden(x[1][0])], "rx": [(1, 1), lambda x: self.circuit.rx(x[0][0], x[1][0])], "ry": [(1, 1), lambda x: self.circuit.ry(x[0][0], x[1][0])], "rz": [(1, 1), lambda x: self.circuit.rz(x[0][0], x[1][0])], "s": [(0, 1), lambda x: self.circuit.s(x[1][0])], "sdg": [(0, 1), lambda x: self.circuit.s(x[1][0]).inverse()], "t": [(0, 1), lambda x: self.circuit.t(x[1][0]).inverse()], "tdg": [(0, 1), lambda x: self.circuit.t(x[1][0]).inverse()], "u1": [(1, 1), lambda x: self.circuit.u1(x[0][0], x[1][0])], "u2": [(2, 1), lambda x: self.circuit.u2(x[0][0], x[0][1], x[1][0])], "u3": [(3, 1), lambda x: self.circuit.u3(x[0][0], x[0][1], x[0][2], x[1][0])], "x": [(0, 1), lambda x: self.circuit.x(x[1][0])], "y": [(0, 1), lambda x: self.circuit.y(x[1][0])], "z": [(0, 1), lambda x: self.circuit.z(x[1][0])]} if name not in lut: raise BackendError("gate %s not in standard extensions" % name) gate_data = lut[name] if gate_data[0] != (len(args), len(qubits)): raise BackendError("gate %s signature (%d, %d) is " % (name, len(args), len(qubits)) + "incompatible with the standard " + "extensions") this_gate = gate_data[1]([list(map(lambda x: x.sym(nested_scope), args)), list(map(self._map_qubit, qubits))]) if self.creg is not None: this_gate.c_if(self._map_creg(self.creg), self.cval) def end_gate(self, name, args, qubits, nested_scope=None): """End a custom gate. name is name string. args is list of Node expression objects. qubits is list of (regname, idx) tuples. nested_scope is a list of dictionaries mapping expression variables to Node expression objects in order of increasing nesting depth. """ if name == self.in_gate: self.in_gate = "" self.listen = True def get_output(self): """Return the QuantumCircuit object.""" return self.circuit