def test_raises(self):
"""test instruction which can't be converted raises"""
circ1 = QuantumCircuit(3)
circ1.x(0)
circ1.cx(0, 1)
circ1.barrier()
inst1 = circuit_to_instruction(circ1)
circ2 = QuantumCircuit(1, 1)
circ2.measure(0, 0)
inst2 = circuit_to_instruction(circ2)
with self.assertRaises(QiskitError):
instruction_to_gate(inst1)
instruction_to_gate(inst2)
def test_simple_instruction(self):
"""test simple instruction"""
qr1 = QuantumRegister(4, 'qr1')
qr2 = QuantumRegister(3, 'qr2')
qr3 = QuantumRegister(3, 'qr3')
circ = QuantumCircuit(qr1, qr2, qr3)
circ.cx(qr1[1], qr2[2])
inst = circuit_to_instruction(circ)
gate = instruction_to_gate(inst)
q = QuantumRegister(10, 'q')
self.assertIsInstance(gate, Gate)
self.assertEqual(gate.definition[0][1], [q[1], q[6]])
def test_registerless_classical_bits(self):
"""Test that conditions on registerless classical bits can be handled during the conversion.
Regression test of gh-7394."""
expected = QuantumCircuit([Qubit(), Clbit()])
expected.h(0).c_if(expected.clbits[0], 0)
test = circuit_to_instruction(expected)
self.assertIsInstance(test, Instruction)
self.assertIsInstance(test.definition, QuantumCircuit)
self.assertEqual(len(test.definition.data), 1)
test_instruction, _, _ = test.definition.data[0]
expected_instruction, _, _ = expected.data[0]
self.assertIs(type(test_instruction), type(expected_instruction))
self.assertEqual(test_instruction.condition, (test.definition.clbits[0], 0))
def test_flatten_circuit_registers(self):
"""Check correct flattening"""
qr1 = QuantumRegister(4, 'qr1')
qr2 = QuantumRegister(3, 'qr2')
qr3 = QuantumRegister(3, 'qr3')
cr1 = ClassicalRegister(4, 'cr1')
cr2 = ClassicalRegister(1, 'cr2')
circ = QuantumCircuit(qr1, qr2, qr3, cr1, cr2)
circ.cx(qr1[1], qr2[2])
circ.measure(qr3[0], cr2[0])
inst = circuit_to_instruction(circ)
q = QuantumRegister(10, 'q')
c = ClassicalRegister(5, 'c')
self.assertEqual(inst.definition[0][1], [q[1], q[6]])
self.assertEqual(inst.definition[1][1], [q[7]])
self.assertEqual(inst.definition[1][2], [c[4]])
def test_flatten_parameters(self):
"""Verify parameters from circuit are moved to instruction.params"""
qr = QuantumRegister(3, 'qr')
qc = QuantumCircuit(qr)
theta = Parameter('theta')
phi = Parameter('phi')
qc.rz(theta, qr[0])
qc.rz(phi, qr[1])
qc.u2(theta, phi, qr[2])
inst = circuit_to_instruction(qc)
self.assertEqual(inst.params, [phi, theta])
self.assertEqual(inst.definition[0][0].params, [theta])
self.assertEqual(inst.definition[1][0].params, [phi])
self.assertEqual(inst.definition[2][0].params, [theta, phi])
def test_flatten_circuit_registers(self):
"""Check correct flattening"""
qr1 = QuantumRegister(4, "qr1")
qr2 = QuantumRegister(3, "qr2")
qr3 = QuantumRegister(3, "qr3")
cr1 = ClassicalRegister(4, "cr1")
cr2 = ClassicalRegister(1, "cr2")
circ = QuantumCircuit(qr1, qr2, qr3, cr1, cr2)
circ.cx(qr1[1], qr2[2])
circ.measure(qr3[0], cr2[0])
inst = circuit_to_instruction(circ)
q = QuantumRegister(10, "q")
c = ClassicalRegister(5, "c")
self.assertEqual(inst.definition[0].qubits, (q[1], q[6]))
self.assertEqual(inst.definition[1].qubits, (q[7], ))
self.assertEqual(inst.definition[1].clbits, (c[4], ))
def test_parameter_map(self):
"""Verify alternate parameter specification"""
qr = QuantumRegister(3, 'qr')
qc = QuantumCircuit(qr)
theta = Parameter('theta')
phi = Parameter('phi')
gamma = Parameter('gamma')
qc.rz(theta, qr[0])
qc.rz(phi, qr[1])
qc.u2(theta, phi, qr[2])
inst = circuit_to_instruction(qc, {theta: gamma, phi: phi})
self.assertEqual(inst.params, [gamma, phi])
self.assertEqual(inst.definition[0][0].params, [gamma])
self.assertEqual(inst.definition[1][0].params, [phi])
self.assertEqual(inst.definition[2][0].params, [gamma, phi])
def test_flatten_parameters(self):
"""Verify parameters from circuit are moved to instruction.params"""
qr = QuantumRegister(3, "qr")
qc = QuantumCircuit(qr)
theta = Parameter("theta")
phi = Parameter("phi")
sum_ = theta + phi
qc.rz(theta, qr[0])
qc.rz(phi, qr[1])
qc.u(theta, phi, 0, qr[2])
qc.rz(sum_, qr[0])
inst = circuit_to_instruction(qc)
self.assertEqual(inst.params, [phi, theta])
self.assertEqual(inst.definition[0][0].params, [theta])
self.assertEqual(inst.definition[1][0].params, [phi])
self.assertEqual(inst.definition[2][0].params, [theta, phi, 0])
self.assertEqual(str(inst.definition[3][0].params[0]), "phi + theta")
def test_converter_gate_registration(self):
"""Verify converters register gates in session equivalence library."""
qc_gate = QuantumCircuit(2)
qc_gate.h(0)
qc_gate.cx(0, 1)
from qiskit.circuit.equivalence_library import SessionEquivalenceLibrary as sel
bell_gate = circuit_to_gate(qc_gate, equivalence_library=sel)
qc_inst = QuantumCircuit(2)
qc_inst.h(0)
qc_inst.cx(0, 1)
bell_inst = circuit_to_instruction(qc_inst, equivalence_library=sel)
gate_entry = sel.get_entry(bell_gate)
inst_entry = sel.get_entry(bell_inst)
self.assertEqual(len(gate_entry), 1)
self.assertEqual(len(inst_entry), 1)
self.assertEqual(gate_entry[0], qc_gate)
self.assertEqual(inst_entry[0], qc_inst)
def test_parameter_map(self):
"""Verify alternate parameter specification"""
qr = QuantumRegister(3, "qr")
qc = QuantumCircuit(qr)
theta = Parameter("theta")
phi = Parameter("phi")
sum_ = theta + phi
gamma = Parameter("gamma")
qc.rz(theta, qr[0])
qc.rz(phi, qr[1])
qc.u(theta, phi, 0, qr[2])
qc.rz(sum_, qr[0])
inst = circuit_to_instruction(qc, {theta: gamma, phi: phi})
self.assertEqual(inst.params, [gamma, phi])
self.assertEqual(inst.definition[0][0].params, [gamma])
self.assertEqual(inst.definition[1][0].params, [phi])
self.assertEqual(inst.definition[2][0].params, [gamma, phi, 0])
self.assertEqual(str(inst.definition[3][0].params[0]), "gamma + phi")
def test_flatten_circuit_overlapping_registers(self):
"""Test that the conversion works when the given circuit has bits that are contained in more
than one register."""
qubits = [Qubit() for _ in [None] * 10]
qr1 = QuantumRegister(bits=qubits[:6])
qr2 = QuantumRegister(bits=qubits[4:])
clbits = [Clbit() for _ in [None] * 10]
cr1 = ClassicalRegister(bits=clbits[:6])
cr2 = ClassicalRegister(bits=clbits[4:])
circ = QuantumCircuit(qubits, clbits, qr1, qr2, cr1, cr2)
circ.cx(3, 5)
circ.measure(4, 4)
inst = circuit_to_instruction(circ)
self.assertEqual(inst.num_qubits, len(qubits))
self.assertEqual(inst.num_clbits, len(clbits))
inst_definition = inst.definition
_, cx_qargs, cx_cargs = inst_definition.data[0]
_, measure_qargs, measure_cargs = inst_definition.data[1]
self.assertEqual(cx_qargs, [inst_definition.qubits[3], inst_definition.qubits[5]])
self.assertEqual(cx_cargs, [])
self.assertEqual(measure_qargs, [inst_definition.qubits[4]])
self.assertEqual(measure_cargs, [inst_definition.clbits[4]])
def test_flatten_circuit_registerless(self):
"""Test that the conversion works when the given circuit has bits that are not contained in
any register."""
qr1 = QuantumRegister(2)
qubits = [Qubit(), Qubit(), Qubit()]
qr2 = QuantumRegister(3)
cr1 = ClassicalRegister(2)
clbits = [Clbit(), Clbit(), Clbit()]
cr2 = ClassicalRegister(3)
circ = QuantumCircuit(qr1, qubits, qr2, cr1, clbits, cr2)
circ.cx(3, 5)
circ.measure(4, 4)
inst = circuit_to_instruction(circ)
self.assertEqual(inst.num_qubits, len(qr1) + len(qubits) + len(qr2))
self.assertEqual(inst.num_clbits, len(cr1) + len(clbits) + len(cr2))
inst_definition = inst.definition
_, cx_qargs, cx_cargs = inst_definition.data[0]
_, measure_qargs, measure_cargs = inst_definition.data[1]
self.assertEqual(cx_qargs, [inst_definition.qubits[3], inst_definition.qubits[5]])
self.assertEqual(cx_cargs, [])
self.assertEqual(measure_qargs, [inst_definition.qubits[4]])
self.assertEqual(measure_cargs, [inst_definition.clbits[4]])
def test_flatten_registers_of_circuit_single_bit_cond(self):
"""Check correct mapping of registers gates conditioned on single classical bits."""
qr1 = QuantumRegister(2, "qr1")
qr2 = QuantumRegister(3, "qr2")
cr1 = ClassicalRegister(3, "cr1")
cr2 = ClassicalRegister(3, "cr2")
circ = QuantumCircuit(qr1, qr2, cr1, cr2)
circ.h(qr1[0]).c_if(cr1[1], True)
circ.h(qr2[1]).c_if(cr2[0], False)
circ.cx(qr1[1], qr2[2]).c_if(cr2[2], True)
circ.measure(qr2[2], cr2[0])
inst = circuit_to_instruction(circ)
q = QuantumRegister(5, "q")
c = ClassicalRegister(6, "c")
self.assertEqual(inst.definition[0][1], [q[0]])
self.assertEqual(inst.definition[1][1], [q[3]])
self.assertEqual(inst.definition[2][1], [q[1], q[4]])
self.assertEqual(inst.definition[0][0].condition, (c[1], True))
self.assertEqual(inst.definition[1][0].condition, (c[3], False))
self.assertEqual(inst.definition[2][0].condition, (c[5], True))
def time_circuit_to_instruction(self, *_):
converters.circuit_to_instruction(self.qc)
def test_unrolling_parameterized_composite_gates(self):
"""Verify unrolling circuits with parameterized composite gates."""
mock_sel = EquivalenceLibrary(base=std_eqlib)
qr1 = QuantumRegister(2)
subqc = QuantumCircuit(qr1)
theta = Parameter('theta')
subqc.rz(theta, qr1[0])
subqc.cx(qr1[0], qr1[1])
subqc.rz(theta, qr1[1])
# Expanding across register with shared parameter
qr2 = QuantumRegister(4)
qc = QuantumCircuit(qr2)
sub_instr = circuit_to_instruction(subqc, equivalence_library=mock_sel)
qc.append(sub_instr, [qr2[0], qr2[1]])
qc.append(sub_instr, [qr2[2], qr2[3]])
dag = circuit_to_dag(qc)
pass_ = UnrollCustomDefinitions(mock_sel, ['p', 'cx'])
dag = pass_.run(dag)
out_dag = BasisTranslator(mock_sel, ['p', 'cx']).run(dag)
# Pick up -1 * theta / 2 global phase four twice (once for each RZ -> P
# in each of the two sub_instr instructions).
expected = QuantumCircuit(qr2, global_phase=-1 * 4 * theta / 2.0)
expected.p(theta, qr2[0])
expected.p(theta, qr2[2])
expected.cx(qr2[0], qr2[1])
expected.cx(qr2[2], qr2[3])
expected.p(theta, qr2[1])
expected.p(theta, qr2[3])
self.assertEqual(circuit_to_dag(expected), out_dag)
# Expanding across register with shared parameter
qc = QuantumCircuit(qr2)
phi = Parameter('phi')
gamma = Parameter('gamma')
sub_instr = circuit_to_instruction(subqc, {theta: phi}, mock_sel)
qc.append(sub_instr, [qr2[0], qr2[1]])
sub_instr = circuit_to_instruction(subqc, {theta: gamma}, mock_sel)
qc.append(sub_instr, [qr2[2], qr2[3]])
dag = circuit_to_dag(qc)
pass_ = UnrollCustomDefinitions(mock_sel, ['p', 'cx'])
dag = pass_.run(dag)
out_dag = BasisTranslator(mock_sel, ['p', 'cx']).run(dag)
expected = QuantumCircuit(qr2,
global_phase=-1 * (2 * phi + 2 * gamma) /
2.0)
expected.p(phi, qr2[0])
expected.p(gamma, qr2[2])
expected.cx(qr2[0], qr2[1])
expected.cx(qr2[2], qr2[3])
expected.p(phi, qr2[1])
expected.p(gamma, qr2[3])
self.assertEqual(circuit_to_dag(expected), out_dag)
def test_unrolling_parameterized_composite_gates(self):
"""Verify unrolling circuits with parameterized composite gates."""
mock_sel = EquivalenceLibrary(base=std_eqlib)
qr1 = QuantumRegister(2)
subqc = QuantumCircuit(qr1)
theta = Parameter('theta')
subqc.rz(theta, qr1[0])
subqc.cx(qr1[0], qr1[1])
subqc.rz(theta, qr1[1])
# Expanding across register with shared parameter
qr2 = QuantumRegister(4)
qc = QuantumCircuit(qr2)
sub_instr = circuit_to_instruction(subqc, equivalence_library=mock_sel)
qc.append(sub_instr, [qr2[0], qr2[1]])
qc.append(sub_instr, [qr2[2], qr2[3]])
dag = circuit_to_dag(qc)
pass_ = UnrollCustomDefinitions(mock_sel, ['u1', 'cx'])
dag = pass_.run(dag)
out_dag = BasisTranslator(mock_sel, ['u1', 'cx']).run(dag)
expected = QuantumCircuit(qr2)
expected.u1(theta, qr2[0])
expected.u1(theta, qr2[2])
expected.cx(qr2[0], qr2[1])
expected.cx(qr2[2], qr2[3])
expected.u1(theta, qr2[1])
expected.u1(theta, qr2[3])
self.assertEqual(circuit_to_dag(expected), out_dag)
# Expanding across register with shared parameter
qc = QuantumCircuit(qr2)
phi = Parameter('phi')
gamma = Parameter('gamma')
sub_instr = circuit_to_instruction(subqc, {theta: phi}, mock_sel)
qc.append(sub_instr, [qr2[0], qr2[1]])
sub_instr = circuit_to_instruction(subqc, {theta: gamma}, mock_sel)
qc.append(sub_instr, [qr2[2], qr2[3]])
dag = circuit_to_dag(qc)
pass_ = UnrollCustomDefinitions(mock_sel, ['u1', 'cx'])
dag = pass_.run(dag)
out_dag = BasisTranslator(mock_sel, ['u1', 'cx']).run(dag)
expected = QuantumCircuit(qr2)
expected.u1(phi, qr2[0])
expected.u1(gamma, qr2[2])
expected.cx(qr2[0], qr2[1])
expected.cx(qr2[2], qr2[3])
expected.u1(phi, qr2[1])
expected.u1(gamma, qr2[3])
self.assertEqual(circuit_to_dag(expected), out_dag)
