def setUp(self):
self.dag = DAGCircuit()
qreg = QuantumRegister(3, 'qr')
creg = ClassicalRegister(2, 'cr')
self.dag.add_qreg(qreg)
self.dag.add_creg(creg)
self.qubit0 = qreg[0]
self.qubit1 = qreg[1]
self.qubit2 = qreg[2]
self.clbit0 = creg[0]
self.clbit1 = creg[1]
self.condition = (creg, 3)
self.dag.apply_operation_back(HGate(self.qubit0))
self.dag.apply_operation_back(CnotGate(self.qubit0, self.qubit1))
self.dag.apply_operation_back(XGate(self.qubit1))
def test_default_shots_greater_than_max_shots(self):
"""Test assembling with default shots greater than max shots"""
qr = QuantumRegister(2, name='q')
qc = ClassicalRegister(2, name='c')
circ = QuantumCircuit(qr, qc, name='circ')
circ.h(qr[0])
circ.cx(qr[0], qr[1])
circ.measure(qr, qc)
backend = FakeYorktown()
backend._configuration.max_shots = 5
qobj = assemble(circ, backend)
validate_qobj_against_schema(qobj)
self.assertIsInstance(qobj, QasmQobj)
self.assertEqual(qobj.config.shots, 5)
def test_dag_depth2(self):
"""Test barrier increases DAG depth
"""
q = QuantumRegister(5, 'q')
c = ClassicalRegister(1, 'c')
qc = QuantumCircuit(q, c)
qc.h(q[0])
qc.cx(q[0], q[4])
qc.x(q[2])
qc.x(q[2])
qc.x(q[2])
qc.x(q[4])
qc.cx(q[4], q[1])
qc.barrier(q)
qc.measure(q[1], c[0])
dag = circuit_to_dag(qc)
self.assertEqual(dag.depth(), 6)
def test_assemble_single_circuit(self):
"""Test assembling a single circuit.
"""
qr = QuantumRegister(2, name='q')
cr = ClassicalRegister(2, name='c')
circ = QuantumCircuit(qr, cr, name='circ')
circ.h(qr[0])
circ.cx(qr[0], qr[1])
circ.measure(qr, cr)
run_config = RunConfig(shots=2000, memory=True)
qobj = assemble_circuits(circ, run_config=run_config)
self.assertIsInstance(qobj, QasmQobj)
self.assertEqual(qobj.config.shots, 2000)
self.assertEqual(qobj.config.memory, True)
self.assertEqual(len(qobj.experiments), 1)
self.assertEqual(qobj.experiments[0].instructions[1].name, 'cx')
def setUp(self):
"""Initial test setup."""
super().setUp()
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
self.qc1 = QuantumCircuit(qr, cr, name='qc1')
self.qc2 = QuantumCircuit(qr, cr, name='qc2')
self.qc1.h(qr)
self.qc2.h(qr[0])
self.qc2.cx(qr[0], qr[1])
self.qc1.measure(qr[0], cr[0])
self.qc1.measure(qr[1], cr[1])
self.qc2.measure(qr[0], cr[0])
self.qc2.measure(qr[1], cr[1])
self.seed = 73846087
self.fake_server = None
def test_dag_depth3(self):
"""Test DAG depth for silly circuit.
"""
q = QuantumRegister(6, 'q')
c = ClassicalRegister(1, 'c')
qc = QuantumCircuit(q, c)
qc.h(q[0])
qc.cx(q[0], q[1])
qc.cx(q[1], q[2])
qc.cx(q[2], q[3])
qc.cx(q[3], q[4])
qc.cx(q[4], q[5])
qc.barrier(q[0])
qc.barrier(q[0])
qc.measure(q[0], c[0])
dag = circuit_to_dag(qc)
self.assertEqual(dag.depth(), 6)
def after_operation(self):
delayed_circ = []
for qc_i in self.circuits:
qr = QuantumRegister(qc_i.num_qubits)
cr = ClassicalRegister(qc_i.num_qubits)
delayed_qc = QuantumCircuit(qr, cr)
delayed_qc.compose(qc_i, inplace=True) # operation
delayed_qc.barrier()
delayed_qc.delay(duration=self.duration, qarg=qr, unit=self.unit)
delayed_qc.barrier()
delayed_qc.measure(delayed_qc.qubits, delayed_qc.clbits)
delayed_circ.append(delayed_qc)
if len(delayed_circ) == 1:
return delayed_circ[0]
return delayed_circ
def test_disassemble_no_run_config(self):
"""Test disassembling with no run_config, relying on default."""
qr = QuantumRegister(2, name="q")
qc = ClassicalRegister(2, name="c")
circ = QuantumCircuit(qr, qc, name="circ")
circ.h(qr[0])
circ.cx(qr[0], qr[1])
circ.measure(qr, qc)
qobj = assemble(circ)
circuits, run_config_out, headers = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.n_qubits, 2)
self.assertEqual(run_config_out.memory_slots, 2)
self.assertEqual(len(circuits), 1)
self.assertEqual(circuits[0], circ)
self.assertEqual({}, headers)
def test_while_loop_no_iteration(self, method):
backend = self.backend(method=method)
qreg = QuantumRegister(1)
creg = ClassicalRegister(1)
circ = QuantumCircuit(qreg, creg)
circ.measure(0, 0)
with circ.while_loop((creg, 1)):
circ.y(0)
circ.measure_all()
result = backend.run(circ, method=method).result()
self.assertSuccess(result)
counts = result.get_counts()
self.assertEqual(len(counts), 1)
self.assertIn('0 0', counts)
def construct_circuit(
self,
estimation_problem: EstimationProblem,
k: int,
measurement: bool = False
) -> Union[QuantumCircuit, Tuple[QuantumCircuit, List[int]]]:
r"""Construct the circuit :math:`Q^k X |0\rangle>`.
The A operator is the unitary specifying the QAE problem and Q the associated Grover
operator.
Args:
estimation_problem: The estimation problem for which to construct the circuit.
k: The power of the Q operator.
measurement: Boolean flag to indicate if measurements should be included in the
circuits.
Returns:
The circuit :math:`Q^k X |0\rangle`.
"""
num_qubits = max(estimation_problem.state_preparation.num_qubits,
estimation_problem.grover_operator.num_qubits)
circuit = QuantumCircuit(num_qubits, name='circuit')
# add classical register if needed
if measurement:
c = ClassicalRegister(len(estimation_problem.objective_qubits))
circuit.add_register(c)
# add A operator
circuit.compose(estimation_problem.state_preparation, inplace=True)
# add Q^k
if k != 0:
circuit.compose(estimation_problem.grover_operator.power(k),
inplace=True)
# add optional measurement
if measurement:
# real hardware can currently not handle operations after measurements, which might
# happen if the circuit gets transpiled, hence we're adding a safeguard-barrier
circuit.barrier()
circuit.measure(estimation_problem.objective_qubits, c[:])
return circuit
def test_opaque_instruction(self):
"""Test the disassembler handles opaque instructions correctly."""
opaque_inst = Instruction(name='my_inst',
num_qubits=4,
num_clbits=2,
params=[0.5, 0.4])
q = QuantumRegister(6, name='q')
c = ClassicalRegister(4, name='c')
circ = QuantumCircuit(q, c, name='circ')
circ.append(opaque_inst, [q[0], q[2], q[5], q[3]], [c[3], c[0]])
qobj = assemble(circ)
circuits, run_config_out, header = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.n_qubits, 6)
self.assertEqual(run_config_out.memory_slots, 4)
self.assertEqual(len(circuits), 1)
self.assertEqual(circuits[0], circ)
self.assertEqual({}, header)
def test_assemble_opaque_inst(self):
"""Test opaque instruction is assembled as-is"""
opaque_inst = Instruction(name='my_inst', num_qubits=4,
num_clbits=2, params=[0.5, 0.4])
q = QuantumRegister(6, name='q')
c = ClassicalRegister(4, name='c')
circ = QuantumCircuit(q, c, name='circ')
circ.append(opaque_inst, [q[0], q[2], q[5], q[3]], [c[3], c[0]])
qobj = assemble(circ)
validate_qobj_against_schema(qobj)
self.assertIsInstance(qobj, QasmQobj)
self.assertEqual(len(qobj.experiments[0].instructions), 1)
self.assertEqual(qobj.experiments[0].instructions[0].name, 'my_inst')
self.assertEqual(qobj.experiments[0].instructions[0].qubits, [0, 2, 5, 3])
self.assertEqual(qobj.experiments[0].instructions[0].memory, [3, 0])
self.assertEqual(qobj.experiments[0].instructions[0].params, [0.5, 0.4])
def test_mirror_gate(self):
"""test mirroring a composite gate"""
q = QuantumRegister(4)
c = ClassicalRegister(4)
circ = QuantumCircuit(q, c, name='circ')
circ.h(q[0])
circ.crz(0.1, q[0], q[1])
circ.iden(q[1])
circ.u3(0.1, 0.2, -0.2, q[0])
gate = circ.to_instruction()
circ = QuantumCircuit(q, c, name='circ')
circ.u3(0.1, 0.2, -0.2, q[0])
circ.iden(q[1])
circ.crz(0.1, q[0], q[1])
circ.h(q[0])
gate_mirror = circ.to_instruction()
self.assertEqual(gate.mirror().definition, gate_mirror.definition)
def test_apply_operation_back_conditional_measure(self):
"""Test consistency of apply_operation_back for conditional measure."""
# Measure targeting a clbit which is not a member of the conditional
# register. qc.measure(qr[0], cr[0]).c_if(cr2, 0)
new_creg = ClassicalRegister(1, 'cr2')
self.dag.add_creg(new_creg)
meas_gate = Measure()
meas_gate.condition = (new_creg, 0)
meas_node = self.dag.apply_operation_back(
meas_gate, [self.qubit0], [self.clbit0], meas_gate.condition)
self.assertEqual(meas_node.qargs, [self.qubit0])
self.assertEqual(meas_node.cargs, [self.clbit0])
self.assertEqual(meas_node.condition, meas_gate.condition)
self.assertEqual(
sorted(self.dag._get_multi_graph_in_edges(meas_node._node_id)),
sorted([
(self.dag.input_map[self.qubit0]._node_id, meas_node._node_id,
{'wire': self.qubit0, 'name': 'qr[0]'}),
(self.dag.input_map[self.clbit0]._node_id, meas_node._node_id,
{'wire': self.clbit0, 'name': 'cr[0]'}),
(self.dag.input_map[new_creg[0]]._node_id, meas_node._node_id,
{'wire': Clbit(new_creg, 0), 'name': 'cr2[0]'}),
]))
self.assertEqual(
sorted(self.dag._get_multi_graph_out_edges(meas_node._node_id)),
sorted([
(meas_node._node_id, self.dag.output_map[self.qubit0]._node_id,
{'wire': self.qubit0, 'name': 'qr[0]'}),
(meas_node._node_id, self.dag.output_map[self.clbit0]._node_id,
{'wire': self.clbit0, 'name': 'cr[0]'}),
(meas_node._node_id, self.dag.output_map[new_creg[0]]._node_id,
{'wire': Clbit(new_creg, 0), 'name': 'cr2[0]'}),
]))
if self.dag._USE_RX:
self.assertTrue(rx.is_directed_acyclic_graph(self.dag._multi_graph))
else:
self.assertTrue(nx.is_directed_acyclic_graph(self.dag._multi_graph))
def test_validate_nr_classical_qubits_less_than_needed_for_storing_measured_qubits(
self):
api = Mock()
api.create_project.return_value = {'id': 42}
api.execute_qasm_async.return_value = 42
api.get_backend_type_by_name.return_value = {
'max_number_of_shots': 4096
}
simulator = QuantumInspireBackend(api, Mock())
q = QuantumRegister(2, "q")
c = ClassicalRegister(1, "c")
qc = QuantumCircuit(q, c, name="conditional")
qc.cx(q[0], q[1])
self.assertRaisesRegex(
QiskitBackendError,
'Number of classical bits \(1\) is not sufficient for storing the '
'outcomes of the experiment', simulator.run, qc)
def test_transpile_mumbai_target(self):
"""Test that transpile respects a more involved target for a fake mumbai."""
backend = FakeMumbaiFractionalCX()
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(1, 0)
qc.measure_all()
tqc = transpile(qc, backend)
qr = QuantumRegister(27, "q")
cr = ClassicalRegister(2, "meas")
expected = QuantumCircuit(qr, cr, global_phase=math.pi / 4)
expected.rz(math.pi / 2, 0)
expected.sx(0)
expected.rz(math.pi / 2, 0)
expected.cx(1, 0)
expected.barrier(qr[0:2])
expected.measure(qr[0], cr[0])
expected.measure(qr[1], cr[1])
self.assertEqual(expected, tqc)
def test_circuit_with_swap_gate(self):
"""Test if a virtual circuit with one swap gate is transformed into
a circuit with physical qubits.
[Circuit with virtual qubits]
v0:--X---.---M(v0->c0)
| |
v1:--X---|---M(v1->c1)
|
v2:-----(+)--M(v2->c2)
Initial layout: {v[0]: 2, v[1]: 1, v[2]: 0}
[Circuit with physical qubits]
q2:--X---.---M(q2->c0)
| |
q1:--X---|---M(q1->c1)
|
q0:-----(+)--M(q0->c2)
"""
v = QuantumRegister(3, "v")
cr = ClassicalRegister(3, "c")
circuit = QuantumCircuit(v, cr)
circuit.swap(v[0], v[1])
circuit.cx(v[0], v[2])
circuit.measure(v[0], cr[0])
circuit.measure(v[1], cr[1])
circuit.measure(v[2], cr[2])
q = QuantumRegister(3, "q")
expected = QuantumCircuit(q, cr)
expected.swap(q[2], q[1])
expected.cx(q[2], q[0])
expected.measure(q[2], cr[0])
expected.measure(q[1], cr[1])
expected.measure(q[0], cr[2])
dag = circuit_to_dag(circuit)
pass_ = ApplyLayout()
pass_.property_set["layout"] = Layout({v[0]: 2, v[1]: 1, v[2]: 0})
after = pass_.run(dag)
self.assertEqual(circuit_to_dag(expected), after)
def test_convert_to_bfunc_plus_conditional(self):
"""Verify assemble_circuits converts conditionals from QASM to Qobj."""
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr, cr)
qc.h(qr[0]).c_if(cr, 1)
qobj = assemble(qc)
bfunc_op, h_op = qobj.experiments[0].instructions
self.assertEqual(bfunc_op.name, 'bfunc')
self.assertEqual(bfunc_op.mask, '0x1')
self.assertEqual(bfunc_op.val, '0x1')
self.assertEqual(bfunc_op.relation, '==')
self.assertTrue(hasattr(h_op, 'conditional'))
self.assertEqual(bfunc_op.register, h_op.conditional)
def test_mixed(self):
"""Test composing on named and unnamed registers."""
qr = QuantumRegister(1, "my_qr")
cr = ClassicalRegister(1, "my_cr")
top = QuantumCircuit(qr, cr)
top.x(0)
top.measure(0, 0)
bottom = QuantumCircuit(2)
bottom.y(0)
bottom.z(1)
expect = QuantumCircuit(qr, *bottom.qregs, cr)
expect.x(0)
expect.y(1)
expect.z(2)
expect.measure(0, 0)
self.assertEqual(bottom.tensor(top), expect)
def setUp(self):
qreg1 = QuantumRegister(3, 'lqr_1')
qreg2 = QuantumRegister(2, 'lqr_2')
creg = ClassicalRegister(2, 'lcr')
self.circuit_left = QuantumCircuit(qreg1, qreg2, creg)
self.circuit_left.h(qreg1[0])
self.circuit_left.x(qreg1[1])
self.circuit_left.u1(0.1, qreg1[2])
self.circuit_left.cx(qreg2[0], qreg2[1])
self.left_qubit0 = qreg1[0]
self.left_qubit1 = qreg1[1]
self.left_qubit2 = qreg1[2]
self.left_qubit3 = qreg2[0]
self.left_qubit4 = qreg2[1]
self.left_clbit0 = creg[0]
self.left_clbit1 = creg[1]
self.condition = (creg, 3)
def test_circuit_with_single_bit_conditions(self):
"""Verify disassemble handles a simple conditional on a single bit of a register."""
# This circuit would fail to perfectly round-trip if 'cr' below had only one bit in it.
# This is because the format of QasmQobj is insufficient to disambiguate single-bit
# conditions from conditions on registers with only one bit. Since single-bit conditions are
# mostly a hack for the QasmQobj format at all, `disassemble` always prefers to return the
# register if it can. It would also fail if registers overlap.
qr = QuantumRegister(1)
cr = ClassicalRegister(2)
qc = QuantumCircuit(qr, cr)
qc.h(qr[0]).c_if(cr[0], 1)
qobj = assemble(qc)
circuits, run_config_out, header = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.n_qubits, len(qr))
self.assertEqual(run_config_out.memory_slots, len(cr))
self.assertEqual(len(circuits), 1)
self.assertEqual(circuits[0], qc)
self.assertEqual({}, header)
def circuit_instruction_circuit_roundtrip(self):
"""test converting between circuit and instruction and back
preserves the circuit"""
q = QuantumRegister(4)
c = ClassicalRegister(4)
circ1 = QuantumCircuit(q, c, name='circuit1')
circ1.h(q[0])
circ1.crz(0.1, q[0], q[1])
circ1.iden(q[1])
circ1.u3(0.1, 0.2, -0.2, q[0])
circ1.barrier()
circ1.measure(q, c)
circ1.rz(0.8, q[0]).c_if(c, 6)
inst = circ1.to_instruction()
circ2 = QuantumCircuit(q, c, name='circ2')
circ2.append(inst, q[:])
self.assertEqual(circ1, circ2)
def test_no_broadcast(self):
"""See https://github.com/Qiskit/qiskit-terra/issues/2777
When creating custom instructions, do not broadcast parameters"""
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
subcircuit = QuantumCircuit(qr, cr, name='subcircuit')
subcircuit.x(qr[0])
subcircuit.h(qr[1])
subcircuit.measure(qr[0], cr[0])
subcircuit.measure(qr[1], cr[1])
inst = subcircuit.to_instruction()
circuit = QuantumCircuit(qr, cr, name='circuit')
circuit.append(inst, qr[:], cr[:])
self.assertEqual(circuit.qregs, [qr])
self.assertEqual(circuit.cregs, [cr])
self.assertEqual(circuit.qubits, [qr[0], qr[1]])
self.assertEqual(circuit.clbits, [cr[0], cr[1]])
def test_dag_depth1(self):
"""Test DAG depth #1
"""
q1 = QuantumRegister(3, 'q1')
q2 = QuantumRegister(2, 'q2')
c = ClassicalRegister(5, 'c')
qc = QuantumCircuit(q1, q2, c)
qc.h(q1[0])
qc.h(q1[1])
qc.h(q1[2])
qc.h(q2[0])
qc.h(q2[1])
qc.ccx(q2[1], q1[0], q2[0])
qc.cx(q1[0], q1[1])
qc.cx(q1[1], q2[1])
qc.cx(q2[1], q1[2])
qc.cx(q1[2], q2[0])
dag = circuit_to_dag(qc)
self.assertEqual(dag.depth(), 6)
def setUp(self):
self.dag = DAGCircuit()
qreg = QuantumRegister(3, 'qr')
creg = ClassicalRegister(2, 'cr')
self.dag.add_qreg(qreg)
self.dag.add_creg(creg)
self.dag.add_basis_element(name='h', number_qubits=1,
number_classical=0, number_parameters=0)
self.dag.add_basis_element('cx', 2, 0, 0)
self.dag.add_basis_element('x', 1, 0, 0)
self.dag.add_basis_element('measure', 1, 1, 0)
self.dag.add_basis_element('reset', 1, 0, 0)
self.qubit0 = qreg[0]
self.qubit1 = qreg[1]
self.qubit2 = qreg[2]
self.clbit0 = creg[0]
self.clbit1 = creg[1]
self.condition = (creg, 3)
def dag_to_circuit(dag):
"""Build a ``QuantumCircuit`` object from a ``DAGCircuit``.
Args:
dag (DAGCircuit): the input dag.
Return:
QuantumCircuit: the circuit representing the input dag.
"""
qregs = collections.OrderedDict()
for qreg in dag.qregs.values():
qreg_tmp = QuantumRegister(qreg.size, name=qreg.name)
qregs[qreg.name] = qreg_tmp
cregs = collections.OrderedDict()
for creg in dag.cregs.values():
creg_tmp = ClassicalRegister(creg.size, name=creg.name)
cregs[creg.name] = creg_tmp
name = dag.name or None
circuit = QuantumCircuit(*qregs.values(), *cregs.values(), name=name)
for node in dag.nodes_in_topological_order():
if node.type == 'op':
qubits = []
for qubit in node.qargs:
qubits.append(qregs[qubit[0].name][qubit[1]])
clbits = []
for clbit in node.cargs:
clbits.append(cregs[clbit[0].name][clbit[1]])
# Get arguments for classical control (if any)
if node.condition is None:
control = None
else:
control = (node.condition[0], node.condition[1])
inst = copy.deepcopy(node.op)
inst.control = control
circuit.append(inst, qubits, clbits)
return circuit
def test_do_not_merge_conditioned_gates(self):
"""Validate that classically conditioned gates are never considered for
inclusion in a block. Note that there are cases where gates conditioned
on the same (register, value) pair could be correctly merged, but this is
not yet implemented.
┌─────────┐┌─────────┐┌─────────┐ ┌───┐
qr_0: |0>┤ U1(0.1) ├┤ U1(0.2) ├┤ U1(0.3) ├──■───┤ X ├────■───
└─────────┘└────┬────┘└────┬────┘┌─┴─┐ └─┬─┘ ┌─┴─┐
qr_1: |0>────────────────┼──────────┼─────┤ X ├───■────┤ X ├─
│ │ └───┘ │ └─┬─┘
qr_2: |0>────────────────┼──────────┼─────────────┼──────┼───
┌──┴──┐ ┌──┴──┐ ┌──┴──┐┌──┴──┐
cr_0: 0 ═════════════╡ ╞════╡ ╞═══════╡ ╞╡ ╞
│ = 0 │ │ = 0 │ │ = 0 ││ = 1 │
cr_1: 0 ═════════════╡ ╞════╡ ╞═══════╡ ╞╡ ╞
└─────┘ └─────┘ └─────┘└─────┘
Previously the blocks collected were : [['u1', 'u1', 'u1', 'cx', 'cx', 'cx']]
This is now corrected to : [['cx']]
"""
# ref: https://github.com/Qiskit/qiskit-terra/issues/3215
print("BEGIN MERGE CONDITION ")
qr = QuantumRegister(3, "qr")
cr = ClassicalRegister(2, "cr")
qc = QuantumCircuit(qr, cr)
qc.u1(0.1, 0)
qc.u1(0.2, 0).c_if(cr, 0)
qc.u1(0.3, 0).c_if(cr, 0)
qc.cx(0, 1)
qc.cx(1, 0).c_if(cr, 0)
qc.cx(0, 1).c_if(cr, 1)
pass_manager = PassManager()
pass_manager.append(CollectMultiQBlocks())
pass_manager.run(qc)
for block in pass_manager.property_set["block_list"]:
self.assertTrue(len(block) <= 1)
def test_mirror_instruction(self):
"""test mirroring an instruction with conditionals"""
q = QuantumRegister(4)
c = ClassicalRegister(4)
circ = QuantumCircuit(q, c, name='circ')
circ.t(q[1])
circ.u3(0.1, 0.2, -0.2, q[0])
circ.barrier()
circ.measure(q[0], c[0])
circ.rz(0.8, q[0]).c_if(c, 6)
inst = circ.to_instruction()
circ = QuantumCircuit(q, c, name='circ')
circ.rz(0.8, q[0]).c_if(c, 6)
circ.measure(q[0], c[0])
circ.barrier()
circ.u3(0.1, 0.2, -0.2, q[0])
circ.t(q[1])
inst_mirror = circ.to_instruction()
self.assertEqual(inst.mirror().definition, inst_mirror.definition)
def test_disassemble_single_circuit(self):
"""Test disassembling a single circuit.
"""
qr = QuantumRegister(2, name='q')
cr = ClassicalRegister(2, name='c')
circ = QuantumCircuit(qr, cr, name='circ')
circ.h(qr[0])
circ.cx(qr[0], qr[1])
circ.measure(qr, cr)
qobj = assemble(circ, shots=2000, memory=True)
circuits, run_config_out, headers = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.n_qubits, 2)
self.assertEqual(run_config_out.memory_slots, 2)
self.assertEqual(run_config_out.shots, 2000)
self.assertEqual(run_config_out.memory, True)
self.assertEqual(len(circuits), 1)
self.assertEqual(circuits[0], circ)
self.assertEqual({}, headers)
def test_validate_nr_classical_qubits_less_than_nr_qubits_conditional_gate(
self):
api = Mock()
api.create_project.return_value = {'id': 42}
api.execute_qasm_async.return_value = 42
api.get_backend_type_by_name.return_value = {
'max_number_of_shots': 4096
}
simulator = QuantumInspireBackend(api, Mock())
q = QuantumRegister(2, "q")
c = ClassicalRegister(4, "c")
qc = QuantumCircuit(q, c, name="conditional")
qc.cx(q[0], q[1]).c_if(c, 1)
qc.measure(0, 1)
self.assertRaisesRegex(
QiskitBackendError,
'Number of classical bits must be less than or equal to the'
' number of qubits when using conditional gate operations',
simulator.run, qc)
