qiskit 2.0.3__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

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,50 @@
+# 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::
+           :alt: Circuit diagram output by the previous code.
+           :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,121 @@
+# 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 DAGCircuit, DAGOpNode
+
+
+def calc_final_ops(dag: DAGCircuit, final_op_names: set[str]) -> list[DAGOpNode]:
+    """Find the final operations of a circuit of a given type.
+    Args:
+        dag: the DAG circuit
+        final_op_names: names of the operations to find at the end of the circuit.
+
+    Returns:
+    List of nodes corresponding the the relevant operations at the end of the circuit.
+    """
+    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_names:
+            # 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
+
+
+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 run(self, dag):
+        """Run the RemoveFinalMeasurements pass on `dag`.
+
+        Args:
+            dag (DAGCircuit): the DAG to be optimized.
+
+        Returns:
+            DAGCircuit: the optimized DAG.
+        """
+        final_ops = calc_final_ops(dag, {"measure", "barrier"})
+        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