qiskit 1.1.2__cp38-abi3-win32.whl → 1.2.0__cp38-abi3-win32.whl

qiskit/transpiler/passes/optimization/commutative_cancellation.py

@@ -16,16 +16,17 @@ from collections import defaultdict
 import numpy as np
 
 from qiskit.circuit.quantumregister import QuantumRegister
-from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.circuit.parameterexpression import ParameterExpression
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.passmanager import PassManager
 from qiskit.transpiler.passes.optimization.commutation_analysis import CommutationAnalysis
 from qiskit.dagcircuit import DAGCircuit, DAGInNode, DAGOutNode
+from qiskit.circuit.commutation_library import CommutationChecker, StandardGateCommutations
 from qiskit.circuit.library.standard_gates.u1 import U1Gate
 from qiskit.circuit.library.standard_gates.rx import RXGate
 from qiskit.circuit.library.standard_gates.p import PhaseGate
 from qiskit.circuit.library.standard_gates.rz import RZGate
-from qiskit.circuit import ControlFlowOp
+from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES
 
 
 _CUTOFF_PRECISION = 1e-5
@@ -62,7 +63,18 @@ class CommutativeCancellation(TransformationPass):
             self.basis = set(target.operation_names)
 
         self._var_z_map = {"rz": RZGate, "p": PhaseGate, "u1": U1Gate}
-        self.requires.append(CommutationAnalysis())
+
+        self._z_rotations = {"p", "z", "u1", "rz", "t", "s"}
+        self._x_rotations = {"x", "rx"}
+        self._gates = {"cx", "cy", "cz", "h", "y"}  # Now the gates supported are hard-coded
+
+        # build a commutation checker restricted to the gates we cancel -- the others we
+        # do not have to investigate, which allows to save time
+        commutation_checker = CommutationChecker(
+            StandardGateCommutations, gates=self._gates | self._z_rotations | self._x_rotations
+        )
+
+        self.requires.append(CommutationAnalysis(_commutation_checker=commutation_checker))
 
     def run(self, dag):
         """Run the CommutativeCancellation pass on `dag`.
@@ -72,23 +84,17 @@ class CommutativeCancellation(TransformationPass):
 
         Returns:
             DAGCircuit: the optimized DAG.
-
-        Raises:
-            TranspilerError: when the 1-qubit rotation gates are not found
         """
         var_z_gate = None
         z_var_gates = [gate for gate in dag.count_ops().keys() if gate in self._var_z_map]
         if z_var_gates:
-            # priortize z gates in circuit
+            # prioritize z gates in circuit
             var_z_gate = self._var_z_map[next(iter(z_var_gates))]
         else:
             z_var_gates = [gate for gate in self.basis if gate in self._var_z_map]
             if z_var_gates:
                 var_z_gate = self._var_z_map[next(iter(z_var_gates))]
 
-        # Now the gates supported are hard-coded
-        q_gate_list = ["cx", "cy", "cz", "h", "y"]
-
         # Gate sets to be cancelled
         cancellation_sets = defaultdict(lambda: [])
 
@@ -107,9 +113,11 @@ class CommutativeCancellation(TransformationPass):
                     continue
                 for node in com_set:
                     num_qargs = len(node.qargs)
-                    if num_qargs == 1 and node.name in q_gate_list:
+                    if any(isinstance(p, ParameterExpression) for p in node.params):
+                        continue  # no support for cancellation of parameterized gates
+                    if num_qargs == 1 and node.name in self._gates:
                         cancellation_sets[(node.name, wire, com_set_idx)].append(node)
-                    if num_qargs == 1 and node.name in ["p", "z", "u1", "rz", "t", "s"]:
+                    if num_qargs == 1 and node.name in self._z_rotations:
                         cancellation_sets[("z_rotation", wire, com_set_idx)].append(node)
                     if num_qargs == 1 and node.name in ["rx", "x"]:
                         cancellation_sets[("x_rotation", wire, com_set_idx)].append(node)
@@ -130,7 +138,7 @@ class CommutativeCancellation(TransformationPass):
             if cancel_set_key[0] == "z_rotation" and var_z_gate is None:
                 continue
             set_len = len(cancellation_sets[cancel_set_key])
-            if set_len > 1 and cancel_set_key[0] in q_gate_list:
+            if set_len > 1 and cancel_set_key[0] in self._gates:
                 gates_to_cancel = cancellation_sets[cancel_set_key]
                 for c_node in gates_to_cancel[: (set_len // 2) * 2]:
                     dag.remove_op_node(c_node)
@@ -142,31 +150,37 @@ class CommutativeCancellation(TransformationPass):
                 total_phase = 0.0
                 for current_node in run:
                     if (
-                        getattr(current_node.op, "condition", None) is not None
+                        current_node.condition is not None
                         or len(current_node.qargs) != 1
                         or current_node.qargs[0] != run_qarg
                     ):
-                        raise TranspilerError("internal error")
+                        raise RuntimeError("internal error")
 
                     if current_node.name in ["p", "u1", "rz", "rx"]:
-                        current_angle = float(current_node.op.params[0])
+                        current_angle = float(current_node.params[0])
                     elif current_node.name in ["z", "x"]:
                         current_angle = np.pi
                     elif current_node.name == "t":
                         current_angle = np.pi / 4
                     elif current_node.name == "s":
                         current_angle = np.pi / 2
+                    else:
+                        raise RuntimeError(
+                            f"Angle for operation {current_node.name } is not defined"
+                        )
 
                     # Compose gates
                     total_angle = current_angle + total_angle
-                    if current_node.op.definition:
-                        total_phase += current_node.op.definition.global_phase
+                    if current_node.definition:
+                        total_phase += current_node.definition.global_phase
 
                 # Replace the data of the first node in the run
                 if cancel_set_key[0] == "z_rotation":
                     new_op = var_z_gate(total_angle)
                 elif cancel_set_key[0] == "x_rotation":
                     new_op = RXGate(total_angle)
+                else:
+                    raise RuntimeError("impossible case")
 
                 new_op_phase = 0
                 if np.mod(total_angle, (2 * np.pi)) > _CUTOFF_PRECISION:
@@ -198,7 +212,9 @@ class CommutativeCancellation(TransformationPass):
         """
 
         pass_manager = PassManager([CommutationAnalysis(), self])
-        for node in dag.op_nodes(ControlFlowOp):
+        for node in dag.op_nodes():
+            if node.name not in CONTROL_FLOW_OP_NAMES:
+                continue
             mapped_blocks = []
             for block in node.op.blocks:
                 new_circ = pass_manager.run(block)

qiskit/transpiler/passes/optimization/consolidate_blocks.py

@@ -24,10 +24,12 @@ from qiskit.synthesis.two_qubit import TwoQubitBasisDecomposer
 from qiskit.circuit.library.generalized_gates.unitary import UnitaryGate
 from qiskit.circuit.library.standard_gates import CXGate
 from qiskit.transpiler.basepasses import TransformationPass
-from qiskit.circuit.controlflow import ControlFlowOp
 from qiskit.transpiler.passmanager import PassManager
 from qiskit.transpiler.passes.synthesis import unitary_synthesis
-from qiskit.transpiler.passes.utils import _block_to_matrix
+from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES
+from qiskit._accelerate.convert_2q_block_matrix import blocks_to_matrix
+from qiskit.exceptions import QiskitError
+
 from .collect_1q_runs import Collect1qRuns
 from .collect_2q_blocks import Collect2qBlocks
 
@@ -105,14 +107,14 @@ class ConsolidateBlocks(TransformationPass):
                 block_cargs = set()
                 for nd in block:
                     block_qargs |= set(nd.qargs)
-                    if isinstance(nd, DAGOpNode) and getattr(nd.op, "condition", None):
-                        block_cargs |= set(getattr(nd.op, "condition", None)[0])
+                    if isinstance(nd, DAGOpNode) and getattr(nd, "condition", None):
+                        block_cargs |= set(getattr(nd, "condition", None)[0])
                     all_block_gates.add(nd)
                 block_index_map = self._block_qargs_to_indices(dag, block_qargs)
                 for nd in block:
-                    if nd.op.name == basis_gate_name:
+                    if nd.name == basis_gate_name:
                         basis_count += 1
-                    if self._check_not_in_basis(dag, nd.op.name, nd.qargs):
+                    if self._check_not_in_basis(dag, nd.name, nd.qargs):
                         outside_basis = True
                 if len(block_qargs) > 2:
                     q = QuantumRegister(len(block_qargs))
@@ -124,7 +126,12 @@ class ConsolidateBlocks(TransformationPass):
                         qc.append(nd.op, [q[block_index_map[i]] for i in nd.qargs])
                     unitary = UnitaryGate(Operator(qc), check_input=False)
                 else:
-                    matrix = _block_to_matrix(block, block_index_map)
+                    try:
+                        matrix = blocks_to_matrix(block, block_index_map)
+                    except QiskitError:
+                        # If building a matrix for the block fails we should not consolidate it
+                        # because there is nothing we can do with it.
+                        continue
                     unitary = UnitaryGate(matrix, check_input=False)
 
                 max_2q_depth = 20  # If depth > 20, there will be 1q gates to consolidate.
@@ -192,7 +199,9 @@ class ConsolidateBlocks(TransformationPass):
             pass_manager.append(Collect2qBlocks())
 
         pass_manager.append(self)
-        for node in dag.op_nodes(ControlFlowOp):
+        for node in dag.op_nodes():
+            if node.name not in CONTROL_FLOW_OP_NAMES:
+                continue
             node.op = node.op.replace_blocks(pass_manager.run(block) for block in node.op.blocks)
         return dag
 

qiskit/transpiler/passes/optimization/inverse_cancellation.py

@@ -53,8 +53,8 @@ class InverseCancellation(TransformationPass):
                     )
             else:
                 raise TranspilerError(
-                    "InverseCancellation pass does not take input type {}. Input must be"
-                    " a Gate.".format(type(gates))
+                    f"InverseCancellation pass does not take input type {type(gates)}. Input must be"
+                    " a Gate."
                 )
 
         self.self_inverse_gates = []
@@ -112,15 +112,15 @@ class InverseCancellation(TransformationPass):
                 partitions = []
                 chunk = []
                 max_index = len(gate_cancel_run) - 1
-                for i in range(len(gate_cancel_run)):
-                    if gate_cancel_run[i].op == gate:
-                        chunk.append(gate_cancel_run[i])
+                for i, cancel_gate in enumerate(gate_cancel_run):
+                    if cancel_gate.op == gate:
+                        chunk.append(cancel_gate)
                     else:
                         if chunk:
                             partitions.append(chunk)
                             chunk = []
                         continue
-                    if i == max_index or gate_cancel_run[i].qargs != gate_cancel_run[i + 1].qargs:
+                    if i == max_index or cancel_gate.qargs != gate_cancel_run[i + 1].qargs:
                         partitions.append(chunk)
                         chunk = []
                 # Remove an even number of gates from each chunk

qiskit/transpiler/passes/optimization/optimize_1q_decomposition.py

@@ -33,6 +33,7 @@ from qiskit.circuit.library.standard_gates import (
     XGate,
 )
 from qiskit.circuit import Qubit
+from qiskit.circuit.quantumcircuitdata import CircuitInstruction
 from qiskit.dagcircuit.dagcircuit import DAGCircuit
 from qiskit.dagcircuit.dagnode import DAGOpNode
 
@@ -110,16 +111,7 @@ class Optimize1qGatesDecomposition(TransformationPass):
         else:
             return None
 
-    def _resynthesize_run(self, matrix, qubit=None):
-        """
-        Re-synthesizes one 2x2 `matrix`, typically extracted via `dag.collect_1q_runs`.
-
-        Returns the newly synthesized circuit in the indicated basis, or None
-        if no synthesis routine applied.
-
-        When multiple synthesis options are available, it prefers the one with the lowest
-        error when the circuit is applied to `qubit`.
-        """
+    def _get_decomposer(self, qubit=None):
         # include path for when target exists but target.num_qubits is None (BasicSimulator)
         if self._target is not None and self._target.num_qubits is not None:
             if qubit is not None:
@@ -133,6 +125,19 @@ class Optimize1qGatesDecomposition(TransformationPass):
                 decomposers = _possible_decomposers(available_1q_basis)
         else:
             decomposers = self._global_decomposers
+        return decomposers
+
+    def _resynthesize_run(self, matrix, qubit=None):
+        """
+        Re-synthesizes one 2x2 `matrix`, typically extracted via `dag.collect_1q_runs`.
+
+        Returns the newly synthesized circuit in the indicated basis, or None
+        if no synthesis routine applied.
+
+        When multiple synthesis options are available, it prefers the one with the lowest
+        error when the circuit is applied to `qubit`.
+        """
+        decomposers = self._get_decomposer(qubit)
 
         best_synth_circuit = euler_one_qubit_decomposer.unitary_to_gate_sequence(
             matrix,
@@ -149,10 +154,13 @@ class Optimize1qGatesDecomposition(TransformationPass):
         out_dag.global_phase = best_synth_circuit.global_phase
 
         for gate_name, angles in best_synth_circuit:
-            out_dag.apply_operation_back(NAME_MAP[gate_name](*angles), qubits, check=False)
+            op = CircuitInstruction.from_standard(gate_name, qubits, angles)
+            out_dag.apply_operation_back(op.operation, qubits, check=False)
         return out_dag
 
-    def _substitution_checks(self, dag, old_run, new_circ, basis, qubit):
+    def _substitution_checks(
+        self, dag, old_run, new_circ, basis, qubit, old_error=None, new_error=None
+    ):
         """
         Returns `True` when it is recommended to replace `old_run` with `new_circ` over `basis`.
         """
@@ -176,11 +184,14 @@ class Optimize1qGatesDecomposition(TransformationPass):
         # if we're outside of the basis set, we're obligated to logically decompose.
         # if we're outside of the set of gates for which we have physical definitions,
         #    then we _try_ to decompose, using the results if we see improvement.
-        new_error = 0.0
-        old_error = 0.0
         if not uncalibrated_and_not_basis_p:
-            new_error = self._error(new_circ, qubit)
-            old_error = self._error(old_run, qubit)
+            if new_error is None:
+                new_error = self._error(new_circ, qubit)
+            if old_error is None:
+                old_error = self._error(old_run, qubit)
+        else:
+            new_error = 0.0
+            old_error = 0.0
 
         return (
             uncalibrated_and_not_basis_p
@@ -198,32 +209,47 @@ class Optimize1qGatesDecomposition(TransformationPass):
         Returns:
             DAGCircuit: the optimized DAG.
         """
-        runs = dag.collect_1q_runs()
-        for run in runs:
+        runs = []
+        qubits = []
+        bases = []
+        for run in dag.collect_1q_runs():
             qubit = dag.find_bit(run[0].qargs[0]).index
-            operator = run[0].op.to_matrix()
-            for node in run[1:]:
-                operator = node.op.to_matrix().dot(operator)
-            best_circuit_sequence = self._resynthesize_run(operator, qubit)
-
+            runs.append(run)
+            qubits.append(qubit)
+            bases.append(self._get_decomposer(qubit))
+        best_sequences = euler_one_qubit_decomposer.optimize_1q_gates_decomposition(
+            runs, qubits, bases, simplify=True, error_map=self.error_map
+        )
+        for index, best_circuit_sequence in enumerate(best_sequences):
+            run = runs[index]
+            qubit = qubits[index]
             if self._target is None:
                 basis = self._basis_gates
             else:
                 basis = self._target.operation_names_for_qargs((qubit,))
-
-            if best_circuit_sequence is not None and self._substitution_checks(
-                dag, run, best_circuit_sequence, basis, qubit
-            ):
-                for gate_name, angles in best_circuit_sequence:
-                    op = NAME_MAP[gate_name](*angles)
-                    node = DAGOpNode(NAME_MAP[gate_name](*angles), run[0].qargs, dag=dag)
-                    node._node_id = dag._multi_graph.add_node(node)
-                    dag._increment_op(op)
-                    dag._multi_graph.insert_node_on_in_edges(node._node_id, run[0]._node_id)
-                dag.global_phase += best_circuit_sequence.global_phase
-                # Delete the other nodes in the run
-                for current_node in run:
-                    dag.remove_op_node(current_node)
+            if best_circuit_sequence is not None:
+                (old_error, new_error, best_circuit_sequence) = best_circuit_sequence
+                if self._substitution_checks(
+                    dag,
+                    run,
+                    best_circuit_sequence,
+                    basis,
+                    qubit,
+                    old_error=old_error,
+                    new_error=new_error,
+                ):
+                    first_node_id = run[0]._node_id
+                    qubit = run[0].qargs
+                    for gate, angles in best_circuit_sequence:
+                        op = CircuitInstruction.from_standard(gate, qubit, angles)
+                        node = DAGOpNode.from_instruction(op, dag=dag)
+                        node._node_id = dag._multi_graph.add_node(node)
+                        dag._increment_op(gate.name)
+                        dag._multi_graph.insert_node_on_in_edges(node._node_id, first_node_id)
+                    dag.global_phase += best_circuit_sequence.global_phase
+                    # Delete the other nodes in the run
+                    for current_node in run:
+                        dag.remove_op_node(current_node)
 
         return dag
 
@@ -241,10 +267,7 @@ class Optimize1qGatesDecomposition(TransformationPass):
                 circuit, qubit, self.error_map
             )
         else:
-            circuit_list = [(x.op.name, []) for x in circuit]
-            return euler_one_qubit_decomposer.compute_error_list(
-                circuit_list, qubit, self.error_map
-            )
+            return euler_one_qubit_decomposer.compute_error_list(circuit, qubit, self.error_map)
 
 
 def _possible_decomposers(basis_set):

qiskit/transpiler/passes/optimization/optimize_1q_gates.py

@@ -308,7 +308,7 @@ class Optimize1qGates(TransformationPass):
                 if "u3" in self.basis:
                     new_op = U3Gate(*right_parameters)
                 else:
-                    raise TranspilerError("It was not possible to use the basis %s" % self.basis)
+                    raise TranspilerError(f"It was not possible to use the basis {self.basis}")
 
             dag.global_phase += right_global_phase
 

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/passes/optimization/template_matching/backward_match.py

@@ -622,7 +622,7 @@ class BackwardMatch:
                     )
                     self.matching_list.append_scenario(new_matching_scenario)
 
-                # Third option: if blocking the succesors breaks a match, we consider
+                # Third option: if blocking the successors breaks a match, we consider
                 # also the possibility to block all predecessors (push the gate to the left).
                 if broken_matches and all(global_broken):
 

qiskit/transpiler/passes/optimization/template_matching/forward_match.py

@@ -138,8 +138,8 @@ class ForwardMatch:
         """
         matches = []
 
-        for i in range(0, len(self.match)):
-            matches.append(self.match[i][0])
+        for match in self.match:
+            matches.append(match[0])
 
         pred = matches.copy()
         if len(pred) > 1:

qiskit/transpiler/passes/optimization/template_matching/template_substitution.py

@@ -507,7 +507,7 @@ class TemplateSubstitution:
             to_native_symbolic = lambda x: x
 
         circuit_params, template_params = [], []
-        # Set of all parameter names that are present in the circuits to be optimised.
+        # Set of all parameter names that are present in the circuits to be optimized.
         circuit_params_set = set()
 
         template_dag_dep = copy.deepcopy(self.template_dag_dep)

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

@@ -17,8 +17,9 @@ from collections import defaultdict
 from qiskit.circuit import Gate, QuantumCircuit, Qubit
 from qiskit.converters import circuit_to_dag
 from qiskit.dagcircuit import DAGCircuit, DAGOpNode
-from qiskit.transpiler import TransformationPass, Layout, TranspilerError
-
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.transpiler.layout import Layout
 from qiskit.transpiler.passes.routing.commuting_2q_gate_routing.swap_strategy import SwapStrategy
 from qiskit.transpiler.passes.routing.commuting_2q_gate_routing.commuting_2q_block import (
     Commuting2qBlock,

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

@@ -17,7 +17,7 @@ import copy
 import numpy as np
 
 from qiskit.exceptions import QiskitError
-from qiskit.transpiler import CouplingMap
+from qiskit.transpiler.coupling import CouplingMap
 
 
 class SwapStrategy:

qiskit/transpiler/passes/routing/layout_transformation.py

@@ -15,9 +15,10 @@ from __future__ import annotations
 
 import numpy as np
 
-from qiskit.transpiler import Layout, CouplingMap
 from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.coupling import CouplingMap
 from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.transpiler.layout import Layout
 from qiskit.transpiler.passes.routing.algorithms import ApproximateTokenSwapper
 from qiskit.transpiler.target import Target