qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/transpiler/passes/utils/control_flow.py

@@ -0,0 +1,61 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2022.
+#
+# 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.
+
+"""Internal utilities for working with control-flow operations."""
+
+import functools
+from typing import Callable
+
+from qiskit.circuit import ControlFlowOp
+from qiskit.converters import circuit_to_dag, dag_to_circuit
+from qiskit.dagcircuit import DAGCircuit
+
+
+def map_blocks(dag_mapping: Callable[[DAGCircuit], DAGCircuit], op: ControlFlowOp) -> ControlFlowOp:
+    """Use the ``dag_mapping`` function to replace the blocks of a :class:`.ControlFlowOp` with new
+    ones.  Each block will be automatically converted to a :class:`.DAGCircuit` and then returned
+    to a :class:`.QuantumCircuit`."""
+    return op.replace_blocks(
+        [
+            dag_to_circuit(dag_mapping(circuit_to_dag(block)), copy_operations=False)
+            for block in op.blocks
+        ]
+    )
+
+
+def trivial_recurse(method):
+    """Decorator that causes :class:`.BasePass.run` to iterate over all control-flow nodes,
+    replacing their operations with a new :class:`.ControlFlowOp` whose blocks have all had
+    :class`.BasePass.run` called on them.
+
+    This is only suitable for simple run calls that store no state between calls, do not need
+    circuit-specific information feeding into them (such as via a :class:`.PropertySet`), and will
+    safely do nothing to control-flow operations that are in the DAG.
+
+    If slightly finer control is needed on when the control-flow operations are modified, one can
+    use :func:`map_blocks` as::
+
+        if isinstance(node.op, ControlFlowOp):
+            dag.substitute_node(node, map_blocks(self.run, node.op))
+
+    from with :meth:`.BasePass.run`."""
+
+    @functools.wraps(method)
+    def out(self, dag):
+        def bound_wrapped_method(dag):
+            return out(self, dag)
+
+        for node in dag.control_flow_op_nodes():
+            dag.substitute_node(node, map_blocks(bound_wrapped_method, node.op))
+        return method(self, dag)
+
+    return out

qiskit/transpiler/passes/utils/dag_fixed_point.py

@@ -0,0 +1,36 @@
+# 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.
+
+"""Check if the DAG has reached a fixed point."""
+
+from copy import deepcopy
+
+from qiskit.transpiler.basepasses import AnalysisPass
+
+
+class DAGFixedPoint(AnalysisPass):
+    """Check if the DAG has reached a fixed point.
+
+    A dummy analysis pass that checks if the DAG a fixed point (the DAG is not
+    modified anymore). The result is saved in
+    ``property_set['dag_fixed_point']`` as a boolean.
+    """
+
+    def run(self, dag):
+        """Run the DAGFixedPoint pass on `dag`."""
+        if self.property_set["_dag_fixed_point_previous_dag"] is None:
+            self.property_set["dag_fixed_point"] = False
+        else:
+            fixed_point_reached = self.property_set["_dag_fixed_point_previous_dag"] == dag
+            self.property_set["dag_fixed_point"] = fixed_point_reached
+
+        self.property_set["_dag_fixed_point_previous_dag"] = deepcopy(dag)

qiskit/transpiler/passes/utils/error.py

@@ -0,0 +1,69 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020.
+#
+# 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.
+
+"""Error pass to be called when an error happens."""
+
+import logging
+import string
+import warnings
+
+from qiskit.transpiler.basepasses import AnalysisPass
+from qiskit.transpiler.exceptions import TranspilerError
+
+
+class Error(AnalysisPass):
+    """Error pass to be called when an error happens."""
+
+    def __init__(self, msg=None, action="raise"):
+        """Error pass.
+
+        Args:
+            msg (str | Callable[[PropertySet], str]): Error message, if not provided a generic error
+                will be used.  This can be either a raw string, or a callback function that accepts
+                the current ``property_set`` and returns the desired message.
+            action (str): the action to perform. Default: 'raise'. The options are:
+              * ``'raise'``: Raises a ``TranspilerError`` exception with msg
+              * ``'warn'``: Raises a non-fatal warning with msg
+              * ``'log'``: logs in ``logging.getLogger(__name__)``
+
+        Raises:
+            TranspilerError: if action is not valid.
+        """
+        super().__init__()
+        self.msg = msg
+        if action in ["raise", "warn", "log"]:
+            self.action = action
+        else:
+            raise TranspilerError(f"Unknown action: {action}")
+
+    def run(self, _):
+        """Run the Error pass on `dag`."""
+        if self.msg is None:
+            msg = "An error occurred while the pass manager was running."
+        elif isinstance(self.msg, str):
+            prop_names = [
+                tup[1] for tup in string.Formatter().parse(self.msg) if tup[1] is not None
+            ]
+            properties = {prop_name: self.property_set[prop_name] for prop_name in prop_names}
+            msg = self.msg.format(**properties)
+        else:
+            msg = self.msg(self.property_set)
+
+        if self.action == "raise":
+            raise TranspilerError(msg)
+        if self.action == "warn":
+            warnings.warn(msg, Warning)
+        elif self.action == "log":
+            logger = logging.getLogger(__name__)
+            logger.info(msg)
+        else:
+            raise TranspilerError(f"Unknown action: {self.action}")

qiskit/transpiler/passes/utils/filter_op_nodes.py

@@ -0,0 +1,66 @@
+# 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.
+
+"""Filter ops from a circuit"""
+
+from typing import Callable
+
+from qiskit.dagcircuit import DAGCircuit, DAGOpNode
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.passes.utils import control_flow
+
+from qiskit._accelerate.filter_op_nodes import filter_op_nodes
+
+
+class FilterOpNodes(TransformationPass):
+    """Remove all operations that match a filter function
+
+    This transformation pass is used to remove any operations that matches a
+    the provided filter function.
+
+    Args:
+       predicate: A given callable that will be passed the :class:`.DAGOpNode`
+           for each node in the :class:`.DAGCircuit`. If the callable returns
+           ``True`` the :class:`.DAGOpNode` is retained in the circuit and if it
+           returns ``False`` it is removed from the circuit.
+
+    Example:
+
+        Filter out operations that are labeled ``"foo"``
+
+        .. plot::
+           :alt: Circuit diagram output by the previous code.
+           :include-source:
+
+            from qiskit import QuantumCircuit
+            from qiskit.transpiler.passes import FilterOpNodes
+
+            circuit = QuantumCircuit(1)
+            circuit.x(0, label='foo')
+            circuit.barrier()
+            circuit.h(0)
+
+            circuit = FilterOpNodes(
+                lambda node: getattr(node.op, "label") != "foo"
+            )(circuit)
+            circuit.draw('mpl')
+    """
+
+    def __init__(self, predicate: Callable[[DAGOpNode], bool]):
+        super().__init__()
+        self.predicate = predicate
+
+    @control_flow.trivial_recurse
+    def run(self, dag: DAGCircuit) -> DAGCircuit:
+        """Run the RemoveBarriers pass on `dag`."""
+        filter_op_nodes(dag, self.predicate)
+        return dag

qiskit/transpiler/passes/utils/fixed_point.py

@@ -0,0 +1,48 @@
+# 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 a property reached a fixed point."""
+
+from copy import deepcopy
+
+from qiskit.transpiler.basepasses import AnalysisPass
+
+
+class FixedPoint(AnalysisPass):
+    """Check if a property reached a fixed point.
+
+    A dummy analysis pass that checks if a property reached a fixed point.
+    The result is saved in ``property_set['<property>_fixed_point']``
+    as a boolean.
+    """
+
+    def __init__(self, property_to_check):
+        """FixedPoint initializer.
+
+        Args:
+            property_to_check (str): The property to check if a fixed point was reached.
+        """
+        super().__init__()
+        self._property = property_to_check
+
+    def run(self, dag):
+        """Run the FixedPoint pass on `dag`."""
+        current_value = self.property_set[self._property]
+        fixed_point_previous_property = f"_fixed_point_previous_{self._property}"
+
+        if self.property_set[fixed_point_previous_property] is None:
+            self.property_set[f"{self._property}_fixed_point"] = False
+        else:
+            fixed_point_reached = self.property_set[fixed_point_previous_property] == current_value
+            self.property_set[f"{self._property}_fixed_point"] = fixed_point_reached
+
+        self.property_set[fixed_point_previous_property] = deepcopy(current_value)

qiskit/transpiler/passes/utils/gate_direction.py

@@ -0,0 +1,93 @@
+# 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.
+        """
+        # Only use "fix_gate_direction_target" if a target exists and target.operation_names
+        # is not empty, else use "fix_gate_direction_coupling".
+        if self.target is None:
+            return fix_gate_direction_coupling(dag, set(self.coupling_map.get_edges()))
+        elif len(self.target.operation_names) == 0:
+            # A  _FakeTarget path, no basis gates, just use the coupling map
+            return fix_gate_direction_coupling(
+                dag, set(self.target.build_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