Make all Layout and Routing passes target aware

qiskit/transpiler/passes/layout/csp_layout.py

@@ -27,7 +27,13 @@ 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=None,
+        strict_direction=False,
+        seed=None,
+        call_limit=1000,
+        time_limit=10,
+        target=None,
     ):
         """If possible, chooses a Layout as a CSP, using backtracking.
 
@@ -50,13 +56,19 @@ def __init__(
                 None means no call limit. Default: 1000.
             time_limit (int): Amount of seconds that the pass will try to find a solution.
                 None means no time limit. Default: 10 seconds.
+            target (Target): A target representing the target backend, if both
+                ``coupling_map`` and this are specified then this argument will take
+                precedence and ``coupling_map`` will be ignored.
         """
         super().__init__()
         self.coupling_map = coupling_map
         self.strict_direction = strict_direction
         self.call_limit = call_limit
         self.time_limit = time_limit
         self.seed = seed
+        self.target = target
+        if self.target is not None:
+            self.coupling_map = self.target.build_coupling_map()
 
     def run(self, dag):
         """run the layout method"""

qiskit/transpiler/passes/layout/full_ancilla_allocation.py

@@ -31,15 +31,21 @@ class FullAncillaAllocation(AnalysisPass):
         circuit.
     """
 
-    def __init__(self, coupling_map):
-        """FullAncillaAllocation initializer.
+    def __init__(self, coupling_map=None, target=None):
+        """FullAncillaAllocation initializer.<F12>
 
         Args:
             coupling_map (Coupling): directed graph representing a coupling map.
+            target (Target): A target representing the target backend, if both
+                ``coupling_map`` and this are specified then this argument will take
+                precedence and ``coupling_map`` will be ignored.
         """
         super().__init__()
         self.coupling_map = coupling_map
         self.ancilla_name = "ancilla"
+        self.target = target
+        if self.target is not None:
+            self.coupling_map = self.target.build_coupling_map()
 
     def run(self, dag):
         """Run the FullAncillaAllocation pass on `dag`.

qiskit/transpiler/passes/layout/layout_2q_distance.py

@@ -30,16 +30,23 @@ class Layout2qDistance(AnalysisPass):
     No CX direction is considered.
     """
 
-    def __init__(self, coupling_map, property_name="layout_score"):
+    def __init__(self, coupling_map=None, property_name="layout_score", target=None):
         """Layout2qDistance initializer.
 
         Args:
             coupling_map (CouplingMap): Directed graph represented a coupling map.
             property_name (str): The property name to save the score. Default: layout_score
+            target (Target): A target representing the target backend, if both
+                ``coupling_map`` and this are specified then this argument will take
+                precedence and ``coupling_map`` will be ignored.
+
         """
         super().__init__()
         self.coupling_map = coupling_map
         self.property_name = property_name
+        self.target = target
+        if self.target is not None:
+            self.coupling_map = self.target.build_coupling_map()
 
     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
 
 
 class NoiseAdaptiveLayout(AnalysisPass):
@@ -54,11 +55,14 @@ class NoiseAdaptiveLayout(AnalysisPass):
          by being set in `property_set`.
     """
 
-    def __init__(self, backend_prop):
+    def __init__(self, backend_prop=None, target=None):
         """NoiseAdaptiveLayout initializer.
 
         Args:
             backend_prop (BackendProperties): backend properties object
+            target (Target): A target representing the target backend, if both
+                ``backend_prop`` and this are specified then this argument will take
+                precedence and ``coupling_map`` will be ignored.
 
         Raises:
             TranspilerError: if invalid options
@@ -77,6 +81,9 @@ def __init__(self, backend_prop):
         self.qarg_to_id = {}
         self.pending_program_edges = []
         self.prog2hw = {}
+        self.target = target
+        if self.target is not None:
+            self.backend_prop = target_to_backend_properties(self.target)
 
     def _initialize_backend_prop(self):
         """Extract readout and CNOT errors and compute swap costs."""

qiskit/transpiler/passes/layout/sabre_layout.py

@@ -80,6 +80,7 @@ def __init__(
         seed=None,
         max_iterations=3,
         swap_trials=None,
+        target=None,
         layout_trials=None,
         skip_routing=False,
     ):
@@ -106,6 +107,9 @@ def __init__(
                 on the number of trials run. This option is mutually exclusive
                 with the ``routing_pass`` argument and an error will be raised
                 if both are used.
+            target (Target): A target representing the target backend, if both
+                ``coupling_map`` and this are specified then this argument will take
+                precedence and ``coupling_map`` will be ignored.
             layout_trials (int): The number of random seed trials to run
                 layout with. When > 1 the trial that resuls in the output with
                 the fewest swap gates will be selected. If this is not specified
@@ -126,21 +130,15 @@ def __init__(
         super().__init__()
         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
         self.seed = seed
         self.max_iterations = max_iterations
         self.trials = swap_trials
+        self.target = target
+        if self.target is not None:
+            self.coupling_map = self.target.build_coupling_map()
         if swap_trials is None:
             self.swap_trials = CPU_COUNT
         else:
@@ -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`.

qiskit/transpiler/passes/layout/trivial_layout.py

@@ -29,17 +29,21 @@ class TrivialLayout(AnalysisPass):
     Does not assume any ancilla.
     """
 
-    def __init__(self, coupling_map):
+    def __init__(self, coupling_map=None, target=None):
         """TrivialLayout initializer.
 
         Args:
             coupling_map (Coupling): directed graph representing a coupling map.
+            target (Target): A target representing the target backend, if both
+                ``coupling_map`` and this are specified then this argument will take
+                precedence and ``coupling_map`` will be ignored.
 
         Raises:
             TranspilerError: if invalid options
         """
         super().__init__()
         self.coupling_map = coupling_map
+        self.target = target
 
     def run(self, dag):
         """Run the TrivialLayout pass on `dag`.
@@ -48,10 +52,14 @@ 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 dag.num_qubits() > self.coupling_map.size():
-            raise TranspilerError("Number of qubits greater than device.")
+        if self.target is not None:
+            if dag.num_qubits() > self.target.num_qubits:
+                raise TranspilerError("Number of qubits greater than device.")
+        else:
+            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

@@ -27,17 +27,23 @@ class BasicSwap(TransformationPass):
     one or more swaps in front to make it compatible.
     """
 
-    def __init__(self, coupling_map, fake_run=False):
+    def __init__(self, coupling_map=None, fake_run=False, target=None):
         """BasicSwap initializer.
 
         Args:
             coupling_map (CouplingMap): Directed graph represented a coupling map.
             fake_run (bool): if true, it only pretend to do routing, i.e., no
                 swap is effectively added.
+            target (Target): A target representing the target backend, if both
+                ``coupling_map`` and this are specified then this argument will take
+                precedence and ``coupling_map`` will be ignored.
         """
         super().__init__()
         self.coupling_map = coupling_map
         self.fake_run = fake_run
+        self.target = target
+        if self.target is not None:
+            self.coupling_map = self.target.build_coupling_map()
 
     def run(self, dag):
         """Run the BasicSwap pass on `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
 
 logger = logging.getLogger(__name__)
 
@@ -64,7 +65,7 @@ class BIPMapping(TransformationPass):
 
     def __init__(
         self,
-        coupling_map,
+        coupling_map=None,
         qubit_subset=None,
         objective="balanced",
         backend_prop=None,
@@ -73,6 +74,7 @@ def __init__(
         max_swaps_inbetween_layers=None,
         depth_obj_weight=0.1,
         default_cx_error_rate=5e-3,
+        target=None,
     ):
         """BIPMapping initializer.
 
@@ -106,6 +108,9 @@ def __init__(
 
             default_cx_error_rate (float):
                 Default CX error rate to be used if backend_prop is not available.
+            target (Target): A target representing the target backend, if both
+                ``coupling_map`` or ``backend_prop`` and this are specified then this argument will take
+                precedence and the other argument will be ignored.
 
         Raises:
             MissingOptionalLibraryError: if cplex or docplex are not installed.
@@ -114,15 +119,20 @@ def __init__(
         super().__init__()
         self.coupling_map = coupling_map
         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
         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
+        self.target = target
+        if self.target is not None:
+            self.coupling_map = self.target.build_coupling_map()
+            self.backend_prop = target_to_backend_properties(self.target)
+
+        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

qiskit/transpiler/passes/routing/layout_transformation.py

@@ -35,6 +35,7 @@ def __init__(
         to_layout: Union[Layout, str],
         seed: Union[int, np.random.default_rng] = None,
         trials=4,
+        target=None,
     ):
         """LayoutTransformation initializer.
 
@@ -55,16 +56,20 @@ def __init__(
 
             trials (int):
                 How many randomized trials to perform, taking the best circuit as output.
+            target (Target): A target representing the target backend, if both
+                ``coupling_map`` and this are specified then this argument will take
+                precedence and the other argument will be ignored.
         """
         super().__init__()
         self.from_layout = from_layout
         self.to_layout = to_layout
-        if coupling_map:
-            self.coupling_map = coupling_map
-            graph = coupling_map.graph.to_undirected()
-        else:
+        self.coupling_map = coupling_map
+        self.target = target
+        if self.target is not None:
+            self.coupling_map = target.build_coupling_map()
+        if self.coupling_map is None:
             self.coupling_map = CouplingMap.from_full(len(to_layout))
-            graph = self.coupling_map.graph.to_undirected()
+        graph = self.coupling_map.graph.to_undirected()
         self.token_swapper = ApproximateTokenSwapper(graph, seed)
         self.trials = trials
 

qiskit/transpiler/passes/routing/lookahead_swap.py

@@ -81,7 +81,7 @@ class LookaheadSwap(TransformationPass):
     https://medium.com/qiskit/improving-a-quantum-compiler-48410d7a7084
     """
 
-    def __init__(self, coupling_map, search_depth=4, search_width=4, fake_run=False):
+    def __init__(self, coupling_map, search_depth=4, search_width=4, fake_run=False, target=None):
         """LookaheadSwap initializer.
 
         Args:
@@ -90,13 +90,19 @@ def __init__(self, coupling_map, search_depth=4, search_width=4, fake_run=False)
             search_width (int): lookahead tree width when ranking best SWAP options.
             fake_run (bool): if true, it only pretend to do routing, i.e., no
                 swap is effectively added.
+            target (Target): A target representing the target backend, if both
+                ``coupling_map`` and this are specified then this argument will take
+                precedence and the other argument will be ignored.
         """
 
         super().__init__()
         self.coupling_map = coupling_map
         self.search_depth = search_depth
         self.search_width = search_width
         self.fake_run = fake_run
+        self.target = target
+        if self.target is not None:
+            self.coupling_map = self.target.build_coupling_map()
 
     def run(self, dag):
         """Run the LookaheadSwap pass on `dag`.

qiskit/transpiler/passes/routing/sabre_swap.py

@@ -72,7 +72,9 @@ class SabreSwap(TransformationPass):
     `arXiv:1809.02573 <https://arxiv.org/pdf/1809.02573.pdf>`_
     """
 
-    def __init__(self, coupling_map, heuristic="basic", seed=None, fake_run=False, trials=None):
+    def __init__(
+        self, coupling_map, heuristic="basic", seed=None, fake_run=False, trials=None, target=None
+    ):
         r"""SabreSwap initializer.
 
         Args:
@@ -88,6 +90,9 @@ def __init__(self, coupling_map, heuristic="basic", seed=None, fake_run=False, t
                 CPUs on the local system. For reproducible results it is recommended
                 that you set this explicitly, as the output will be deterministic for
                 a fixed number of trials.
+            target (Target): A target representing the target backend, if both
+                ``coupling_map`` and this are specified then this argument will take
+                precedence and the other argument will be ignored.
 
         Raises:
             TranspilerError: If the specified heuristic is not valid.
@@ -139,9 +144,11 @@ def __init__(self, coupling_map, heuristic="basic", seed=None, fake_run=False, t
         super().__init__()
 
         # Assume bidirectional couplings, fixing gate direction is easy later.
-        if coupling_map is None or coupling_map.is_symmetric:
-            self.coupling_map = coupling_map
-        else:
+        self.coupling_map = coupling_map
+        self.target = target
+        if self.target is not None:
+            self.coupling_map = self.target.build_coupling_map()
+        if self.coupling_map is not None and not self.coupling_map.is_symmetric:
             # A deepcopy is needed here to avoid modifications updating
             # shared references in passes which require directional
             # constraints