qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/transpiler/passes/basis/basis_translator.py

@@ -0,0 +1,138 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+
+"""Translates gates to a target basis using a given equivalence library."""
+
+import logging
+
+from collections import defaultdict
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit._accelerate.basis_translator import base_run
+
+logger = logging.getLogger(__name__)
+
+
+class BasisTranslator(TransformationPass):
+    """Translates gates to a target basis by searching for a set of translations
+    from a given EquivalenceLibrary.
+
+    This pass operates in several steps:
+
+    * Determine the source basis from the input circuit.
+    * Perform a Dijkstra search over basis sets, starting from the device's
+      target_basis new gates are being generated using the rules from the provided
+      EquivalenceLibrary and the search stops if all gates in the source basis have
+      been generated.
+    * The found path, as a set of rules from the EquivalenceLibrary, is composed
+      into a set of gate replacement rules.
+    * The composed replacement rules are applied in-place to each op node which
+      is not already in the target_basis.
+
+    If the target keyword argument is specified and that
+    :class:`~qiskit.transpiler.Target` objects contains operations
+    which are non-global (i.e. they are defined only for a subset of qubits),
+    as calculated by :meth:`~qiskit.transpiler.Target.get_non_global_operation_names`,
+    this pass will attempt to match the output translation to those constraints.
+    For 1 qubit operations this is straightforward, the pass will perform a
+    search using the union of the set of global operations with the set of operations
+    defined solely on that qubit. For multi-qubit gates this is a bit more involved,
+    while the behavior is initially similar to the single qubit case, just using all
+    the qubits the operation is run on (where order is not significant) isn't sufficient.
+    We also need to consider any potential local qubits defined on subsets of the
+    quantum arguments for the multi-qubit operation. This means the target used for the
+    search of a non-global multi-qubit gate is the union of global operations, non-global
+    multi-qubit gates sharing the same qubits, and any non-global gates defined on
+    any subset of the qubits used.
+
+
+    .. note::
+
+        In the case of non-global operations it is possible for a single
+        execution of this pass to output an incomplete translation if any
+        non-global gates are defined on qubits that are a subset of a larger
+        multi-qubit gate. For example, if you have a ``u`` gate only defined on
+        qubit 0 and an ``x`` gate only on qubit 1 it is possible when
+        translating a 2 qubit operation on qubit 0 and 1 that the output might
+        have ``u`` on qubit 1 and ``x`` on qubit 0. Typically running this pass
+        a second time will correct these issues.
+
+    .. _translation_errors:
+
+    Translation Errors
+    ------------------
+
+    This pass will error if there is no path to translate an input gate to
+    the specified basis. However, during a typical/default preset passmanager
+    this pass gets run multiple times at different stages of the compilation
+    pipeline. This means that potentially the input gates that are getting
+    translated were not in the input circuit to :func:`~.transpile` as they
+    were generated by an intermediate transform in the circuit.
+
+    When this error occurs it typically means that either the target basis
+    is not universal or there are additional equivalence rules needed in the
+    :class:`~.EquivalenceLibrary` instance being used by the
+    :class:`~.BasisTranslator` pass. You can refer to
+    :ref:`custom_basis_gates` for details on adding custom equivalence rules.
+    """
+
+    def __init__(self, equivalence_library, target_basis, target=None, min_qubits=0):
+        """Initialize a BasisTranslator instance.
+
+        Args:
+            equivalence_library (EquivalenceLibrary): The equivalence library
+                which will be used by the BasisTranslator pass. (Instructions in
+                this library will not be unrolled by this pass.)
+            target_basis (list[str]): Target basis names to unroll to, e.g. ``['u3', 'cx']``.
+            target (Target): The backend compilation target
+            min_qubits (int): The minimum number of qubits for operations in the input
+                dag to translate.
+        """
+        super().__init__()
+        self._equiv_lib = equivalence_library
+        self._target_basis = target_basis
+        # Bypass target if it doesn't contain any basis gates (i.e. it's a _FakeTarget), as this
+        # not part of the official target model.
+        self._target = target if target is not None and len(target.operation_names) > 0 else None
+        self._non_global_operations = None
+        self._qargs_with_non_global_operation = {}
+        self._min_qubits = min_qubits
+        if self._target is not None:
+            self._non_global_operations = self._target.get_non_global_operation_names()
+            self._qargs_with_non_global_operation = defaultdict(set)
+            for gate in self._non_global_operations:
+                for qarg in self._target[gate]:
+                    self._qargs_with_non_global_operation[qarg].add(gate)
+
+    def run(self, dag):
+        """Translate an input DAGCircuit to the target basis.
+
+        Args:
+            dag (DAGCircuit): input dag
+
+        Raises:
+            TranspilerError: if the target basis cannot be reached
+
+        Returns:
+            DAGCircuit: translated circuit.
+        """
+
+        return base_run(
+            dag,
+            self._equiv_lib,
+            self._qargs_with_non_global_operation,
+            self._min_qubits,
+            None if self._target_basis is None else set(self._target_basis),
+            self._target,
+            None if self._non_global_operations is None else set(self._non_global_operations),
+        )

qiskit/transpiler/passes/basis/decompose.py

@@ -0,0 +1,137 @@
+# 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.
+
+"""Expand a gate in a circuit using its decomposition rules."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Type
+from fnmatch import fnmatch
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.passes.utils import control_flow
+from qiskit.dagcircuit.dagnode import DAGOpNode
+from qiskit.dagcircuit.dagcircuit import DAGCircuit
+from qiskit.converters.circuit_to_dag import circuit_to_dag
+from qiskit.circuit.instruction import Instruction
+
+from ..synthesis import HighLevelSynthesis
+
+
+class Decompose(TransformationPass):
+    """Expand a gate in a circuit using its decomposition rules."""
+
+    def __init__(
+        self,
+        gates_to_decompose: (
+            str | Type[Instruction] | Sequence[str | Type[Instruction]] | None
+        ) = None,
+        apply_synthesis: bool = False,
+    ) -> None:
+        """
+        Args:
+            gates_to_decompose: optional subset of gates to be decomposed,
+                identified by gate label, name or type. Defaults to all gates.
+            apply_synthesis: If ``True``, run :class:`.HighLevelSynthesis` to synthesize operations
+                that do not have a definition attached.
+        """
+        super().__init__()
+        self.gates_to_decompose = gates_to_decompose
+        self.apply_synthesis = apply_synthesis
+
+    def run(self, dag: DAGCircuit) -> DAGCircuit:
+        """Run the Decompose pass on `dag`.
+
+        Args:
+            dag: input dag.
+
+        Returns:
+            output dag where ``gate`` was expanded.
+        """
+        # We might use HLS to synthesize objects that do not have a definition
+        hls = HighLevelSynthesis(qubits_initially_zero=False) if self.apply_synthesis else None
+
+        # Walk through the DAG and expand each non-basis node
+        for node in dag.op_nodes():
+            # Check in self.gates_to_decompose if the operation should be decomposed
+            if not self._should_decompose(node):
+                continue
+
+            if node.is_control_flow():
+                decomposition = control_flow.map_blocks(self.run, node.op)
+                dag.substitute_node(node, decomposition, inplace=True)
+
+            elif getattr(node.op, "definition", None) is None:
+                # if we try to synthesize, turn the node into a DAGCircuit and run HLS
+                if self.apply_synthesis:
+                    node_as_dag = _node_to_dag(node)
+                    synthesized = hls.run(node_as_dag)
+                    dag.substitute_node_with_dag(node, synthesized)
+
+                # else: no definition and synthesis not enabled, so we do nothing
+            else:
+                rule = node.op.definition.data
+
+                if (
+                    len(rule) == 1
+                    and len(node.qargs) == len(rule[0].qubits) == 1  # to preserve gate order
+                    and len(node.cargs) == len(rule[0].clbits) == 0
+                ):
+                    if node.op.definition.global_phase:
+                        dag.global_phase += node.op.definition.global_phase
+                    dag.substitute_node(node, rule[0].operation, inplace=True)
+                else:
+                    decomposition = circuit_to_dag(node.op.definition)
+                    dag.substitute_node_with_dag(node, decomposition)
+
+        return dag
+
+    def _should_decompose(self, node: DAGOpNode) -> bool:
+        """Call a decomposition pass on this circuit to decompose one level (shallow decompose)."""
+        if self.gates_to_decompose is None:  # check if no gates given
+            return True
+
+        if not isinstance(self.gates_to_decompose, list):
+            gates = [self.gates_to_decompose]
+        else:
+            gates = self.gates_to_decompose
+
+        strings_list = [s for s in gates if isinstance(s, str)]
+        gate_type_list = [g for g in gates if isinstance(g, type)]
+
+        if (
+            getattr(node.op, "label", None) is not None
+            and node.op.label != ""
+            and (  # check if label or label wildcard is given
+                node.op.label in gates or any(fnmatch(node.op.label, p) for p in strings_list)
+            )
+        ):
+            return True
+        elif node.name in gates or any(  # check if name or name wildcard is given
+            fnmatch(node.name, p) for p in strings_list
+        ):
+            return True
+        elif any(isinstance(node.op, op) for op in gate_type_list):  # check if Gate type given
+            return True
+        else:
+            return False
+
+
+def _node_to_dag(node: DAGOpNode) -> DAGCircuit:
+    # create new dag and apply the operation
+    dag = DAGCircuit()
+    dag.add_qubits(node.qargs)
+    dag.add_clbits(node.cargs)
+    dag.apply_operation_back(node.op, node.qargs, node.cargs)
+
+    return dag

qiskit/transpiler/passes/basis/translate_parameterized.py

@@ -0,0 +1,175 @@
+# 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.
+
+"""Translate parameterized gates only, and leave others as they are."""
+
+from __future__ import annotations
+
+from qiskit.circuit import Instruction, ParameterExpression, Qubit, Clbit
+from qiskit.circuit.equivalence_library import EquivalenceLibrary
+from qiskit.converters import circuit_to_dag
+from qiskit.dagcircuit import DAGCircuit, DAGOpNode
+from qiskit.exceptions import QiskitError
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.passes.basis.basis_translator import BasisTranslator
+from qiskit.transpiler.target import Target
+
+
+class TranslateParameterizedGates(TransformationPass):
+    """Translate parameterized gates to a supported basis set.
+
+    Once a parameterized instruction is found that is not in the ``supported_gates`` list,
+    the instruction is decomposed one level and the parameterized sub-blocks are recursively
+    decomposed. The recursion is stopped once all parameterized gates are in ``supported_gates``,
+    or if a gate has no definition and a translation to the basis is attempted (this might happen
+    e.g. for the ``UGate`` if it's not in the specified gate list).
+
+    Example:
+
+        The following, multiply nested circuit::
+
+            from qiskit.circuit import QuantumCircuit, ParameterVector
+            from qiskit.transpiler.passes import TranslateParameterizedGates
+
+            x = ParameterVector("x", 4)
+            block1 = QuantumCircuit(1)
+            block1.rx(x[0], 0)
+
+            sub_block = QuantumCircuit(2)
+            sub_block.cx(0, 1)
+            sub_block.rz(x[2], 0)
+
+            block2 = QuantumCircuit(2)
+            block2.ry(x[1], 0)
+            block2.append(sub_block.to_gate(), [0, 1])
+
+            block3 = QuantumCircuit(3)
+            block3.ccx(0, 1, 2)
+
+            circuit = QuantumCircuit(3)
+            circuit.append(block1.to_gate(), [1])
+            circuit.append(block2.to_gate(), [0, 1])
+            circuit.append(block3.to_gate(), [0, 1, 2])
+            circuit.cry(x[3], 0, 2)
+
+            supported_gates = ["rx", "ry", "rz", "cp", "crx", "cry", "crz"]
+            unrolled = TranslateParameterizedGates(supported_gates)(circuit)
+
+        is decomposed to::
+
+                 ┌──────────┐     ┌──────────┐┌─────────────┐
+            q_0: ┤ Ry(x[1]) ├──■──┤ Rz(x[2]) ├┤0            ├─────■──────
+                 ├──────────┤┌─┴─┐└──────────┘│             │     │
+            q_1: ┤ Rx(x[0]) ├┤ X ├────────────┤1 circuit-92 ├─────┼──────
+                 └──────────┘└───┘            │             │┌────┴─────┐
+            q_2: ─────────────────────────────┤2            ├┤ Ry(x[3]) ├
+                                              └─────────────┘└──────────┘
+
+    """
+
+    def __init__(
+        self,
+        supported_gates: list[str] | None = None,
+        equivalence_library: EquivalenceLibrary | None = None,
+        target: Target | None = None,
+    ) -> None:
+        """
+        Args:
+            supported_gates: A list of suppported basis gates specified as string. If ``None``,
+                a ``target`` must be provided.
+            equivalence_library: The equivalence library to translate the gates. Defaults
+                to the equivalence library of all Qiskit standard gates.
+            target: A :class:`.Target` containing the supported operations. If ``None``,
+                ``supported_gates`` must be set. Note that this argument takes precedence over
+                ``supported_gates``, if both are set.
+
+        Raises:
+            ValueError: If neither of ``supported_gates`` and ``target`` are passed.
+        """
+        super().__init__()
+
+        # get the default equivalence library, if none has been set
+        if equivalence_library is None:
+            from qiskit.circuit.library.standard_gates.equivalence_library import _sel
+
+            equivalence_library = _sel
+
+        # The target takes precedence over the supported_gates argument. If neither are set,
+        # raise an error.
+        if target is not None:
+            supported_gates = target.operation_names
+        elif supported_gates is None:
+            raise ValueError("One of ``supported_gates`` or ``target`` must be specified.")
+
+        self._supported_gates = supported_gates
+        self._target = target
+        self._translator = BasisTranslator(equivalence_library, supported_gates, target=target)
+
+    def run(self, dag: DAGCircuit) -> DAGCircuit:
+        """Run the transpiler pass.
+
+        Args:
+            dag: The DAG circuit in which the parameterized gates should be unrolled.
+
+        Returns:
+            A DAG where the parameterized gates have been unrolled.
+
+        Raises:
+            QiskitError: If the circuit cannot be unrolled.
+        """
+        for node in dag.op_nodes():
+            # check whether it is parameterized and we need to decompose it
+            if _is_parameterized(node.op) and not _is_supported(
+                node, self._supported_gates, self._target
+            ):
+                definition = node.op.definition
+
+                if definition is not None:
+                    # recurse to unroll further parameterized blocks
+                    unrolled = self.run(circuit_to_dag(definition))
+                else:
+                    # if we hit a base case, try to translate to the specified basis
+                    try:
+                        unrolled = self._translator.run(_instruction_to_dag(node.op))
+                    except Exception as exc:
+                        raise QiskitError("Failed to translate final block.") from exc
+
+                # replace with unrolled (or translated) dag
+                dag.substitute_node_with_dag(node, unrolled)
+
+        return dag
+
+
+def _is_parameterized(op: Instruction) -> bool:
+    return any(
+        isinstance(param, ParameterExpression) and len(param.parameters) > 0 for param in op.params
+    )
+
+
+def _is_supported(node: DAGOpNode, supported_gates: list[str], target: Target | None) -> bool:
+    """Check whether the node is supported.
+
+    If the target is provided, check using the target, otherwise the supported_gates are used.
+    """
+    if target is not None:
+        return target.instruction_supported(node.op.name)
+
+    return node.op.name in supported_gates
+
+
+def _instruction_to_dag(op: Instruction) -> DAGCircuit:
+    dag = DAGCircuit()
+    dag.add_qubits([Qubit() for _ in range(op.num_qubits)])
+    dag.add_qubits([Clbit() for _ in range(op.num_clbits)])
+    dag.apply_operation_back(op, dag.qubits, dag.clbits, check=False)
+
+    return dag

qiskit/transpiler/passes/basis/unroll_3q_or_more.py

@@ -0,0 +1,84 @@
+# 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.
+
+"""Recursively expands 3q+ gates until the circuit only contains 2q or 1q gates."""
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.passes.utils import control_flow
+from qiskit.exceptions import QiskitError
+from qiskit.circuit import ControlFlowOp
+from qiskit.converters.circuit_to_dag import circuit_to_dag
+
+
+class Unroll3qOrMore(TransformationPass):
+    """Recursively expands 3q+ gates until the circuit only contains 2q or 1q gates."""
+
+    def __init__(self, target=None, basis_gates=None):
+        """Initialize the Unroll3qOrMore pass
+
+        Args:
+            target (Target): The target object representing the compilation
+                target. If specified any multi-qubit instructions in the
+                circuit when the pass is run that are supported by the target
+                device will be left in place. If both this and ``basis_gates``
+                are specified only the target will be checked.
+            basis_gates (list): A list of basis gate names that the target
+                device supports. If specified any gate names in the circuit
+                which are present in this list will not be unrolled. If both
+                this and ``target`` are specified only the target will be used
+                for checking which gates are supported.
+        """
+        super().__init__()
+        self.target = target
+        self.basis_gates = None
+        if basis_gates is not None:
+            self.basis_gates = set(basis_gates)
+
+    def run(self, dag):
+        """Run the Unroll3qOrMore pass on `dag`.
+
+        Args:
+            dag(DAGCircuit): input dag
+        Returns:
+            DAGCircuit: output dag with maximum node degrees of 2
+        Raises:
+            QiskitError: if a 3q+ gate is not decomposable
+        """
+        for node in dag.multi_qubit_ops():
+
+            if isinstance(node.op, ControlFlowOp):
+                dag.substitute_node(node, control_flow.map_blocks(self.run, node.op))
+                continue
+
+            if self.target is not None:
+                # Treat target instructions as global since this pass can be run
+                # prior to layout and routing we don't have physical qubits from
+                # the circuit yet
+                if node.name in self.target:
+                    continue
+            elif self.basis_gates is not None and node.name in self.basis_gates:
+                continue
+
+            # TODO: allow choosing other possible decompositions
+            rule = node.op.definition.data
+            if not rule:
+                if rule == []:  # empty node
+                    dag.remove_op_node(node)
+                    continue
+                raise QiskitError(
+                    "Cannot unroll all 3q or more gates. "
+                    f"No rule to expand instruction {node.op.name}."
+                )
+            decomposition = circuit_to_dag(node.op.definition, copy_operations=False)
+            decomposition = self.run(decomposition)  # recursively unroll
+            dag.substitute_node_with_dag(node, decomposition)
+        return dag

qiskit/transpiler/passes/basis/unroll_custom_definitions.py

@@ -0,0 +1,110 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+"""Unrolls instructions with custom definitions."""
+
+from qiskit.exceptions import QiskitError
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.passes.utils import control_flow
+from qiskit.circuit import ControlledGate, ControlFlowOp
+from qiskit.converters.circuit_to_dag import circuit_to_dag
+
+
+class UnrollCustomDefinitions(TransformationPass):
+    """Unrolls instructions with custom definitions."""
+
+    def __init__(self, equivalence_library, basis_gates=None, target=None, min_qubits=0):
+        """Unrolls instructions with custom definitions.
+
+        Args:
+            equivalence_library (EquivalenceLibrary): The equivalence library
+                which will be used by the BasisTranslator pass. (Instructions in
+                this library will not be unrolled by this pass.)
+            basis_gates (Optional[list[str]]): Target basis names to unroll to, e.g. ``['u3', 'cx']``.
+                Ignored if ``target`` is also specified.
+            target (Optional[Target]): The :class:`~.Target` object corresponding to the compilation
+                target. When specified, any argument specified for ``basis_gates`` is ignored.
+             min_qubits (int): The minimum number of qubits for operations in the input
+                 dag to translate.
+        """
+
+        super().__init__()
+        self._equiv_lib = equivalence_library
+        self._basis_gates = basis_gates
+        self._target = target
+        self._min_qubits = min_qubits
+
+    def run(self, dag):
+        """Run the UnrollCustomDefinitions pass on `dag`.
+
+        Args:
+            dag (DAGCircuit): input dag
+
+        Raises:
+            QiskitError: if unable to unroll given the basis due to undefined
+            decomposition rules (such as a bad basis) or excessive recursion.
+
+        Returns:
+            DAGCircuit: output unrolled dag
+        """
+
+        if self._basis_gates is None and self._target is None:
+            return dag
+
+        device_insts = {"measure", "reset", "barrier", "snapshot", "delay", "store"}
+        if self._target is None:
+            device_insts |= set(self._basis_gates)
+
+        for node in dag.op_nodes():
+            if isinstance(node.op, ControlFlowOp):
+                dag.substitute_node(
+                    node,
+                    control_flow.map_blocks(self.run, node.op),
+                )
+                continue
+
+            if getattr(node.op, "_directive", False):
+                continue
+
+            if len(node.qargs) < self._min_qubits:
+                continue
+
+            controlled_gate_open_ctrl = isinstance(node.op, ControlledGate) and node.op._open_ctrl
+            if not controlled_gate_open_ctrl:
+                if self._target is not None:
+                    inst_supported = self._target.instruction_supported(
+                        operation_name=node.op.name,
+                        qargs=tuple(dag.find_bit(x).index for x in node.qargs),
+                    )
+                else:
+                    inst_supported = node.name in device_insts
+
+                if inst_supported or self._equiv_lib.has_entry(node.op):
+                    continue
+            try:
+                unrolled = getattr(node.op, "definition", None)
+            except TypeError as err:
+                raise QiskitError(f"Error decomposing node {node.name}: {err}") from err
+
+            if unrolled is None:
+                # opaque node
+                raise QiskitError(
+                    f"Cannot unroll the circuit to the given basis, {str(self._basis_gates)}. "
+                    f"Instruction {node.op.name} not found in equivalence library "
+                    "and no rule found to expand."
+                )
+
+            decomposition = circuit_to_dag(unrolled, copy_operations=False)
+            unrolled_dag = self.run(decomposition)
+            dag.substitute_node_with_dag(node, unrolled_dag)
+
+        return dag

qiskit/transpiler/passes/layout/__init__.py

@@ -0,0 +1,26 @@
+# 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 layout passes."""
+
+from .set_layout import SetLayout
+from .trivial_layout import TrivialLayout
+from .dense_layout import DenseLayout
+from .sabre_layout import SabreLayout
+from .csp_layout import CSPLayout
+from .vf2_layout import VF2Layout
+from .vf2_post_layout import VF2PostLayout
+from .apply_layout import ApplyLayout
+from .layout_2q_distance import Layout2qDistance
+from .enlarge_with_ancilla import EnlargeWithAncilla
+from .full_ancilla_allocation import FullAncillaAllocation
+from .sabre_pre_layout import SabrePreLayout