qiskit 1.3.0__cp39-abi3-win32.whl

qiskit/transpiler/passes/utils/gate_direction.py

@@ -0,0 +1,86 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Rearrange the direction of the 2-qubit gate nodes to match the directed coupling map."""
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit._accelerate.gate_direction import fix_gate_direction_coupling, fix_gate_direction_target
+
+
+class GateDirection(TransformationPass):
+    """Modify asymmetric gates to match the hardware coupling direction.
+
+    This pass supports replacements for the `cx`, `cz`, `ecr`, `swap`, `rzx`, `rxx`, `ryy` and
+    `rzz` gates, using the following identities::
+
+                             ┌───┐┌───┐┌───┐
+        q_0: ──■──      q_0: ┤ H ├┤ X ├┤ H ├
+             ┌─┴─┐  =        ├───┤└─┬─┘├───┤
+        q_1: ┤ X ├      q_1: ┤ H ├──■──┤ H ├
+             └───┘           └───┘     └───┘
+
+
+                          global phase: 3π/2
+             ┌──────┐           ┌───┐ ┌────┐┌─────┐┌──────┐┌───┐
+        q_0: ┤0     ├     q_0: ─┤ S ├─┤ √X ├┤ Sdg ├┤1     ├┤ H ├
+             │  ECR │  =       ┌┴───┴┐├────┤└┬───┬┘│  Ecr │├───┤
+        q_1: ┤1     ├     q_1: ┤ Sdg ├┤ √X ├─┤ S ├─┤0     ├┤ H ├
+             └──────┘          └─────┘└────┘ └───┘ └──────┘└───┘
+        Note: This is done in terms of less-efficient S/SX/Sdg gates instead of the more natural
+        `RY(pi /2)` so we have a chance for basis translation to keep things in a discrete basis
+        during resynthesis, if that's what's being asked for.
+
+
+             ┌──────┐          ┌───┐┌──────┐┌───┐
+        q_0: ┤0     ├     q_0: ┤ H ├┤1     ├┤ H ├
+             │  RZX │  =       ├───┤│  RZX │├───┤
+        q_1: ┤1     ├     q_1: ┤ H ├┤0     ├┤ H ├
+             └──────┘          └───┘└──────┘└───┘
+
+        cz, swap, rxx, ryy and rzz directions are fixed by reversing their qargs order.
+
+    This pass assumes that the positions of the qubits in the :attr:`.DAGCircuit.qubits` attribute
+    are the physical qubit indices. For example if ``dag.qubits[0]`` is qubit 0 in the
+    :class:`.CouplingMap` or :class:`.Target`.
+    """
+
+    def __init__(self, coupling_map, target=None):
+        """GateDirection pass.
+
+        Args:
+            coupling_map (CouplingMap): Directed graph representing a coupling map.
+            target (Target): The backend target to use for this pass. If this is specified
+                it will be used instead of the coupling map
+        """
+        super().__init__()
+        self.coupling_map = coupling_map
+        self.target = target
+
+    def run(self, dag):
+        """Run the GateDirection pass on `dag`.
+
+        Flips the cx nodes to match the directed coupling map. Modifies the
+        input dag.
+
+        Args:
+            dag (DAGCircuit): DAG to map.
+
+        Returns:
+            DAGCircuit: The rearranged dag for the coupling map
+
+        Raises:
+            TranspilerError: If the circuit cannot be mapped just by flipping the
+                cx nodes.
+        """
+        if self.target is None:
+            return fix_gate_direction_coupling(dag, set(self.coupling_map.get_edges()))
+        return fix_gate_direction_target(dag, self.target)

qiskit/transpiler/passes/utils/gates_basis.py

@@ -0,0 +1,51 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2018.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Check if all gates in the DAGCircuit are in the specified basis gates."""
+
+from qiskit.transpiler.basepasses import AnalysisPass
+
+from qiskit._accelerate.gates_in_basis import (
+    any_gate_missing_from_basis,
+    any_gate_missing_from_target,
+)
+
+
+class GatesInBasis(AnalysisPass):
+    """Check if all gates in a DAG are in a given set of gates"""
+
+    def __init__(self, basis_gates=None, target=None):
+        """Initialize the GatesInBasis pass.
+
+        Args:
+            basis_gates (list): The list of strings representing the set of basis gates.
+            target (Target): The target representing the backend. If specified
+                this will be used instead of the ``basis_gates`` parameter
+        """
+        super().__init__()
+        self._basis_gates = None
+        if basis_gates is not None:
+            self._basis_gates = set(basis_gates).union(
+                {"measure", "reset", "barrier", "snapshot", "delay", "store"}
+            )
+        self._target = target
+
+    def run(self, dag):
+        """Run the GatesInBasis pass on `dag`."""
+        if self._basis_gates is None and self._target is None:
+            self.property_set["all_gates_in_basis"] = True
+            return
+        if self._target is not None:
+            gates_out_of_basis = any_gate_missing_from_target(dag, self._target)
+        else:
+            gates_out_of_basis = any_gate_missing_from_basis(dag, self._basis_gates)
+        self.property_set["all_gates_in_basis"] = not gates_out_of_basis

qiskit/transpiler/passes/utils/merge_adjacent_barriers.py

@@ -0,0 +1,163 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Return a circuit with any adjacent barriers merged together."""
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.circuit.barrier import Barrier
+
+
+class MergeAdjacentBarriers(TransformationPass):
+    """Return a circuit with any adjacent barriers merged together.
+
+    Only barriers which can be merged without affecting the barrier structure
+    of the DAG will be merged.
+
+    Not all redundant barriers will necessarily be merged, only adjacent
+    barriers are merged.
+
+    For example, the circuit::
+
+        qr = QuantumRegister(3, 'q')
+        circuit = QuantumCircuit(qr)
+        circuit.barrier(qr[0])
+        circuit.barrier(qr[1])
+        circuit.barrier(qr)
+
+    Will be transformed into a circuit corresponding to::
+
+        circuit.barrier(qr[0])
+        circuit.barrier(qr)
+
+    i.e,
+
+    .. code-block:: text
+
+              ░  ░             ░  ░
+        q_0: ─░──░─      q_0: ─░──░─
+              ░  ░             ░  ░
+        q_1: ─░──░─  =>  q_1: ────░─
+              ░  ░                ░
+        q_2: ────░─      q_2: ────░─
+                 ░
+
+    after one iteration of the pass. These two barriers were not merged by the
+    first pass as they are not adjacent in the initial circuit.
+
+    The pass then can be reapplied to merge the newly adjacent barriers.
+    """
+
+    def run(self, dag):
+        """Run the MergeAdjacentBarriers pass on `dag`."""
+        indices = {qubit: index for index, qubit in enumerate(dag.qubits)}
+
+        # sorted to so that they are in the order they appear in the DAG
+        # so ancestors/descendants makes sense
+        barriers = [nd for nd in dag.topological_op_nodes() if nd.name == "barrier"]
+
+        # get dict of barrier merges
+        node_to_barrier_qubits = MergeAdjacentBarriers._collect_potential_merges(dag, barriers)
+
+        if not node_to_barrier_qubits:
+            return dag
+
+        for barrier in barriers:
+            if barrier in node_to_barrier_qubits:
+                barrier_to_add, nodes = node_to_barrier_qubits[barrier]
+                dag.replace_block_with_op(
+                    nodes, barrier_to_add, wire_pos_map=indices, cycle_check=False
+                )
+
+        return dag
+
+    @staticmethod
+    def _collect_potential_merges(dag, barriers):
+        """Return the potential merges.
+
+        Returns a dict of DAGOpNode: (Barrier, [DAGOpNode]) objects, where the barrier needs to be
+        inserted where the corresponding index DAGOpNode appears in the main DAG, in replacement of
+        the listed DAGOpNodes.
+        """
+        # if only got 1 or 0 barriers then can't merge
+        if len(barriers) < 2:
+            return None
+
+        # mapping from the node that will be the main barrier to the
+        # barrier object that gets built up
+        node_to_barrier_qubits = {}
+
+        # Start from the first barrier
+        current_barrier = barriers[0]
+        end_of_barrier = current_barrier
+        current_barrier_nodes = [current_barrier]
+
+        current_qubits = set(current_barrier.qargs)
+        current_ancestors = dag.ancestors(current_barrier)
+        current_descendants = dag.descendants(current_barrier)
+
+        barrier_to_add = Barrier(len(current_qubits))
+
+        for next_barrier in barriers[1:]:
+
+            # Ensure barriers are adjacent before checking if they are mergeable.
+            if dag._has_edge(end_of_barrier._node_id, next_barrier._node_id):
+
+                # Remove all barriers that have already been included in this new barrier from the
+                # set of ancestors/descendants as they will be removed from the new DAG when it is
+                # created.
+                next_ancestors = {
+                    nd for nd in dag.ancestors(next_barrier) if nd not in current_barrier_nodes
+                }
+                next_descendants = {
+                    nd for nd in dag.descendants(next_barrier) if nd not in current_barrier_nodes
+                }
+                next_qubits = set(next_barrier.qargs)
+
+                if (
+                    not current_qubits.isdisjoint(next_qubits)
+                    and current_ancestors.isdisjoint(next_descendants)
+                    and current_descendants.isdisjoint(next_ancestors)
+                ):
+
+                    # can be merged
+                    current_ancestors = current_ancestors | next_ancestors
+                    current_descendants = current_descendants | next_descendants
+                    current_qubits = current_qubits | next_qubits
+
+                    # update the barrier that will be added back to include this barrier
+                    barrier_to_add = Barrier(len(current_qubits))
+
+                    end_of_barrier = next_barrier
+                    current_barrier_nodes.append(end_of_barrier)
+                    continue
+
+            # Fallback if barriers are not adjacent or not mergeable.
+
+            # store the previously made barrier
+            if barrier_to_add:
+                node_to_barrier_qubits[end_of_barrier] = (barrier_to_add, current_barrier_nodes)
+
+            # reset the properties
+            current_qubits = set(next_barrier.qargs)
+            current_ancestors = dag.ancestors(next_barrier)
+            current_descendants = dag.descendants(next_barrier)
+
+            barrier_to_add = Barrier(len(current_qubits))
+            current_barrier_nodes = []
+
+            end_of_barrier = next_barrier
+            current_barrier_nodes.append(end_of_barrier)
+
+        if barrier_to_add:
+            node_to_barrier_qubits[end_of_barrier] = (barrier_to_add, current_barrier_nodes)
+
+        return node_to_barrier_qubits

qiskit/transpiler/passes/utils/minimum_point.py

@@ -0,0 +1,118 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2023
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Check if the DAG has reached a relative semi-stable point over previous runs."""
+
+from copy import deepcopy
+from dataclasses import dataclass
+import math
+from typing import Tuple
+
+from qiskit.dagcircuit.dagcircuit import DAGCircuit
+from qiskit.transpiler.basepasses import TransformationPass
+
+
+class MinimumPoint(TransformationPass):
+    """Check if the DAG has reached a relative semi-stable point over previous runs
+
+    This pass is similar to the :class:`~.FixedPoint` transpiler pass and is intended
+    primarily to be used to set a loop break condition in the property set.
+    However, unlike the :class:`~.FixedPoint` class which only sets the
+    condition if 2 consecutive runs have the same value property set value
+    this pass is designed to find a local minimum and use that instead. This
+    pass is designed for an optimization loop where a fixed point may never
+    get reached (for example if synthesis is used and there are multiple
+    equivalent outputs for some cases).
+
+    This pass will track the state of fields in the property set over its past
+    executions and set a boolean field when either a fixed point is reached
+    over the backtracking depth or selecting the minimum value found if the
+    backtracking depth is reached. To do this it stores a deep copy of the
+    current minimum DAG in the property set and when ``backtrack_depth`` number
+    of executions is reached since the last minimum the output dag is set to
+    that copy of the earlier minimum.
+
+    Fields used by this pass in the property set are (all relative to the ``prefix``
+    argument):
+
+    * ``{prefix}_minimum_point_state`` - Used to track the state of the minimum point search
+    * ``{prefix}_minimum_point`` - This value gets set to ``True`` when either a fixed point
+        is reached over the ``backtrack_depth`` executions, or ``backtrack_depth`` was exceeded
+        and an earlier minimum is restored.
+    """
+
+    def __init__(self, property_set_list, prefix, backtrack_depth=5):
+        """Initialize an instance of this pass
+
+        Args:
+            property_set_list (list): A list of property set keys that will
+                be used to evaluate the local minimum. The values of these
+                property set keys will be used as a tuple for comparison
+            prefix (str): The prefix to use for the property set key that is used
+                for tracking previous evaluations
+            backtrack_depth (int): The maximum number of entries to store. If
+                this number is reached and the next iteration doesn't have
+                a decrease in the number of values the minimum of the previous
+                n will be set as the output dag and ``minimum_point`` will be set to
+                ``True`` in the property set
+        """
+        super().__init__()
+        self.property_set_list = property_set_list
+
+        self.backtrack_name = f"{prefix}_minimum_point_state"
+        self.minimum_reached = f"{prefix}_minimum_point"
+        self.backtrack_depth = backtrack_depth
+
+    def run(self, dag):
+        """Run the MinimumPoint pass on `dag`."""
+        score = tuple(self.property_set[x] for x in self.property_set_list)
+        state = self.property_set[self.backtrack_name]
+
+        # The pass starts at None and the first iteration doesn't set a real
+        # score so the overall loop is treated as a do-while to ensure we have
+        # at least 2 iterations.
+        if state is None:
+            self.property_set[self.backtrack_name] = _MinimumPointState(
+                dag=None, score=(math.inf,) * len(self.property_set_list), since=0
+            )
+        # If the score of this execution is worse than the previous execution
+        # increment 'since' since we have not found a new minimum point
+        elif score > state.score:
+            state.since += 1
+            if state.since == self.backtrack_depth:
+                self.property_set[self.minimum_reached] = True
+                return self.property_set[self.backtrack_name].dag
+        # If the score has decreased (gotten better) then this iteration is
+        # better performing and this iteration should be the new minimum state.
+        # So update the state to be this iteration and reset counter
+        elif score < state.score:
+            state.since = 1
+            state.score = score
+            state.dag = deepcopy(dag)
+        # If the current execution is equal to the previous minimum value then
+        # we've reached an equivalent fixed point and we should use this iteration's
+        # dag as the output and set the property set flag that we've found a minimum
+        # point.
+        elif score == state.score:
+            self.property_set[self.minimum_reached] = True
+            return dag
+
+        return dag
+
+
+@dataclass
+class _MinimumPointState:
+    __slots__ = ("dag", "score", "since")
+
+    dag: DAGCircuit
+    score: Tuple[float, ...]
+    since: int

qiskit/transpiler/passes/utils/remove_barriers.py

@@ -0,0 +1,49 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Remove all barriers in a circuit"""
+
+from qiskit.dagcircuit import DAGCircuit
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.passes.utils import control_flow
+
+
+class RemoveBarriers(TransformationPass):
+    """Return a circuit with any barrier removed.
+
+    This transformation is not semantics preserving.
+
+    Example:
+
+        .. plot::
+           :include-source:
+
+            from qiskit import QuantumCircuit
+            from qiskit.transpiler.passes import RemoveBarriers
+
+            circuit = QuantumCircuit(1)
+            circuit.x(0)
+            circuit.barrier()
+            circuit.h(0)
+
+            circuit = RemoveBarriers()(circuit)
+            circuit.draw('mpl')
+
+    """
+
+    @control_flow.trivial_recurse
+    def run(self, dag: DAGCircuit) -> DAGCircuit:
+        """Run the RemoveBarriers pass on `dag`."""
+
+        dag.remove_all_ops_named("barrier")
+
+        return dag

qiskit/transpiler/passes/utils/remove_final_measurements.py

@@ -0,0 +1,114 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Remove final measurements and barriers at the end of a circuit."""
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.dagcircuit import DAGOpNode
+
+
+class RemoveFinalMeasurements(TransformationPass):
+    """Remove final measurements and barriers at the end of a circuit.
+
+    This pass removes final barriers and final measurements, as well as all
+    unused classical registers and bits they are connected to.
+    Measurements and barriers are considered final if they are
+    followed by no other operations (aside from other measurements or barriers.)
+
+    Classical registers are removed iff they reference at least one bit
+    that has become unused by the circuit as a result of the operation, and all
+    of their other bits are also unused. Separately, classical bits are removed
+    iff they have become unused by the circuit as a result of the operation,
+    or they appear in a removed classical register, but do not appear
+    in a classical register that will remain.
+    """
+
+    def _calc_final_ops(self, dag):
+        final_op_types = {"measure", "barrier"}
+        final_ops = []
+
+        to_visit = [next(dag.predecessors(dag.output_map[qubit])) for qubit in dag.qubits]
+        barrier_encounters_remaining = {}
+
+        while to_visit:
+            node = to_visit.pop()
+            if not isinstance(node, DAGOpNode):
+                continue
+            if node.op.name == "barrier":
+                # Barrier is final if all children are final, so we track
+                # how many times we still need to encounter each barrier
+                # via a child node.
+                if node not in barrier_encounters_remaining:
+                    barrier_encounters_remaining[node] = sum(
+                        1 for _ in dag.quantum_successors(node)
+                    )
+                if barrier_encounters_remaining[node] - 1 > 0:
+                    # We've encountered the barrier, but not (yet) via all children.
+                    # Record the encounter, and bail!
+                    barrier_encounters_remaining[node] -= 1
+                    continue
+            if node.name in final_op_types:
+                # Current node is either a measure, or a barrier with all final op children.
+                final_ops.append(node)
+                to_visit.extend(dag.quantum_predecessors(node))
+
+        return final_ops
+
+    def run(self, dag):
+        """Run the RemoveFinalMeasurements pass on `dag`.
+
+        Args:
+            dag (DAGCircuit): the DAG to be optimized.
+
+        Returns:
+            DAGCircuit: the optimized DAG.
+        """
+        final_ops = self._calc_final_ops(dag)
+        if not final_ops:
+            return dag
+
+        # remove final measure and barrier operations from DAG, keeping track
+        # of their clbits
+        clbits_with_final_measures = set()
+        for node in final_ops:
+            for carg in node.cargs:
+                clbits_with_final_measures.add(carg)
+            dag.remove_op_node(node)
+
+        # ignore any non-idle clbits now that all final op nodes are removed
+        idle_wires = set(dag.idle_wires())
+        clbits_with_final_measures &= idle_wires
+
+        if not clbits_with_final_measures:
+            # no idle wires to remove
+            return dag
+
+        # determine bits of all registers where register is now idle
+        # as a result of the removal.
+        idle_register_bits = set()
+        busy_register_bits = set()
+        for creg in dag.cregs.values():
+            clbits = set(creg)
+            if not clbits.isdisjoint(clbits_with_final_measures) and clbits.issubset(idle_wires):
+                # register contains a newly idle bit, and all other bits are idle.
+                idle_register_bits |= clbits
+            else:
+                # register does not contain a newly idle bit, or contains other busy bits
+                # and thus should not be removed.
+                busy_register_bits |= clbits
+
+        # note: `clbits_with_final_measure` is needed here to account for loose
+        # bits not in any register.
+        bits_to_remove = (clbits_with_final_measures | idle_register_bits) - busy_register_bits
+
+        dag.remove_clbits(*bits_to_remove)
+        return dag

qiskit/transpiler/passes/utils/unroll_forloops.py

@@ -0,0 +1,81 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2023.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+""" UnrollForLoops transpilation pass """
+
+from qiskit.circuit import ForLoopOp, ContinueLoopOp, BreakLoopOp, IfElseOp
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.passes.utils import control_flow
+from qiskit.converters import circuit_to_dag
+
+
+class UnrollForLoops(TransformationPass):
+    """``UnrollForLoops`` transpilation pass unrolls for-loops when possible."""
+
+    def __init__(self, max_target_depth=-1):
+        """Things like ``for x in {0, 3, 4} {rx(x) qr[1];}`` will turn into
+        ``rx(0) qr[1]; rx(3) qr[1]; rx(4) qr[1];``.
+
+        .. note::
+            The ``UnrollForLoops`` unrolls only one level of block depth. No inner loop will
+            be considered by ``max_target_depth``.
+
+        Args:
+            max_target_depth (int): Optional. Checks if the unrolled block is over a particular
+                subcircuit depth. To disable the check, use ``-1`` (Default).
+        """
+        super().__init__()
+        self.max_target_depth = max_target_depth
+
+    @control_flow.trivial_recurse
+    def run(self, dag):
+        """Run the UnrollForLoops pass on ``dag``.
+
+        Args:
+            dag (DAGCircuit): the directed acyclic graph to run on.
+
+        Returns:
+            DAGCircuit: Transformed DAG.
+        """
+        for forloop_op in dag.op_nodes(ForLoopOp):
+            (indexset, loop_param, body) = forloop_op.op.params
+
+            # skip unrolling if it results in bigger than max_target_depth
+            if 0 < self.max_target_depth < len(indexset) * body.depth():
+                continue
+
+            # skip unroll when break_loop or continue_loop inside body
+            if _body_contains_continue_or_break(body):
+                continue
+
+            unrolled_dag = circuit_to_dag(body).copy_empty_like()
+            for index_value in indexset:
+                bound_body = (
+                    body.assign_parameters({loop_param: index_value}) if loop_param else body
+                )
+                unrolled_dag.compose(circuit_to_dag(bound_body), inplace=True)
+            dag.substitute_node_with_dag(forloop_op, unrolled_dag)
+
+        return dag
+
+
+def _body_contains_continue_or_break(circuit):
+    """Checks if a circuit contains ``continue``s or ``break``s. Conditional bodies are inspected."""
+    for inst in circuit.data:
+        operation = inst.operation
+        if isinstance(operation, (ContinueLoopOp, BreakLoopOp)):
+            return True
+        if isinstance(operation, IfElseOp):
+            for block in operation.params:
+                if _body_contains_continue_or_break(block):
+                    return True
+    return False