Make VF2Layout pass Target aware

qiskit/transpiler/passes/layout/vf2_layout.py

@@ -20,6 +20,7 @@
 
 from qiskit.transpiler.layout import Layout
 from qiskit.transpiler.basepasses import AnalysisPass
+from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.providers.exceptions import BackendPropertyError
 
 
@@ -54,13 +55,14 @@ class VF2Layout(AnalysisPass):
 
     def __init__(
         self,
-        coupling_map,
+        coupling_map=None,
         strict_direction=False,
         seed=None,
         call_limit=None,
         time_limit=None,
         properties=None,
         max_trials=None,
+        target=None,
     ):
         """Initialize a ``VF2Layout`` pass instance
 
@@ -80,18 +82,31 @@ def __init__(
                 based on the number of edges in the interaction graph or the coupling graph
                 (whichever is larger). If set to a value <= 0 no limit on the number of trials
                 will be set.
+            target (Target): A target representing the backend device to run ``VF2Layout`` on.
+                If specified it will supersede a set value for ``properties`` and
+                ``coupling_map``.
+
+        Raises:
+            TypeError: At runtime, if neither ``coupling_map`` or ``target`` are provided.
         """
         super().__init__()
-        self.coupling_map = coupling_map
+        self.target = target
+        if target is not None:
+            self.coupling_map = self.target.build_coupling_map()
+        else:
+            self.coupling_map = coupling_map
+        self.properties = properties
         self.strict_direction = strict_direction
         self.seed = seed
         self.call_limit = call_limit
         self.time_limit = time_limit
-        self.properties = properties
         self.max_trials = max_trials
 
     def run(self, dag):
         """run the layout method"""
+        if self.coupling_map is None:
+            raise TranspilerError("coupling_map or target must be specified.")
+
         qubits = dag.qubits
         qubit_indices = {qubit: index for index, qubit in enumerate(qubits)}
 
@@ -197,20 +212,32 @@ def _score_layout(self, layout):
         to weight against higher connectivity qubits."""
         bits = layout.get_physical_bits()
         score = 0
-        if self.properties is None:
-            # Sum qubit degree for each qubit in chosen layout as really rough estimate of error
+        if self.target is not None and "measure" in self.target:
+                for bit in bits:
+                    props = self.target["measure"].get((bit,))
+                    if props is None or props.error is None:
+                        score += (
+                            self.coupling_map.graph.out_degree(bit)
+                            + self.coupling_map.graph.in_degree(bit)
+                        ) / len(self.coupling_map.graph)
+                    else:
+                        score += props.error
+        else:
+            if self.properties is None:
+                # Sum qubit degree for each qubit in chosen layout as really rough estimate of error
+                for bit in bits:
+                    score += self.coupling_map.graph.out_degree(
+                        bit
+                    ) + self.coupling_map.graph.in_degree(bit)
+                return score
             for bit in bits:
-                score += self.coupling_map.graph.out_degree(
-                    bit
-                ) + self.coupling_map.graph.in_degree(bit)
-            return score
-        for bit in bits:
-            try:
-                score += self.properties.readout_error(bit)
-            # If readout error can't be found in properties fallback to degree
-            # divided by number of qubits as a terrible approximation
-            except BackendPropertyError:
-                score += (
-                    self.coupling_map.graph.out_degree(bit) + self.coupling_map.graph.in_degree(bit)
-                ) / len(self.coupling_map.graph)
+                try:
+                    score += self.properties.readout_error(bit)
+                # If readout error can't be found in properties fallback to degree
+                # divided by number of qubits as a terrible approximation
+                except BackendPropertyError:
+                    score += (
+                        self.coupling_map.graph.out_degree(bit)
+                        + self.coupling_map.graph.in_degree(bit)
+                    ) / len(self.coupling_map.graph)
         return score

qiskit/transpiler/preset_passmanagers/level1.py

@@ -156,6 +156,7 @@ def _vf2_match_not_found(property_set):
             call_limit=int(5e4),  # Set call limit to ~100ms with retworkx 0.10.2
             time_limit=0.1,
             properties=backend_properties,
+            target=target,
         )
     )
 

qiskit/transpiler/preset_passmanagers/level2.py

@@ -154,6 +154,7 @@ def _vf2_match_not_found(property_set):
             call_limit=int(5e6),  # Set call limit to ~10 sec with retworkx 0.10.2
             time_limit=10.0,
             properties=backend_properties,
+            target=target,
         )
     )
 

qiskit/transpiler/preset_passmanagers/level3.py

@@ -157,6 +157,7 @@ def _vf2_match_not_found(property_set):
             call_limit=int(3e7),  # Set call limit to ~60 sec with retworkx 0.10.2
             time_limit=60,
             properties=backend_properties,
+            target=target,
         )
     )
     # 2b. if VF2 didn't converge on a solution use layout_method (dense).

releasenotes/notes/vf2layout-target-51cc8f77fdfcde67.yaml

@@ -0,0 +1,9 @@
+---
+features:
+  - |
+    The :class:`~.VF2Layout` transpiler pass has a new keyword argument,
+    ``target`` which is used to provide a :class:`~.Target` object for
+    the pass. When specified, the :class:`~.Target` will be used by the
+    pass for all information about the target device. If it is specified,
+    the ``target`` option will take priority over the ``coupling_map`` and
+    ``properties`` arguments.

test/python/transpiler/test_vf2_layout.py

@@ -17,12 +17,12 @@
 import retworkx
 
 from qiskit import QuantumRegister, QuantumCircuit
-from qiskit.transpiler import CouplingMap, Layout
+from qiskit.transpiler import CouplingMap, Layout, Target, TranspilerError
 from qiskit.transpiler.passes.layout.vf2_layout import VF2Layout, VF2LayoutStopReason
 from qiskit.converters import circuit_to_dag
 from qiskit.test import QiskitTestCase
 from qiskit.test.mock import FakeTenerife, FakeRueschlikon, FakeManhattan, FakeYorktown
-from qiskit.circuit.library import GraphState
+from qiskit.circuit.library import GraphState, CXGate
 
 
 class LayoutTestCase(QiskitTestCase):
@@ -119,6 +119,29 @@ def test_call_limit(self):
             pass_.property_set["VF2Layout_stop_reason"], VF2LayoutStopReason.NO_SOLUTION_FOUND
         )
 
+    def test_coupling_map_and_target(self):
+        """Test that a Target is used instead of a CouplingMap if both are specified."""
+        cmap = CouplingMap([[0, 1], [1, 2]])
+        target = Target()
+        target.add_instruction(CXGate(), {(0, 1): None, (1, 2): None, (1, 0): None})
+        qr = QuantumRegister(3, "qr")
+        circuit = QuantumCircuit(qr)
+        circuit.cx(qr[0], qr[1])  # qr0-> qr1
+        circuit.cx(qr[1], qr[2])  # qr1-> qr2
+        circuit.cx(qr[1], qr[0])  # qr1-> qr0
+        dag = circuit_to_dag(circuit)
+        pass_ = VF2Layout(cmap, seed=-1, max_trials=1, target=target)
+        pass_.run(dag)
+        self.assertLayout(dag, target.build_coupling_map(), pass_.property_set)
+
+    def test_neither_coupling_map_or_target(self):
+        """Test that we raise if neither a target or coupling map is specified."""
+        vf2_pass = VF2Layout(seed=123, call_limit=1000, time_limit=20, max_trials=7)
+        circuit = QuantumCircuit(2)
+        dag = circuit_to_dag(circuit)
+        with self.assertRaises(TranspilerError):
+            vf2_pass.run(dag)
+
 
 class TestVF2LayoutLattice(LayoutTestCase):
     """Fit in 25x25 hexagonal lattice coupling map"""