qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/transpiler/passes/optimization/template_optimization.py

@@ -0,0 +1,158 @@
+# 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.
+
+"""
+Given a template and a circuit: it applies template matching and substitutes
+all compatible maximal matches that reduces the size of the circuit.
+
+**Reference:**
+
+[1] Iten, R., Moyard, R., Metger, T., Sutter, D. and Woerner, S., 2020.
+Exact and practical pattern matching for quantum circuit optimization.
+`arXiv:1909.05270 <https://arxiv.org/abs/1909.05270>`_
+"""
+import numpy as np
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.dagcircuit import DAGDependency
+from qiskit.converters.circuit_to_dagdependency import circuit_to_dagdependency
+from qiskit.converters.dagdependency_to_circuit import dagdependency_to_circuit
+from qiskit.converters.dag_to_dagdependency import dag_to_dagdependency
+from qiskit.converters.dagdependency_to_dag import dagdependency_to_dag
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.circuit.library.templates import template_nct_2a_1, template_nct_2a_2, template_nct_2a_3
+from qiskit.quantum_info.operators.operator import Operator
+from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.transpiler.passes.optimization.template_matching import (
+    TemplateMatching,
+    TemplateSubstitution,
+    MaximalMatches,
+)
+
+
+class TemplateOptimization(TransformationPass):
+    """
+    Class for the template optimization pass.
+    """
+
+    def __init__(
+        self,
+        template_list=None,
+        heuristics_qubits_param=None,
+        heuristics_backward_param=None,
+        user_cost_dict=None,
+    ):
+        """
+        Args:
+            template_list (list[QuantumCircuit()]): list of the different template circuit to apply.
+            heuristics_backward_param (list[int]): [length, survivor] Those are the parameters for
+                applying heuristics on the backward part of the algorithm. This part of the
+                algorithm creates a tree of matching scenario. This tree grows exponentially. The
+                heuristics evaluate which scenarios have the longest match and keep only those.
+                The length is the interval in the tree for cutting it and survivor is the number
+                of scenarios that are kept. We advise to use l=3 and s=1 to have serious time
+                advantage. We remind that the heuristics implies losing a part of the maximal
+                matches. Check reference for more details.
+            heuristics_qubits_param (list[int]): [length] The heuristics for the qubit choice make
+                guesses from the dag dependency of the circuit in order to limit the number of
+                qubit configurations to explore. The length is the number of successors or not
+                predecessors that will be explored in the dag dependency of the circuit, each
+                qubits of the nodes are added to the set of authorized qubits. We advise to use
+                length=1. Check reference for more details.
+            user_cost_dict (Dict[str, int]): quantum cost dictionary passed to TemplateSubstitution
+                to configure its behavior. This will override any default values if None
+                is not given. The key is the name of the gate and the value its quantum cost.
+        """
+        super().__init__()
+        # If no template is given; the template are set as x-x, cx-cx, ccx-ccx.
+        if template_list is None:
+            template_list = [template_nct_2a_1(), template_nct_2a_2(), template_nct_2a_3()]
+        self.template_list = template_list
+        self.heuristics_qubits_param = (
+            heuristics_qubits_param if heuristics_qubits_param is not None else []
+        )
+        self.heuristics_backward_param = (
+            heuristics_backward_param if heuristics_backward_param is not None else []
+        )
+
+        self.user_cost_dict = user_cost_dict
+
+    def run(self, dag):
+        """
+        Args:
+            dag(DAGCircuit): DAG circuit.
+        Returns:
+            DAGCircuit: optimized DAG circuit.
+        Raises:
+            TranspilerError: If the template has not the right form or
+             if the output circuit acts differently as the input circuit.
+        """
+        circuit_dag = dag
+        circuit_dag_dep = dag_to_dagdependency(circuit_dag)
+
+        for template in self.template_list:
+            if not isinstance(template, (QuantumCircuit, DAGDependency)):
+                raise TranspilerError("A template is a Quantumciruit or a DAGDependency.")
+
+            if len(template.qubits) > len(circuit_dag_dep.qubits):
+                continue
+
+            identity = np.identity(2 ** len(template.qubits), dtype=complex)
+            try:
+                if isinstance(template, DAGDependency):
+                    data = Operator(dagdependency_to_circuit(template)).data
+                else:
+                    data = Operator(template).data
+
+                comparison = np.allclose(data, identity)
+
+                if not comparison:
+                    raise TranspilerError(
+                        "A template is a Quantumciruit() that performs the identity."
+                    )
+            except TypeError:
+                pass
+
+            if isinstance(template, QuantumCircuit):
+                template_dag_dep = circuit_to_dagdependency(template)
+            else:
+                template_dag_dep = template
+
+            template_m = TemplateMatching(
+                circuit_dag_dep,
+                template_dag_dep,
+                self.heuristics_qubits_param,
+                self.heuristics_backward_param,
+            )
+
+            template_m.run_template_matching()
+
+            matches = template_m.match_list
+
+            if matches:
+                maximal = MaximalMatches(matches)
+                maximal.run_maximal_matches()
+                max_matches = maximal.max_match_list
+
+                substitution = TemplateSubstitution(
+                    max_matches,
+                    template_m.circuit_dag_dep,
+                    template_m.template_dag_dep,
+                    self.user_cost_dict,
+                )
+                substitution.run_dag_opt()
+
+                circuit_dag_dep = substitution.dag_dep_optimized
+            else:
+                continue
+        circuit_dag = dagdependency_to_dag(circuit_dag_dep)
+        return circuit_dag

qiskit/transpiler/passes/routing/__init__.py

@@ -0,0 +1,21 @@
+# 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.
+
+"""Module containing transpiler mapping passes."""
+
+from .basic_swap import BasicSwap
+from .layout_transformation import LayoutTransformation
+from .lookahead_swap import LookaheadSwap
+from .sabre_swap import SabreSwap
+from .commuting_2q_gate_routing.commuting_2q_gate_router import Commuting2qGateRouter
+from .commuting_2q_gate_routing.swap_strategy import SwapStrategy
+from .star_prerouting import StarPreRouting

qiskit/transpiler/passes/routing/algorithms/__init__.py

@@ -0,0 +1,33 @@
+# 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.
+
+# Copyright 2019 Andrew M. Childs, Eddie Schoute, Cem M. Unsal
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""The permutation modules contains some functions for permuting on architectures given a mapping.
+
+A permutation function takes in a graph and a permutation of graph nodes,
+and returns a sequence of SWAPs that implements that permutation on the graph.
+"""
+
+from .token_swapper import ApproximateTokenSwapper

qiskit/transpiler/passes/routing/algorithms/token_swapper.py

@@ -0,0 +1,105 @@
+# 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.
+
+# Copyright 2019 Andrew M. Childs, Eddie Schoute, Cem M. Unsal
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Permutation algorithms for general graphs."""
+
+from __future__ import annotations
+import logging
+from collections.abc import Mapping
+
+import numpy as np
+import rustworkx as rx
+
+from .types import Swap, Permutation
+from .util import PermutationCircuit, permutation_circuit
+
+
+logger = logging.getLogger(__name__)
+
+
+class ApproximateTokenSwapper:
+    """A class for computing approximate solutions to the Token Swapping problem.
+
+    Internally caches the graph and associated datastructures for re-use.
+    """
+
+    def __init__(self, graph: rx.PyGraph, seed: int | np.random.Generator | None = None) -> None:
+        """Construct an ApproximateTokenSwapping object.
+
+        Args:
+            graph: Undirected graph represented a coupling map.
+            seed: Seed to use for random trials.
+        """
+        self.graph = graph
+        self.shortest_paths = rx.graph_distance_matrix(graph)
+        if isinstance(seed, np.random.Generator):
+            self.seed = seed
+        else:
+            self.seed = np.random.default_rng(seed)
+
+    def distance(self, vertex0: int, vertex1: int) -> int:
+        """Compute the distance between two nodes in `graph`."""
+        return self.shortest_paths[vertex0, vertex1]
+
+    def permutation_circuit(self, permutation: Permutation, trials: int = 4) -> PermutationCircuit:
+        """Perform an approximately optimal Token Swapping algorithm to implement the permutation.
+
+        Args:
+          permutation: The partial mapping to implement in swaps.
+          trials: The number of trials to try to perform the mapping. Minimize over the trials.
+
+        Returns:
+          The circuit to implement the permutation
+        """
+        sequential_swaps = self.map(permutation, trials=trials)
+
+        parallel_swaps = [[swap] for swap in sequential_swaps]
+        return permutation_circuit(parallel_swaps)
+
+    def map(
+        self, mapping: Mapping[int, int], trials: int = 4, parallel_threshold: int = 50
+    ) -> list[Swap[int]]:
+        """Perform an approximately optimal Token Swapping algorithm to implement the permutation.
+
+        Supports partial mappings (i.e. not-permutations) for graphs with missing tokens.
+
+        Based on the paper: Approximation and Hardness for Token Swapping by Miltzow et al. (2016)
+        ArXiV: https://arxiv.org/abs/1602.05150
+        and generalization based on our own work.
+
+        Args:
+          mapping: The partial mapping to implement in swaps.
+          trials: The number of trials to try to perform the mapping. Minimize over the trials.
+          parallel_threshold: The number of nodes in the graph beyond which the algorithm
+                will use parallel processing
+
+        Returns:
+          The swaps to implement the mapping
+        """
+        # Since integer seed is used in rustworkx, take random integer from np.random.randint
+        # and use that for the seed.
+        seed = self.seed.integers(1, 10000)
+        return rx.graph_token_swapper(self.graph, mapping, trials, seed, parallel_threshold)

qiskit/transpiler/passes/routing/algorithms/types.py

@@ -0,0 +1,46 @@
+# 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.
+
+# Copyright 2019 Andrew M. Childs, Eddie Schoute, Cem M. Unsal
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Type definitions used within the permutation package."""
+
+from typing import TypeVar, Dict, Tuple, NamedTuple, Union
+
+from qiskit.circuit import Qubit
+from qiskit.dagcircuit import DAGCircuit
+
+PermuteElement = TypeVar("PermuteElement")
+Permutation = Dict[PermuteElement, PermuteElement]
+Swap = Tuple[PermuteElement, PermuteElement]
+
+# Represents a circuit for permuting to a mapping.
+PermutationCircuit = NamedTuple(
+    "PermutationCircuit",
+    [
+        ("circuit", DAGCircuit),
+        ("inputmap", Dict[Union[int, Qubit], Qubit]),
+        # A mapping from architecture nodes to circuit registers.
+    ],
+)

qiskit/transpiler/passes/routing/algorithms/util.py

@@ -0,0 +1,103 @@
+# 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.
+
+# Copyright 2019 Andrew M. Childs, Eddie Schoute, Cem M. Unsal
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Utility functions shared between permutation functionality."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import TypeVar, MutableMapping
+
+from qiskit.circuit import QuantumRegister
+from qiskit.dagcircuit import DAGCircuit
+from qiskit.circuit.library.standard_gates import SwapGate
+
+from .types import Swap, PermutationCircuit
+
+_K = TypeVar("_K")
+_V = TypeVar("_V")
+
+
+def swap_permutation(
+    swaps: Iterable[Iterable[Swap[_K]]],
+    mapping: MutableMapping[_K, _V],
+    allow_missing_keys: bool = False,
+) -> None:
+    """Given a circuit of swaps, apply them to the permutation (in-place).
+
+    Args:
+      swaps: param mapping: A mapping of Keys to Values, where the Keys are being swapped.
+      mapping: The permutation to have swaps applied to.
+      allow_missing_keys: Whether to allow swaps of missing keys in mapping.
+    """
+    for swap_step in swaps:
+        for sw1, sw2 in swap_step:
+            # Take into account non-existent keys.
+            val1: _V | None = None
+            val2: _V | None = None
+            if allow_missing_keys:
+                val1 = mapping.pop(sw1, None)
+                val2 = mapping.pop(sw2, None)
+            else:
+                # Asserts that both keys exist
+                val1, val2 = mapping.pop(sw1), mapping.pop(sw2)
+
+            if val1 is not None:
+                mapping[sw2] = val1
+            if val2 is not None:
+                mapping[sw1] = val2
+
+
+def permutation_circuit(swaps: Iterable[list[Swap[_V]]]) -> PermutationCircuit:
+    """Produce a circuit description of a list of swaps.
+        With a given permutation and permuter you can compute the swaps using the permuter function
+        then feed it into this circuit function to obtain a circuit description.
+    Args:
+      swaps: An iterable of swaps to perform.
+    Returns:
+      A MappingCircuit with the circuit and a mapping of node to qubit in the circuit.
+    """
+    # Construct a circuit with each unique node id becoming a quantum register of size 1.
+    dag = DAGCircuit()
+    swap_list = list(swaps)
+
+    # Set of unique nodes used in the swaps.
+    nodes = {
+        swap_node for swap_step in swap_list for swap_nodes in swap_step for swap_node in swap_nodes
+    }
+
+    node_qargs = {node: QuantumRegister(1) for node in nodes}
+    for qubit in node_qargs.values():
+        dag.add_qreg(qubit)
+
+    inputmap = {node: q[0] for node, q in node_qargs.items()}
+
+    # Apply swaps to the circuit.
+    for swap_step in swap_list:
+        for swap0, swap1 in swap_step:
+            dag.apply_operation_back(SwapGate(), (inputmap[swap0], inputmap[swap1]), check=False)
+
+    return PermutationCircuit(dag, inputmap)

qiskit/transpiler/passes/routing/basic_swap.py

@@ -0,0 +1,166 @@
+# 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.
+
+"""Map (with minimum effort) a DAGCircuit onto a ``coupling_map`` adding swap gates."""
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.dagcircuit import DAGCircuit
+from qiskit.transpiler.layout import Layout
+from qiskit.circuit.library.standard_gates import SwapGate
+from qiskit.transpiler.target import Target
+from qiskit.transpiler.passes.layout import disjoint_utils
+
+
+class BasicSwap(TransformationPass):
+    """Map (with minimum effort) a DAGCircuit onto a ``coupling_map`` adding swap gates.
+
+    The basic mapper is a minimum effort to insert swap gates to map the DAG onto
+    a coupling map. When a cx is not in the coupling map possibilities, it inserts
+    one or more swaps in front to make it compatible.
+    """
+
+    def __init__(self, coupling_map, fake_run=False):
+        """BasicSwap initializer.
+
+        Args:
+            coupling_map (Union[CouplingMap, Target]): Directed graph represented a coupling map.
+            fake_run (bool): if true, it will only pretend to do routing, i.e., no
+                swap is effectively added.
+        """
+        super().__init__()
+        if isinstance(coupling_map, Target):
+            self.target = coupling_map
+            self.coupling_map = self.target.build_coupling_map()
+        else:
+            self.target = None
+            self.coupling_map = coupling_map
+        self.fake_run = fake_run
+
+    def run(self, dag):
+        """Run the BasicSwap pass on `dag`.
+
+        Args:
+            dag (DAGCircuit): DAG to map.
+
+        Returns:
+            DAGCircuit: A mapped DAG.
+
+        Raises:
+            TranspilerError: if the coupling map or the layout are not
+            compatible with the DAG, or if the ``coupling_map=None``.
+        """
+        if self.fake_run:
+            return self._fake_run(dag)
+
+        new_dag = dag.copy_empty_like()
+
+        if self.coupling_map is None:
+            raise TranspilerError("BasicSwap cannot run with coupling_map=None")
+
+        if len(dag.qregs) != 1 or dag.qregs.get("q", None) is None:
+            raise TranspilerError("Basic swap runs on physical circuits only")
+
+        if len(dag.qubits) > len(self.coupling_map.physical_qubits):
+            raise TranspilerError("The layout does not match the amount of qubits in the DAG")
+        disjoint_utils.require_layout_isolated_to_component(
+            dag, self.coupling_map if self.target is None else self.target
+        )
+        canonical_register = dag.qregs["q"]
+        trivial_layout = Layout.generate_trivial_layout(canonical_register)
+        current_layout = trivial_layout.copy()
+
+        for layer in dag.serial_layers():
+            subdag = layer["graph"]
+
+            for gate in subdag.two_qubit_ops():
+                physical_q0 = current_layout[gate.qargs[0]]
+                physical_q1 = current_layout[gate.qargs[1]]
+                if self.coupling_map.distance(physical_q0, physical_q1) != 1:
+                    # Insert a new layer with the SWAP(s).
+                    swap_layer = DAGCircuit()
+                    swap_layer.add_qreg(canonical_register)
+
+                    path = self.coupling_map.shortest_undirected_path(physical_q0, physical_q1)
+                    for swap in range(len(path) - 2):
+                        connected_wire_1 = path[swap]
+                        connected_wire_2 = path[swap + 1]
+
+                        qubit_1 = current_layout[connected_wire_1]
+                        qubit_2 = current_layout[connected_wire_2]
+
+                        # create the swap operation
+                        swap_layer.apply_operation_back(
+                            SwapGate(), (qubit_1, qubit_2), cargs=(), check=False
+                        )
+
+                    # layer insertion
+                    order = current_layout.reorder_bits(new_dag.qubits)
+                    new_dag.compose(swap_layer, qubits=order)
+
+                    # update current_layout
+                    for swap in range(len(path) - 2):
+                        current_layout.swap(path[swap], path[swap + 1])
+
+            order = current_layout.reorder_bits(new_dag.qubits)
+            new_dag.compose(subdag, qubits=order)
+
+        if self.property_set["final_layout"] is None:
+            self.property_set["final_layout"] = current_layout
+        else:
+            self.property_set["final_layout"] = current_layout.compose(
+                self.property_set["final_layout"], dag.qubits
+            )
+
+        return new_dag
+
+    def _fake_run(self, dag):
+        """Do a fake run the BasicSwap pass on `dag`.
+
+        Args:
+            dag (DAGCircuit): DAG to improve initial layout.
+
+        Returns:
+            DAGCircuit: The same DAG.
+
+        Raises:
+            TranspilerError: if the coupling map or the layout are not
+            compatible with the DAG.
+        """
+        if len(dag.qregs) != 1 or dag.qregs.get("q", None) is None:
+            raise TranspilerError("Basic swap runs on physical circuits only")
+
+        if len(dag.qubits) > len(self.coupling_map.physical_qubits):
+            raise TranspilerError("The layout does not match the amount of qubits in the DAG")
+
+        canonical_register = dag.qregs["q"]
+        trivial_layout = Layout.generate_trivial_layout(canonical_register)
+        current_layout = trivial_layout.copy()
+
+        for layer in dag.serial_layers():
+            subdag = layer["graph"]
+            for gate in subdag.two_qubit_ops():
+                physical_q0 = current_layout[gate.qargs[0]]
+                physical_q1 = current_layout[gate.qargs[1]]
+                if self.coupling_map.distance(physical_q0, physical_q1) != 1:
+                    path = self.coupling_map.shortest_undirected_path(physical_q0, physical_q1)
+                    # update current_layout
+                    for swap in range(len(path) - 2):
+                        current_layout.swap(path[swap], path[swap + 1])
+
+        if self.property_set["final_layout"] is None:
+            self.property_set["final_layout"] = current_layout
+        else:
+            self.property_set["final_layout"] = current_layout.compose(
+                self.property_set["final_layout"], dag.qubits
+            )
+        return dag

qiskit/transpiler/passes/routing/commuting_2q_gate_routing/__init__.py

@@ -0,0 +1,25 @@
+# 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.
+
+"""Module containing swap strategies for blocks of commuting gates.
+
+Swap routing is, in general, a hard problem. However, this problem is much simpler if
+the gates commute. Many variational algorithms such as QAOA are built with blocks of
+commuting gates. Transpiling such circuits with a general purpose SWAP router typically
+yields sub optimal results or is costly to run. This module introduces a framework to
+transpile blocks of commuting gates by applying layers of a predefined swap strategy.
+Further details can also be found here: https://arxiv.org/abs/2202.03459.
+"""
+
+from .swap_strategy import SwapStrategy
+from .pauli_2q_evolution_commutation import FindCommutingPauliEvolutions
+from .commuting_2q_gate_router import Commuting2qGateRouter