Add ElidePermutations transpiler pass

qiskit/transpiler/passes/__init__.py

@@ -87,8 +87,10 @@
    EchoRZXWeylDecomposition
    ResetAfterMeasureSimplification
    OptimizeCliffords
+   ElidePermutations
    NormalizeRXAngle
    OptimizeAnnotated
+   FinalizeLayouts
 
 Calibration
 =============
@@ -236,8 +238,10 @@
 from .optimization import CollectCliffords
 from .optimization import ResetAfterMeasureSimplification
 from .optimization import OptimizeCliffords
+from .optimization import ElidePermutations
 from .optimization import NormalizeRXAngle
 from .optimization import OptimizeAnnotated
+from .optimization import FinalizeLayouts
 
 # circuit analysis
 from .analysis import ResourceEstimation

qiskit/transpiler/passes/layout/apply_layout.py

@@ -56,7 +56,6 @@ def run(self, dag):
             raise TranspilerError("The 'layout' must be full (with ancilla).")
 
         post_layout = self.property_set["post_layout"]
-
         q = QuantumRegister(len(layout), "q")
 
         new_dag = DAGCircuit()

qiskit/transpiler/passes/layout/set_layout.py

@@ -63,7 +63,7 @@ def run(self, dag):
             layout = None
         else:
             raise InvalidLayoutError(
-                f"SetLayout was intialized with the layout type: {type(self.layout)}"
+                f"SetLayout was initialized with the layout type: {type(self.layout)}"
             )
         self.property_set["layout"] = layout
         return dag

qiskit/transpiler/passes/optimization/__init__.py

@@ -35,5 +35,7 @@
 from .reset_after_measure_simplification import ResetAfterMeasureSimplification
 from .optimize_cliffords import OptimizeCliffords
 from .collect_cliffords import CollectCliffords
+from .elide_permutations import ElidePermutations
 from .normalize_rx_angle import NormalizeRXAngle
 from .optimize_annotated import OptimizeAnnotated
+from .finalize_layouts import FinalizeLayouts

qiskit/transpiler/passes/optimization/elide_permutations.py

@@ -0,0 +1,106 @@
+# 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.
+
+
+"""Remove any swap gates in the circuit by pushing it through into a qubit permutation."""
+
+import logging
+
+from qiskit.circuit.library.standard_gates import SwapGate
+from qiskit.circuit.library.generalized_gates import PermutationGate
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.layout import Layout
+
+logger = logging.getLogger(__name__)
+
+
+class ElidePermutations(TransformationPass):
+    r"""Remove permutation operations from a pre-layout circuit
+
+    This pass is intended to be run before a layout (mapping virtual qubits
+    to physical qubits) is set during the transpilation pipeline. This
+    pass iterates over the :class:`~.DAGCircuit` and when a :class:`~.SwapGate`
+    or :class:`~.PermutationGate` are encountered it permutes the virtual qubits in
+    the circuit and removes the swap gate. This will effectively remove any
+    :class:`~SwapGate`\s or :class:`~PermutationGate` in the circuit prior to running
+    layout. If this pass is run after a layout has been set it will become a no-op
+    (and log a warning) as this optimization is not sound after physical qubits are
+    selected and there are connectivity constraints to adhere to.
+
+    For tracking purposes this pass sets 3 values in the property set if there
+    are any :class:`~.SwapGate` or :class:`~.PermutationGate` objects in the circuit
+    and the pass isn't a no-op.
+
+    * ``original_layout``: The trivial :class:`~.Layout` for the input to this pass being run
+    * ``original_qubit_indices``: The mapping of qubit objects to positional indices for the state
+        of the circuit as input to this pass.
+    * ``virtual_permutation_layout``: A :class:`~.Layout` object mapping input qubits to the output
+        state after eliding permutations.
+
+    These three properties are needed for the transpiler to track the permutations in the out
+    :attr:`.QuantumCircuit.layout` attribute. The elision of permutations is equivalent to a
+    ``final_layout`` set by routing and all three of these attributes are needed in the case
+    """
+
+    def run(self, dag):
+        """Run the ElidePermutations pass on ``dag``.
+
+        Args:
+            dag (DAGCircuit): the DAG to be optimized.
+
+        Returns:
+            DAGCircuit: the optimized DAG.
+        """
+        if self.property_set["layout"] is not None:
+            logger.warning(
+                "ElidePermutations is not valid after a layout has been set. This indicates "
+                "an invalid pass manager construction."
+            )
+            return dag
+
+        op_count = dag.count_ops()
+        if op_count.get("swap", 0) == 0 and op_count.get("permutation", 0) == 0:
+            return dag
+
+        new_dag = dag.copy_empty_like()
+        qubit_mapping = list(range(len(dag.qubits)))
+
+        def _apply_mapping(qargs):
+            return tuple(dag.qubits[qubit_mapping[dag.find_bit(qubit).index]] for qubit in qargs)
+
+        for node in dag.topological_op_nodes():
+            if not isinstance(node.op, (SwapGate, PermutationGate)):
+                new_dag.apply_operation_back(node.op, _apply_mapping(node.qargs), node.cargs)
+            elif getattr(node.op, "condition", None) is not None:
+                new_dag.apply_operation_back(node.op, _apply_mapping(node.qargs), node.cargs)
+            elif isinstance(node.op, SwapGate):
+                index_0 = dag.find_bit(node.qargs[0]).index
+                index_1 = dag.find_bit(node.qargs[1]).index
+                qubit_mapping[index_1], qubit_mapping[index_0] = (
+                    qubit_mapping[index_0],
+                    qubit_mapping[index_1],
+                )
+            elif isinstance(node.op, PermutationGate):
+                starting_indices = [qubit_mapping[dag.find_bit(qarg).index] for qarg in node.qargs]
+                pattern = node.op.params[0]
+                pattern_indices = [qubit_mapping[idx] for idx in pattern]
+                for i, j in zip(starting_indices, pattern_indices):
+                    qubit_mapping[i] = j
+        input_qubit_mapping = {qubit: index for index, qubit in enumerate(dag.qubits)}
+        self.property_set["original_layout"] = Layout(input_qubit_mapping)
+        if self.property_set["original_qubit_indices"] is None:
+            self.property_set["original_qubit_indices"] = input_qubit_mapping
+        # ToDo: check if this exists; then compose
+        self.property_set["virtual_permutation_layout"] = Layout(
+            {dag.qubits[out]: idx for idx, out in enumerate(qubit_mapping)}
+        )
+        return new_dag

qiskit/transpiler/passes/optimization/finalize_layouts.py

@@ -0,0 +1,77 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2024
+#
+# 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.
+
+
+"""Finalize layout-related attributes."""
+
+import logging
+
+from qiskit.transpiler.basepasses import AnalysisPass
+from qiskit.transpiler.layout import Layout
+
+logger = logging.getLogger(__name__)
+
+
+class FinalizeLayouts(AnalysisPass):
+    """Finalize 'layout' and 'final_layout' attributes, taking 'virtual_permutation_layout'
+    into account when exists.
+    """
+
+    def run(self, dag):
+        """Run the FinalizeLayouts pass on ``dag``.
+
+        Args:
+            dag (DAGCircuit): the DAG circuit.
+        """
+
+        if (
+            virtual_permutation_layout := self.property_set.get("virtual_permutation_layout", None)
+        ) is None:
+            return
+
+        self.property_set.pop("virtual_permutation_layout")
+
+        # virtual_permutation_layout is usually created before extending the layout with ancillas,
+        # so we extend the permutation to be identity on ancilla qubits
+        original_qubit_indices = self.property_set.get("original_qubit_indices", None)
+        for oq in original_qubit_indices:
+            if oq not in virtual_permutation_layout:
+                virtual_permutation_layout[oq] = original_qubit_indices[oq]
+
+        t_qubits = dag.qubits
+
+        if (t_initial_layout := self.property_set.get("layout", None)) is None:
+            t_initial_layout = Layout(dict(enumerate(t_qubits)))
+
+        if (t_final_layout := self.property_set.get("final_layout", None)) is None:
+            t_final_layout = Layout(dict(enumerate(t_qubits)))
+
+        # Ordered list of original qubits
+        original_qubits_reverse = {v: k for k, v in original_qubit_indices.items()}
+        original_qubits = []
+        for i in range(len(original_qubits_reverse)):
+            original_qubits.append(original_qubits_reverse[i])
+
+        virtual_permutation_layout_inv = virtual_permutation_layout.inverse(
+            original_qubits, original_qubits
+        )
+
+        t_initial_layout_inv = t_initial_layout.inverse(original_qubits, t_qubits)
+
+        # ToDo: this can possibly be made simpler
+        new_final_layout = t_initial_layout_inv
+        new_final_layout = new_final_layout.compose(virtual_permutation_layout_inv, original_qubits)
+        new_final_layout = new_final_layout.compose(t_initial_layout, original_qubits)
+        new_final_layout = new_final_layout.compose(t_final_layout, t_qubits)
+
+        self.property_set["layout"] = t_initial_layout
+        self.property_set["final_layout"] = new_final_layout

qiskit/transpiler/preset_passmanagers/builtin_plugins.py

@@ -154,7 +154,6 @@ def pass_manager(self, pass_manager_config, optimization_level=None) -> PassMana
                 )
             )
             init.append(CommutativeCancellation())
-
         else:
             raise TranspilerError(f"Invalid optimization level {optimization_level}")
         return init

releasenotes/notes/add-elide-swaps-b0a4c373c9af1efd.yaml

@@ -0,0 +1,47 @@
+---
+features:
+  - |
+    Added a new optimization transpiler pass, :class:`~.ElidePermutations`,
+    which is designed to run prior to the :ref:`layout_stage` and will
+    optimize away any :class:`~.SwapGate`\s and
+    :class:`~qiskit.circuit.library.PermutationGate`\s
+    in a circuit by permuting virtual
+    qubits. For example, taking a circuit with :class:`~.SwapGate`\s:
+
+    .. plot::
+
+       from qiskit.circuit import QuantumCircuit
+
+       qc = QuantumCircuit(3)
+       qc.h(0)
+       qc.swap(0, 1)
+       qc.swap(2, 0)
+       qc.cx(1, 0)
+       qc.measure_all()
+       qc.draw("mpl")
+
+    will remove the swaps when the pass is run:
+
+    .. plot::
+       :include-source:
+
+       from qiskit.transpiler.passes import ElidePermutations
+       from qiskit.circuit import QuantumCircuit
+
+       qc = QuantumCircuit(3)
+       qc.h(0)
+       qc.swap(0, 1)
+       qc.swap(2, 0)
+       qc.cx(1, 0)
+       qc.measure_all()
+
+       ElidePermutations()(qc).draw("mpl")
+
+    The pass also sets the ``virtual_permutation_layout`` property set, storing
+    the permutation of the virtual qubits that was optimized away.
+
+  - |
+    Added a new optimization transpiler pass, :class:`~.FinalizeLayouts`,
+    which is designed to run after the :ref:`routing_stage` and update the
+    ``final_layout`` property set based on ``layout`` and
+    ``virtual_permutation_layout``.