Add ElidePermutations pass to optimization level 3

qiskit/quantum_info/operators/operator.py

@@ -81,6 +81,9 @@ def __init__(
             a Numpy array of shape (2**N, 2**N) qubit systems will be used. If
             the input operator is not an N-qubit operator, it will assign a
             single subsystem with dimension specified by the shape of the input.
+            Note that two operators initialized via this method are only considered equivalent if they
+            match up to their canonical qubit order (or: permutation). See :meth:`.Operator.from_circuit`
+            to specify a different qubit permutation.
         """
         op_shape = None
         if isinstance(data, (list, np.ndarray)):
@@ -391,8 +394,7 @@ def from_circuit(
         Returns:
             Operator: An operator representing the input circuit
         """
-        dimension = 2**circuit.num_qubits
-        op = cls(np.eye(dimension))
+
         if layout is None:
             if not ignore_set_layout:
                 layout = getattr(circuit, "_layout", None)
@@ -403,27 +405,38 @@ def from_circuit(
                 initial_layout=layout,
                 input_qubit_mapping={qubit: index for index, qubit in enumerate(circuit.qubits)},
             )
+
+        initial_layout = layout.initial_layout if layout is not None else None
+
         if final_layout is None:
             if not ignore_set_layout and layout is not None:
                 final_layout = getattr(layout, "final_layout", None)
 
-        qargs = None
-        # If there was a layout specified (either from the circuit
-        # or via user input) use that to set qargs to permute qubits
-        # based on that layout
-        if layout is not None:
-            physical_to_virtual = layout.initial_layout.get_physical_bits()
-            qargs = [
-                layout.input_qubit_mapping[physical_to_virtual[physical_bit]]
-                for physical_bit in range(len(physical_to_virtual))
-            ]
-        # Convert circuit to an instruction
-        instruction = circuit.to_instruction()
-        op._append_instruction(instruction, qargs=qargs)
-        # If final layout is set permute output indices based on layout
+        from qiskit.synthesis.permutation.permutation_utils import _inverse_pattern
+
+        if initial_layout is not None:
+            input_qubits = [None] * len(layout.input_qubit_mapping)
+            for q, p in layout.input_qubit_mapping.items():
+                input_qubits[p] = q
+
+            initial_permutation = initial_layout.to_permutation(input_qubits)
+            initial_permutation_inverse = _inverse_pattern(initial_permutation)
+
         if final_layout is not None:
-            perm_pattern = [final_layout._v2p[v] for v in circuit.qubits]
-            op = op.apply_permutation(perm_pattern, front=False)
+            final_permutation = final_layout.to_permutation(circuit.qubits)
+            final_permutation_inverse = _inverse_pattern(final_permutation)
+
+        op = Operator(circuit)
+
+        if initial_layout:
+            op = op.apply_permutation(initial_permutation, True)
+
+        if final_layout:
+            op = op.apply_permutation(final_permutation_inverse, False)
+
+        if initial_layout:
+            op = op.apply_permutation(initial_permutation_inverse, False)
+
         return op
 
     def is_unitary(self, atol=None, rtol=None):

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()
@@ -71,9 +70,9 @@ def run(self, dag):
             }
             for qreg in dag.qregs.values():
                 self.property_set["layout"].add_register(qreg)
-            virtual_phsyical_map = layout.get_virtual_bits()
+            virtual_physical_map = layout.get_virtual_bits()
             for node in dag.topological_op_nodes():
-                qargs = [q[virtual_phsyical_map[qarg]] for qarg in node.qargs]
+                qargs = [q[virtual_physical_map[qarg]] for qarg in node.qargs]
                 new_dag.apply_operation_back(node.op, qargs, node.cargs, check=False)
         else:
             # First build a new layout object going from:

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

@@ -26,7 +26,7 @@
 from qiskit.transpiler.passes import TrivialLayout
 from qiskit.transpiler.passes import CheckMap
 from qiskit.transpiler.passes import BarrierBeforeFinalMeasurements
-from qiskit.transpiler.passes import OptimizeSwapBeforeMeasure
+from qiskit.transpiler.passes import ElidePermutations
 from qiskit.transpiler.passes import RemoveDiagonalGatesBeforeMeasure
 from qiskit.transpiler.preset_passmanagers import common
 from qiskit.transpiler.preset_passmanagers.plugin import (
@@ -135,7 +135,7 @@ def pass_manager(self, pass_manager_config, optimization_level=None) -> PassMana
                 pass_manager_config.unitary_synthesis_plugin_config,
                 pass_manager_config.hls_config,
             )
-            init.append(OptimizeSwapBeforeMeasure())
+            init.append(ElidePermutations())
             init.append(RemoveDiagonalGatesBeforeMeasure())
             init.append(
                 InverseCancellation(
@@ -156,7 +156,6 @@ def pass_manager(self, pass_manager_config, optimization_level=None) -> PassMana
                 )
             )
             init.append(CommutativeCancellation())
-
         else:
             return TranspilerError(f"Invalid optimization level {optimization_level}")
         return init

qiskit/transpiler/preset_passmanagers/common.py

@@ -48,6 +48,7 @@
 from qiskit.transpiler.passes import PulseGates
 from qiskit.transpiler.passes import ContainsInstruction
 from qiskit.transpiler.passes import VF2PostLayout
+from qiskit.transpiler.passes import FinalizeLayouts
 from qiskit.transpiler.passes.layout.vf2_layout import VF2LayoutStopReason
 from qiskit.transpiler.passes.layout.vf2_post_layout import VF2PostLayoutStopReason
 from qiskit.transpiler.exceptions import TranspilerError
@@ -407,6 +408,13 @@ def _direction_condition(property_set):
     return pre_opt
 
 
+def generate_post_op_passmanager():
+    """Generates the post-optimization pass manager."""
+    out = PassManager()
+    out.append(FinalizeLayouts())
+    return out
+
+
 def generate_translation_passmanager(
     target,
     basis_gates=None,

qiskit/transpiler/preset_passmanagers/level3.py

@@ -107,6 +107,8 @@ def level_3_pass_manager(pass_manager_config: PassManagerConfig) -> StagedPassMa
         "scheduling", scheduling_method, pass_manager_config, optimization_level=3
     )
 
+    post_optimization = common.generate_post_op_passmanager()
+
     return StagedPassManager(
         pre_init=pre_init,
         init=init,
@@ -115,5 +117,6 @@ def level_3_pass_manager(pass_manager_config: PassManagerConfig) -> StagedPassMa
         translation=translation,
         pre_optimization=pre_optimization,
         optimization=optimization,
+        post_optimization=post_optimization,
         scheduling=sched,
     )

releasenotes/notes/add-elide-permutations-to-pipeline-077dad03bd55ab9c.yaml

@@ -0,0 +1,9 @@
+---
+features:
+  - |
+    The transpiler passes :class:`~.ElidePermutations` and :class:`~.FinalizeLayouts`
+    run by default with optimization level 3. Intuitively, removing
+    :class:`~.SwapGate`\s and :class:`~qiskit.circuit.library.PermutationGate`\s
+    in a virtual circuit is almost always beneficial, as it makes the circuit shorter
+    and easier to route. As :class:`~.OptimizeSwapBeforeMeasure` is a special case
+    of :class:`~.ElidePermutations`, it has been removed from optimization level 3.