nonuniform cost of physical swaps in sabre

crates/accelerate/src/sabre_swap/mod.rs

@@ -556,6 +556,7 @@ fn choose_best_swap(
         } else if (score - min_score).abs() < BEST_EPSILON {
             best_swaps.push(swap);
         }
+        //println!("swap: {}-{}: {}", swap[0], swap[1], score);
     }
     *best_swaps.choose(rng).unwrap()
 }

qiskit/transpiler/coupling.py

@@ -254,9 +254,10 @@ def make_symmetric(self):
         # 0.13.0 is released.
         edges = self.get_edges()
         edge_set = set(edges)
-        for src, dest in edges:
+        for i in range(len(edge_set)):
+            src, dest, weight = self.graph.edge_index_map()[i]
             if (dest, src) not in edge_set:
-                self.graph.add_edge(dest, src, None)
+                self.graph.add_edge(dest, src, weight)
         self._dist_matrix = None  # invalidate
         self._is_symmetric = None  # invalidate
 

qiskit/transpiler/passes/layout/csp_layout.py

@@ -21,14 +21,20 @@
 from qiskit.transpiler.basepasses import AnalysisPass
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.utils import optionals as _optionals
+from qiskit.transpiler.target import Target
 
 
 @_optionals.HAS_CONSTRAINT.require_in_instance
 class CSPLayout(AnalysisPass):
     """If possible, chooses a Layout as a CSP, using backtracking."""
 
     def __init__(
-        self, coupling_map, strict_direction=False, seed=None, call_limit=1000, time_limit=10
+        self,
+        coupling_map,
+        strict_direction=False,
+        seed=None,
+        call_limit=1000,
+        time_limit=10,
     ):
         """If possible, chooses a Layout as a CSP, using backtracking.
 
@@ -42,7 +48,7 @@ def __init__(
         * time limit reached: If no perfect layout was found and the time limit was reached.
 
         Args:
-            coupling_map (Coupling): Directed graph representing a coupling map.
+            coupling_map (Union[CouplingMap, Target]): Directed graph representing a coupling map.
             strict_direction (bool): If True, considers the direction of the coupling map.
                                      Default is False.
             seed (int): Sets the seed of the PRNG.
@@ -53,7 +59,13 @@ def __init__(
                 None means no time limit. Default: 10 seconds.
         """
         super().__init__()
-        self.coupling_map = coupling_map
+        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.strict_direction = strict_direction
         self.call_limit = call_limit
         self.time_limit = time_limit

qiskit/transpiler/passes/layout/full_ancilla_allocation.py

@@ -15,6 +15,7 @@
 from qiskit.circuit import QuantumRegister
 from qiskit.transpiler.basepasses import AnalysisPass
 from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.transpiler.target import Target
 
 
 class FullAncillaAllocation(AnalysisPass):
@@ -35,10 +36,15 @@ def __init__(self, coupling_map):
         """FullAncillaAllocation initializer.
 
         Args:
-            coupling_map (Coupling): directed graph representing a coupling map.
+            coupling_map (Union[CouplingMap, Target]): directed graph representing a coupling map.
         """
         super().__init__()
-        self.coupling_map = coupling_map
+        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.ancilla_name = "ancilla"
 
     def run(self, dag):

qiskit/transpiler/passes/layout/layout_2q_distance.py

@@ -19,6 +19,7 @@
 """
 
 from qiskit.transpiler.basepasses import AnalysisPass
+from qiskit.transpiler.target import Target
 
 
 class Layout2qDistance(AnalysisPass):
@@ -34,11 +35,16 @@ def __init__(self, coupling_map, property_name="layout_score"):
         """Layout2qDistance initializer.
 
         Args:
-            coupling_map (CouplingMap): Directed graph represented a coupling map.
+            coupling_map (Union[CouplingMap, Target]): Directed graph represented a coupling map.
             property_name (str): The property name to save the score. Default: layout_score
         """
         super().__init__()
-        self.coupling_map = coupling_map
+        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.property_name = property_name
 
     def run(self, dag):

qiskit/transpiler/passes/layout/noise_adaptive_layout.py

@@ -19,6 +19,7 @@
 from qiskit.transpiler.layout import Layout
 from qiskit.transpiler.basepasses import AnalysisPass
 from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.transpiler.target import target_to_backend_properties, Target
 
 
 class NoiseAdaptiveLayout(AnalysisPass):
@@ -58,13 +59,18 @@ def __init__(self, backend_prop):
         """NoiseAdaptiveLayout initializer.
 
         Args:
-            backend_prop (BackendProperties): backend properties object
+            backend_prop (Union[BackendProperties, Target]): backend properties object
 
         Raises:
             TranspilerError: if invalid options
         """
         super().__init__()
-        self.backend_prop = backend_prop
+        if isinstance(backend_prop, Target):
+            self.target = backend_prop
+            self.backend_prop = target_to_backend_properties(self.target)
+        else:
+            self.target = None
+            self.backend_prop = backend_prop
         self.swap_graph = rx.PyDiGraph()
         self.cx_reliability = {}
         self.readout_reliability = {}

qiskit/transpiler/passes/layout/sabre_layout.py

@@ -34,6 +34,8 @@
     NeighborTable,
 )
 from qiskit.transpiler.passes.routing.sabre_swap import process_swaps, apply_gate
+from qiskit.transpiler.target import Target
+from qiskit.quantum_info.synthesis.two_qubit_decompose import TwoQubitWeylDecomposition
 from qiskit.tools.parallel import CPU_COUNT
 
 logger = logging.getLogger(__name__)
@@ -86,7 +88,7 @@ def __init__(
         """SabreLayout initializer.
 
         Args:
-            coupling_map (Coupling): directed graph representing a coupling map.
+            coupling_map (Union[CouplingMap, Target]): directed graph representing a coupling map.
             routing_pass (BasePass): the routing pass to use while iterating.
                 If specified this pass operates as an :class:`~.AnalysisPass` and
                 will only populate the ``layout`` field in the property set and
@@ -124,17 +126,13 @@ def __init__(
             both ``routing_pass`` and ``layout_trials`` are specified
         """
         super().__init__()
-        self.coupling_map = coupling_map
+        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._neighbor_table = None
-        if self.coupling_map is not None:
-            if not self.coupling_map.is_symmetric:
-                # deepcopy is needed here to avoid modifications updating
-                # shared references in passes which require directional
-                # constraints
-                self.coupling_map = copy.deepcopy(self.coupling_map)
-                self.coupling_map.make_symmetric()
-            self._neighbor_table = NeighborTable(rx.adjacency_matrix(self.coupling_map.graph))
-
         if routing_pass is not None and (swap_trials is not None or layout_trials is not None):
             raise TranspilerError("Both routing_pass and swap_trials can't be set at the same time")
         self.routing_pass = routing_pass
@@ -150,6 +148,14 @@ def __init__(
         else:
             self.layout_trials = layout_trials
         self.skip_routing = skip_routing
+        if self.coupling_map is not None:
+            if not self.coupling_map.is_symmetric:
+                # deepcopy is needed here to avoid modifications updating
+                # shared references in passes which require directional
+                # constraints
+                self.coupling_map = copy.deepcopy(self.coupling_map)
+                self.coupling_map.make_symmetric()
+            self._neighbor_table = NeighborTable(rx.adjacency_matrix(self.coupling_map.graph))
 
     def run(self, dag):
         """Run the SabreLayout pass on `dag`.
@@ -210,7 +216,18 @@ def run(self, dag):
             self.property_set["layout"] = initial_layout
             self.routing_pass.fake_run = False
             return dag
+
         dist_matrix = self.coupling_map.distance_matrix
+        print('original distance matrix')
+        print(dist_matrix)
+
+        if self.target:
+            dist_matrix = rx.digraph_floyd_warshall_numpy(
+                self.coupling_map.graph, weight_fn=lambda x: self._swap_cost(x)
+            )
+        print('new distance matrix')
+        print(dist_matrix)
+
         original_qubit_indices = {bit: index for index, bit in enumerate(dag.qubits)}
         original_clbit_indices = {bit: index for index, bit in enumerate(dag.clbits)}
 
@@ -322,3 +339,38 @@ def _compose_layouts(self, initial_layout, pass_final_layout, qregs):
         qubit_map = Layout.combine_into_edge_map(initial_layout, trivial_layout)
         final_layout = {v: pass_final_layout._v2p[qubit_map[v]] for v in initial_layout._v2p}
         return Layout(final_layout)
+
+    def _swap_cost(self, instructions):
+        """Get the minimum cost of a SWAP on a pair of physical qubits given a list
+        of available instructions on those qubits.
+
+        TODO: this function only considers certain known basis for which Qiskit knows
+        analytical decompositions. This can be generalized to arbitrary basis using the
+        tools of monodromy polytopes.
+
+        Args:
+            instructions (list[dict]): mappings of gate name to properties for that gate.
+
+        Return:
+            float: minimum cost of performing SWAP using the available physical instructions.
+        """
+        swap_cost = np.inf
+        for key, value in instructions.items():
+            weyl = TwoQubitWeylDecomposition(self.target.operation_from_name(key))
+            a, b, c = weyl.a, weyl.b, weyl.c
+            if a == b == c == np.pi / 4:  # 1 x SWAP
+                gates_per_swap = 1
+            elif b == c == 0:  # k x controlled XX(theta)
+                gates_per_swap = 3 * (np.pi / 2 / (2 * a))
+            elif a == np.pi / 4 and c == 0:  # 3 x supercontrolled
+                gates_per_swap = 3
+            elif a == b == abs(c) == np.pi / 8:  # 2 x sqrt(SWAP)
+                gates_per_swap = 2
+            elif a == b == np.pi / 8 and c == 0:  # 2 x sqrt(iSWAP)
+                gates_per_swap = 3
+            elif (a, b, c) == (np.pi / 4, np.pi / 8, 0):  # 2 x B
+                gates_per_swap = 2
+
+            if gates_per_swap * value.error < swap_cost:
+                swap_cost = gates_per_swap * value.error
+        return swap_cost

qiskit/transpiler/passes/layout/trivial_layout.py

@@ -15,6 +15,7 @@
 from qiskit.transpiler.layout import Layout
 from qiskit.transpiler.basepasses import AnalysisPass
 from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.transpiler.target import Target
 
 
 class TrivialLayout(AnalysisPass):
@@ -33,13 +34,18 @@ def __init__(self, coupling_map):
         """TrivialLayout initializer.
 
         Args:
-            coupling_map (Coupling): directed graph representing a coupling map.
+            coupling_map (Union[CouplingMap, Target]): directed graph representing a coupling map.
 
         Raises:
             TranspilerError: if invalid options
         """
         super().__init__()
-        self.coupling_map = coupling_map
+        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
 
     def run(self, dag):
         """Run the TrivialLayout pass on `dag`.
@@ -48,15 +54,18 @@ def run(self, dag):
             dag (DAGCircuit): DAG to find layout for.
 
         Raises:
-            TranspilerError: if dag wider than self.coupling_map
+            TranspilerError: if dag wider than the target backend
         """
+        if self.target is not None:
+            if dag.num_qubits() > self.target.num_qubits:
+                raise TranspilerError("Number of qubits greater than device.")
+        elif dag.num_qubits() > self.coupling_map.size():
+            raise TranspilerError("Number of qubits greater than device.")
         if not self.coupling_map.is_connected():
             raise TranspilerError(
                 "Coupling Map is disjoint, this pass can't be used with a disconnected coupling "
                 "map."
             )
-        if dag.num_qubits() > self.coupling_map.size():
-            raise TranspilerError("Number of qubits greater than device.")
         self.property_set["layout"] = Layout.generate_trivial_layout(
             *(dag.qubits + list(dag.qregs.values()))
         )

qiskit/transpiler/passes/routing/basic_swap.py

@@ -17,6 +17,7 @@
 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
 
 
 class BasicSwap(TransformationPass):
@@ -31,12 +32,17 @@ def __init__(self, coupling_map, fake_run=False):
         """BasicSwap initializer.
 
         Args:
-            coupling_map (CouplingMap): Directed graph represented a coupling map.
+            coupling_map (Union[CouplingMap, Target]): Directed graph represented a coupling map.
             fake_run (bool): if true, it only pretend to do routing, i.e., no
                 swap is effectively added.
         """
         super().__init__()
-        self.coupling_map = coupling_map
+        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):

qiskit/transpiler/passes/routing/bip_mapping.py

@@ -22,6 +22,7 @@
 from qiskit.transpiler import TransformationPass
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.transpiler.passes.routing.algorithms.bip_model import BIPMappingModel
+from qiskit.transpiler.target import target_to_backend_properties, Target
 
 logger = logging.getLogger(__name__)
 
@@ -77,7 +78,7 @@ def __init__(
         """BIPMapping initializer.
 
         Args:
-            coupling_map (CouplingMap): Directed graph represented a coupling map.
+            coupling_map (Union[CouplingMap, Target]): Directed graph represented a coupling map.
             qubit_subset (list[int]): Sublist of physical qubits to be used in the mapping.
                 If None, all qubits in the coupling_map will be considered.
             objective (str): Type of objective function to be minimized:
@@ -112,17 +113,25 @@ def __init__(
             TranspilerError: if invalid options are specified.
         """
         super().__init__()
-        self.coupling_map = coupling_map
+        if isinstance(coupling_map, Target):
+            self.target = coupling_map
+            self.coupling_map = self.target.build_coupling_map()
+            self.backend_prop = target_to_backend_properties(self.target)
+        else:
+            self.target = None
+            self.coupling_map = coupling_map
+            self.backend_prop = None
         self.qubit_subset = qubit_subset
-        if self.coupling_map is not None and self.qubit_subset is None:
-            self.qubit_subset = list(range(self.coupling_map.size()))
         self.objective = objective
-        self.backend_prop = backend_prop
+        if backend_prop is not None:
+            self.backend_prop = backend_prop
         self.time_limit = time_limit
         self.threads = threads
         self.max_swaps_inbetween_layers = max_swaps_inbetween_layers
         self.depth_obj_weight = depth_obj_weight
         self.default_cx_error_rate = default_cx_error_rate
+        if self.coupling_map is not None and self.qubit_subset is None:
+            self.qubit_subset = list(range(self.coupling_map.size()))
 
     def run(self, dag):
         """Run the BIPMapping pass on `dag`, assuming the number of virtual qubits (defined in