Merge branch 'main' into move-equivalence

Cargo.toml

@@ -15,7 +15,7 @@ license = "Apache-2.0"
 # Each crate can add on specific features freely as it inherits.
 [workspace.dependencies]
 bytemuck = "1.16"
-indexmap.version = "2.2.6"
+indexmap.version = "2.3.0"
 hashbrown.version = "0.14.0"
 num-bigint = "0.4"
 num-complex = "0.4"

qiskit/transpiler/passes/__init__.py

@@ -91,6 +91,7 @@
    ElidePermutations
    NormalizeRXAngle
    OptimizeAnnotated
+   Split2QUnitaries
 
 Calibration
 =============
@@ -244,6 +245,7 @@
 from .optimization import ElidePermutations
 from .optimization import NormalizeRXAngle
 from .optimization import OptimizeAnnotated
+from .optimization import Split2QUnitaries
 
 # circuit analysis
 from .analysis import ResourceEstimation

qiskit/transpiler/passes/optimization/__init__.py

@@ -38,3 +38,4 @@
 from .elide_permutations import ElidePermutations
 from .normalize_rx_angle import NormalizeRXAngle
 from .optimize_annotated import OptimizeAnnotated
+from .split_2q_unitaries import Split2QUnitaries

qiskit/transpiler/passes/optimization/split_2q_unitaries.py

@@ -0,0 +1,83 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+"""Splits each two-qubit gate in the `dag` into two single-qubit gates, if possible without error."""
+from typing import Optional
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.circuit.quantumcircuitdata import CircuitInstruction
+from qiskit.dagcircuit.dagcircuit import DAGCircuit, DAGOpNode
+from qiskit.circuit.library.generalized_gates import UnitaryGate
+from qiskit.synthesis.two_qubit.two_qubit_decompose import TwoQubitWeylDecomposition
+
+
+class Split2QUnitaries(TransformationPass):
+    """Attempt to splits two-qubit gates in a :class:`.DAGCircuit` into two single-qubit gates
+
+    This pass will analyze all the two qubit gates in the circuit and analyze the gate's unitary
+    matrix to determine if the gate is actually a product of 2 single qubit gates. In these
+    cases the 2q gate can be simplified into two single qubit gates and this pass will
+    perform this optimization and will replace the two qubit gate with two single qubit
+    :class:`.UnitaryGate`.
+    """
+
+    def __init__(self, fidelity: Optional[float] = 1.0 - 1e-16):
+        """Split2QUnitaries initializer.
+
+        Args:
+            fidelity (float): Allowed tolerance for splitting two-qubit unitaries and gate decompositions
+        """
+        super().__init__()
+        self.requested_fidelity = fidelity
+
+    def run(self, dag: DAGCircuit):
+        """Run the Split2QUnitaries pass on `dag`."""
+        for node in dag.topological_op_nodes():
+            # skip operations without two-qubits and for which we can not determine a potential 1q split
+            if (
+                len(node.cargs) > 0
+                or len(node.qargs) != 2
+                or node.matrix is None
+                or node.is_parameterized()
+            ):
+                continue
+
+            decomp = TwoQubitWeylDecomposition(node.op, fidelity=self.requested_fidelity)
+            if (
+                decomp._inner_decomposition.specialization
+                == TwoQubitWeylDecomposition._specializations.IdEquiv
+            ):
+                new_dag = DAGCircuit()
+                new_dag.add_qubits(node.qargs)
+
+                ur = decomp.K1r
+                ur_node = DAGOpNode.from_instruction(
+                    CircuitInstruction(UnitaryGate(ur), qubits=(node.qargs[0],)), dag=new_dag
+                )
+
+                ul = decomp.K1l
+                ul_node = DAGOpNode.from_instruction(
+                    CircuitInstruction(UnitaryGate(ul), qubits=(node.qargs[1],)), dag=new_dag
+                )
+                new_dag._apply_op_node_back(ur_node)
+                new_dag._apply_op_node_back(ul_node)
+                new_dag.global_phase = decomp.global_phase
+                dag.substitute_node_with_dag(node, new_dag)
+            elif (
+                decomp._inner_decomposition.specialization
+                == TwoQubitWeylDecomposition._specializations.SWAPEquiv
+            ):
+                # TODO maybe also look into swap-gate-like gates? Things to consider:
+                #   * As the qubit mapping may change, we'll always need to build a new dag in this pass
+                #   * There may not be many swap-gate-like gates in an arbitrary input circuit
+                #   * Removing swap gates from a user-routed input circuit here is unexpected
+                pass
+        return dag

qiskit/transpiler/preset_passmanagers/builtin_plugins.py

@@ -14,6 +14,8 @@
 
 import os
 
+from qiskit.circuit import Instruction
+from qiskit.transpiler.passes.optimization.split_2q_unitaries import Split2QUnitaries
 from qiskit.transpiler.passmanager import PassManager
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.transpiler.passes import BasicSwap
@@ -64,12 +66,23 @@
     CYGate,
     SXGate,
     SXdgGate,
+    get_standard_gate_name_mapping,
 )
 from qiskit.utils.parallel import CPU_COUNT
 from qiskit import user_config
 
 CONFIG = user_config.get_config()
 
+_discrete_skipped_ops = {
+    "delay",
+    "reset",
+    "measure",
+    "switch_case",
+    "if_else",
+    "for_loop",
+    "while_loop",
+}
+
 
 class DefaultInitPassManager(PassManagerStagePlugin):
     """Plugin class for default init stage."""
@@ -160,6 +173,58 @@ def pass_manager(self, pass_manager_config, optimization_level=None) -> PassMana
                 )
             )
             init.append(CommutativeCancellation())
+            # skip peephole optimization before routing if target basis gate set is discrete,
+            # i.e. only consists of Cliffords that an user might want to keep
+            # use rz, sx, x, cx as basis, rely on physical optimziation to fix everything later one
+            stdgates = get_standard_gate_name_mapping()
+
+            def _is_one_op_non_discrete(ops):
+                """Checks if one operation in `ops` is not discrete, i.e. is parameterizable
+                Args:
+                    ops (List(Operation)): list of operations to check
+                Returns
+                    True if at least one operation in `ops` is not discrete, False otherwise
+                """
+                found_one_continuous_gate = False
+                for op in ops:
+                    if isinstance(op, str):
+                        if op in _discrete_skipped_ops:
+                            continue
+                        op = stdgates.get(op, None)
+
+                    if op is not None and op.name in _discrete_skipped_ops:
+                        continue
+
+                    if op is None or not isinstance(op, Instruction):
+                        return False
+
+                    if len(op.params) > 0:
+                        found_one_continuous_gate = True
+                return found_one_continuous_gate
+
+            target = pass_manager_config.target
+            basis = pass_manager_config.basis_gates
+            # consolidate gates before routing if the user did not specify a discrete basis gate, i.e.
+            # * no target or basis gate set has been specified
+            # * target has been specified, and we have one non-discrete gate in the target's spec
+            # * basis gates have been specified, and we have one non-discrete gate in that set
+            do_consolidate_blocks_init = target is None and basis is None
+            do_consolidate_blocks_init |= target is not None and _is_one_op_non_discrete(
+                target.operations
+            )
+            do_consolidate_blocks_init |= basis is not None and _is_one_op_non_discrete(basis)
+
+            if do_consolidate_blocks_init:
+                init.append(Collect2qBlocks())
+                init.append(ConsolidateBlocks())
+                # If approximation degree is None that indicates a request to approximate up to the
+                # error rates in the target. However, in the init stage we don't yet know the target
+                # qubits being used to figure out the fidelity so just use the default fidelity parameter
+                # in this case.
+                if pass_manager_config.approximation_degree is not None:
+                    init.append(Split2QUnitaries(pass_manager_config.approximation_degree))
+                else:
+                    init.append(Split2QUnitaries())
         else:
             raise TranspilerError(f"Invalid optimization level {optimization_level}")
         return init

releasenotes/notes/peephole-before-routing-c3d184b740bb7a8b.yaml

@@ -0,0 +1,20 @@
+---
+features_transpiler:
+  - |
+    Added a new pass :class:`.Split2QUnitaries` that iterates over all two-qubit gates or unitaries in a
+    circuit and replaces them with two single-qubit unitaries, if possible without introducing errors, i.e.
+    the two-qubit gate/unitary is actually a (kronecker) product of single-qubit unitaries.
+  - |
+    The passes :class:`.Collect2qBlocks`, :class:`.ConsolidateBlocks` and :class:`.Split2QUnitaries` have been
+    added to the ``init`` stage of the preset pass managers with optimization level 2 and optimization level 3.
+    The modification of the `init` stage should allow for a more efficient routing for quantum circuits that either:
+    
+      * contain two-qubit unitaries/gates that are actually a product of single-qubit gates
+      * contain multiple two-qubit gates in a continuous block of two-qubit gates.
+      
+    In the former case, the routing of the two-qubit gate can simply be skipped as no real interaction
+    between a pair of qubits occurs. In the latter case, the lookahead space of routing algorithms is not
+    'polluted' by superfluous two-qubit gates, i.e. for routing it is sufficient to only consider one single
+    two-qubit gate per continuous block of two-qubit gates. These passes are not run if the pass
+    managers target a :class:`.Target` that has a discrete basis gate set, i.e. all basis gates have are not
+    parameterized.