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
