qiskit 1.3.0b1__cp39-abi3-macosx_10_9_x86_64.whl

qiskit/transpiler/passes/utils/__init__.py

@@ -0,0 +1,33 @@
+# 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.
+
+"""Utility passes and functions used for other main passes."""
+
+from .check_map import CheckMap
+from .check_gate_direction import CheckGateDirection
+from .gate_direction import GateDirection
+from .barrier_before_final_measurements import BarrierBeforeFinalMeasurements
+from .remove_final_measurements import RemoveFinalMeasurements
+from .merge_adjacent_barriers import MergeAdjacentBarriers
+from .dag_fixed_point import DAGFixedPoint
+from .fixed_point import FixedPoint
+from .error import Error
+from .remove_barriers import RemoveBarriers
+from .contains_instruction import ContainsInstruction
+from .gates_basis import GatesInBasis
+from .convert_conditions_to_if_ops import ConvertConditionsToIfOps
+from .unroll_forloops import UnrollForLoops
+from .minimum_point import MinimumPoint
+from .filter_op_nodes import FilterOpNodes
+
+# Utility functions
+from . import control_flow

qiskit/transpiler/passes/utils/barrier_before_final_measurements.py

@@ -0,0 +1,95 @@
+# 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.
+
+
+"""Add a barrier before final measurements."""
+
+from qiskit.circuit.barrier import Barrier
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.dagcircuit import DAGCircuit, DAGOpNode
+from .merge_adjacent_barriers import MergeAdjacentBarriers
+
+
+class BarrierBeforeFinalMeasurements(TransformationPass):
+    """Add a barrier before final measurements.
+
+    This pass adds a barrier before the set of final measurements. Measurements
+    are considered final if they are followed by no other operations (aside from
+    other measurements or barriers.)
+    """
+
+    def __init__(self, label=None):
+        super().__init__()
+        self.label = label
+
+    def run(self, dag):
+        """Run the BarrierBeforeFinalMeasurements pass on `dag`."""
+        # Collect DAG nodes which are followed only by barriers or other measures.
+        final_op_types = ["measure", "barrier"]
+        final_ops = []
+        for candidate_node in dag.named_nodes(*final_op_types):
+            is_final_op = True
+
+            for _, child_successors in dag.bfs_successors(candidate_node):
+
+                if any(
+                    isinstance(suc, DAGOpNode) and suc.name not in final_op_types
+                    for suc in child_successors
+                ):
+                    is_final_op = False
+                    break
+
+            if is_final_op:
+                final_ops.append(candidate_node)
+
+        if not final_ops:
+            return dag
+
+        # Create a layer with the barrier and add both bits and registers from the original dag.
+        barrier_layer = DAGCircuit()
+        barrier_layer.add_qubits(dag.qubits)
+        for qreg in dag.qregs.values():
+            barrier_layer.add_qreg(qreg)
+        barrier_layer.add_clbits(dag.clbits)
+        for creg in dag.cregs.values():
+            barrier_layer.add_creg(creg)
+
+        # Add a barrier across all qubits so swap mapper doesn't add a swap
+        # from an unmeasured qubit after a measure.
+        final_qubits = dag.qubits
+
+        barrier_layer.apply_operation_back(
+            Barrier(len(final_qubits), label=self.label), final_qubits, (), check=False
+        )
+
+        # Preserve order of final ops collected earlier from the original DAG.
+        ordered_final_nodes = [
+            node for node in dag.topological_op_nodes() if node in set(final_ops)
+        ]
+
+        # Move final ops to the new layer and append the new layer to the DAG.
+        for final_node in ordered_final_nodes:
+            barrier_layer.apply_operation_back(
+                final_node.op, final_node.qargs, final_node.cargs, check=False
+            )
+
+        for final_op in final_ops:
+            dag.remove_op_node(final_op)
+
+        dag.compose(barrier_layer)
+
+        if self.label is None:
+            # Merge the new barrier into any other barriers
+            adjacent_pass = MergeAdjacentBarriers()
+            return adjacent_pass.run(dag)
+        else:
+            return dag

qiskit/transpiler/passes/utils/check_gate_direction.py

@@ -0,0 +1,52 @@
+# 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 the gates follow the right direction with respect to the coupling map."""
+
+from qiskit.transpiler.basepasses import AnalysisPass
+from qiskit._accelerate.gate_direction import (
+    check_gate_direction_coupling,
+    check_gate_direction_target,
+)
+
+
+class CheckGateDirection(AnalysisPass):
+    """Check if the two-qubit gates follow the right direction with
+    respect to the coupling map.
+    """
+
+    def __init__(self, coupling_map, target=None):
+        """CheckGateDirection initializer.
+
+        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 CheckGateDirection pass on `dag`.
+
+        If `dag` is mapped and the direction is correct the property
+        `is_direction_mapped` is set to True (or to False otherwise).
+
+        Args:
+            dag (DAGCircuit): DAG to check.
+        """
+        self.property_set["is_direction_mapped"] = (
+            check_gate_direction_target(dag, self.target)
+            if self.target
+            else check_gate_direction_coupling(dag, set(self.coupling_map.get_edges()))
+        )

qiskit/transpiler/passes/utils/check_map.py

@@ -0,0 +1,78 @@
+# 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 DAG circuit is already mapped to a coupling map."""
+
+from qiskit.transpiler.basepasses import AnalysisPass
+from qiskit.transpiler.target import Target
+
+from qiskit._accelerate import check_map
+
+
+class CheckMap(AnalysisPass):
+    """Check if a DAG circuit is already mapped to a coupling map.
+
+    Check if a DAGCircuit is mapped to ``coupling_map`` by checking that all
+    2-qubit interactions are laid out to be on adjacent qubits in the global coupling
+    map of the device, setting the property set field (either specified with ``property_set_field``
+    or the default ``is_swap_mapped``) to ``True`` or ``False`` accordingly. Note this does not
+    validate directionality of the connectivity between  qubits. If you need to check gates are
+    implemented in a native direction for a target use the :class:`~.CheckGateDirection` pass
+    instead.
+    """
+
+    def __init__(self, coupling_map, property_set_field=None):
+        """CheckMap initializer.
+
+        Args:
+            coupling_map (Union[CouplingMap, Target]): Directed graph representing a coupling map.
+            property_set_field (str): An optional string to specify the property set field to
+                store the result of the check. If not default the result is stored in
+                ``"is_swap_mapped"``.
+        """
+        super().__init__()
+        if property_set_field is None:
+            self.property_set_field = "is_swap_mapped"
+        else:
+            self.property_set_field = property_set_field
+        if isinstance(coupling_map, Target):
+            cmap = coupling_map.build_coupling_map()
+        else:
+            cmap = coupling_map
+        if cmap is None:
+            self.qargs = None
+        else:
+            self.qargs = set()
+            for edge in cmap.get_edges():
+                self.qargs.add(edge)
+                self.qargs.add((edge[1], edge[0]))
+
+    def run(self, dag):
+        """Run the CheckMap pass on `dag`.
+
+        If `dag` is mapped to `coupling_map`, the property
+        `is_swap_mapped` is set to True (or to False otherwise).
+
+        Args:
+            dag (DAGCircuit): DAG to map.
+        """
+        if not self.qargs:
+            self.property_set[self.property_set_field] = True
+            return
+        res = check_map.check_map(dag, self.qargs)
+        if res is None:
+            self.property_set[self.property_set_field] = True
+            return
+        self.property_set[self.property_set_field] = False
+        self.property_set["check_map_msg"] = (
+            f"{res[0]}({dag.qubits[res[1][0]]}, {dag.qubits[res[1][1]]}) failed"
+        )

qiskit/transpiler/passes/utils/contains_instruction.py

@@ -0,0 +1,45 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+
+"""Check if a property reached a fixed point."""
+
+from qiskit.transpiler.basepasses import AnalysisPass
+
+
+class ContainsInstruction(AnalysisPass):
+    """An analysis pass to detect if the DAG contains a specific instruction.
+
+    This pass takes in a single instruction name for example ``'delay'`` and
+    will set the property set ``contains_delay`` to ``True`` if the DAG contains
+    that instruction and ``False`` if it does not.
+    """
+
+    def __init__(self, instruction_name, recurse: bool = True):
+        """ContainsInstruction initializer.
+
+        Args:
+            instruction_name (str | Iterable[str]): The instruction or instructions to check are in
+                the DAG. The output in the property set is set to ``contains_`` prefixed on each
+                value for this parameter.
+            recurse (bool): if ``True`` (default), then recurse into control-flow operations.
+        """
+        super().__init__()
+        self._instruction_names = (
+            {instruction_name} if isinstance(instruction_name, str) else set(instruction_name)
+        )
+        self._recurse = recurse
+
+    def run(self, dag):
+        """Run the ContainsInstruction pass on dag."""
+        names = dag.count_ops(recurse=self._recurse)
+        for name in self._instruction_names:
+            self.property_set[f"contains_{name}"] = name in names

qiskit/transpiler/passes/utils/control_flow.py

@@ -0,0 +1,65 @@
+# 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)
+
+        control_flow_nodes = dag.control_flow_op_nodes()
+        if control_flow_nodes is not None:
+            for node in control_flow_nodes:
+                dag.substitute_node(
+                    node, map_blocks(bound_wrapped_method, node.op), propagate_condition=False
+                )
+        return method(self, dag)
+
+    return out

qiskit/transpiler/passes/utils/convert_conditions_to_if_ops.py

@@ -0,0 +1,88 @@
+# 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.
+
+"""Replace conditional instructions with equivalent :class:`.IfElseOp` objects."""
+
+from qiskit.converters import dag_to_circuit, circuit_to_dag
+from qiskit.circuit import (
+    CircuitInstruction,
+    ClassicalRegister,
+    Clbit,
+    IfElseOp,
+    QuantumCircuit,
+)
+from qiskit.dagcircuit import DAGCircuit
+from qiskit.transpiler.basepasses import TransformationPass
+
+
+class ConvertConditionsToIfOps(TransformationPass):
+    """Convert instructions whose ``condition`` attribute is set to a non-``None`` value into the
+    equivalent single-statement :class:`.IfElseBlock`.
+
+    This is a simple pass aimed at easing the conversion from the old style of using
+    :meth:`.InstructionSet.c_if` into the new style of using more complex conditional logic."""
+
+    def _run_inner(self, dag):
+        """Run the pass on one :class:`.DAGCircuit`, mutating it.  Returns ``True`` if the circuit
+        was modified and ``False`` if not."""
+        modified = False
+        for node in dag.op_nodes():
+            if node.is_control_flow():
+                modified_blocks = False
+                new_dags = []
+                for block in node.op.blocks:
+                    new_dag = circuit_to_dag(block)
+                    modified_blocks |= self._run_inner(new_dag)
+                    new_dags.append(new_dag)
+                if not modified_blocks:
+                    continue
+                dag.substitute_node(
+                    node,
+                    node.op.replace_blocks(dag_to_circuit(block) for block in new_dags),
+                    inplace=True,
+                )
+            elif node.condition is None:
+                continue
+            else:
+                target, value = node.op.condition
+                clbits = list(node.cargs)
+                condition_clbits = [target] if isinstance(target, Clbit) else list(target)
+                clbits_set = set(clbits)
+                clbits += [bit for bit in condition_clbits if bit not in clbits_set]
+                block_body = QuantumCircuit(list(node.qargs) + clbits)
+                if isinstance(target, ClassicalRegister):
+                    block_body.add_register(target)
+                new_op = node.op.copy()
+                new_op.condition = None
+                block_body._append(CircuitInstruction(new_op, node.qargs, node.cargs))
+                # Despite only being a node-for-node replacement, control-flow ops contain the
+                # condition bits in their cargs, which requires slightly different handling in the
+                # DAGCircuit methods right now.
+                replacement = DAGCircuit()
+                replacement.add_qubits(block_body.qubits)
+                replacement.add_clbits(block_body.clbits)
+                if isinstance(target, ClassicalRegister):
+                    replacement.add_creg(target)
+                replacement.apply_operation_back(
+                    IfElseOp((target, value), block_body),
+                    block_body.qubits,
+                    block_body.clbits,
+                    check=False,
+                )
+                wire_map = {bit: bit for bit in block_body.qubits + block_body.clbits}
+                dag.substitute_node_with_dag(node, replacement, wire_map, propagate_condition=False)
+            modified = True
+        return modified
+
+    def run(self, dag):
+        self._run_inner(dag)
+        return dag

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,65 @@
+# 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 labelled ``"foo"``
+
+        .. plot::
+           :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)