Update transpiler pipeline to (only) use target internally (#12850)

* First attempt at supporting a virtual target (FakeTarget) with no basis gates in the preset pass managers.

* Remove prints

* Fix control-flow failures with fake target

* Fix init stage, add instruction_supported method to FakeTarget

* Tweak preset pass manager

* Handle inst_map deprecation warning

* Handle annotated operations

* Do not skip stages with FakeTarget

* Deprecate custom basis gates

* Cleanup

* Remove reno

* Refactor creation of _FakeTarget, add tests

* Fix handling of pre-optimization stage and gate direction passes

* Restore cargo.lock

* Address most lint complaints

* Fix dt issue

* Address HLS issue

* Address GateDirection issue

* Fix lint and improve style

* Refactor plugin logic, handle target with no basis gates at the pass level (Python interface only) instead of pm level.

* Remove deprecated arguments: instruction_durations, timing_constrants and custom basis_gates.
Do not skip target unless dictated by backend. Add warning for backend + loose constraints and
raise error if basis_gates contains 3q+ gates with a coupling map, as this generates a conflic
in the model where it's not clear to which qubits the gates can apply. This is a limitation that
comes from Target.from_configuration, but it's more user-friendly to raise the error from
generate_preset_pass_manager.

* Apply suggestions from Eli's code review

Co-authored-by: Eli Arbel <46826214+eliarbel@users.noreply.github.com>

* Clean up

* Apply suggestions from Eli's code review. Add reno for API changes. Fix oversights

* Fix merge conflict

---------

Co-authored-by: Eli Arbel <46826214+eliarbel@users.noreply.github.com>

Author: ElePT

qiskit/compiler/transpiler.py

@@ -16,7 +16,6 @@
 import logging
 from time import time
 from typing import List, Union, Dict, Callable, Any, Optional, TypeVar
-import warnings
 
 from qiskit import user_config
 from qiskit.circuit.quantumcircuit import QuantumCircuit
@@ -25,35 +24,15 @@
 from qiskit.transpiler import Layout, CouplingMap, PropertySet
 from qiskit.transpiler.basepasses import BasePass
 from qiskit.transpiler.exceptions import TranspilerError, CircuitTooWideForTarget
-from qiskit.transpiler.instruction_durations import InstructionDurationsType
 from qiskit.transpiler.passes.synthesis.high_level_synthesis import HLSConfig
 from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
 from qiskit.transpiler.target import Target
-from qiskit.utils import deprecate_arg
 
 logger = logging.getLogger(__name__)
 
 _CircuitT = TypeVar("_CircuitT", bound=Union[QuantumCircuit, List[QuantumCircuit]])
 
 
-@deprecate_arg(
-    name="instruction_durations",
-    since="1.3",
-    package_name="Qiskit",
-    removal_timeline="in Qiskit 2.0",
-    additional_msg="The `target` parameter should be used instead. You can build a `Target` instance "
-    "with defined instruction durations with "
-    "`Target.from_configuration(..., instruction_durations=...)`",
-)
-@deprecate_arg(
-    name="timing_constraints",
-    since="1.3",
-    package_name="Qiskit",
-    removal_timeline="in Qiskit 2.0",
-    additional_msg="The `target` parameter should be used instead. You can build a `Target` instance "
-    "with defined timing constraints with "
-    "`Target.from_configuration(..., timing_constraints=...)`",
-)
 def transpile(  # pylint: disable=too-many-return-statements
     circuits: _CircuitT,
     backend: Optional[Backend] = None,
@@ -64,10 +43,8 @@ def transpile(  # pylint: disable=too-many-return-statements
     routing_method: Optional[str] = None,
     translation_method: Optional[str] = None,
     scheduling_method: Optional[str] = None,
-    instruction_durations: Optional[InstructionDurationsType] = None,
     dt: Optional[float] = None,
     approximation_degree: Optional[float] = 1.0,
-    timing_constraints: Optional[Dict[str, int]] = None,
     seed_transpiler: Optional[int] = None,
     optimization_level: Optional[int] = None,
     callback: Optional[Callable[[BasePass, DAGCircuit, float, PropertySet, int], Any]] = None,
@@ -90,8 +67,8 @@ def transpile(  # pylint: disable=too-many-return-statements
 
     The prioritization of transpilation target constraints works as follows: if a ``target``
     input is provided, it will take priority over any ``backend`` input or loose constraints
-    (``basis_gates``, ``coupling_map``, ``instruction_durations``,
-    ``dt`` or ``timing_constraints``). If a ``backend`` is provided together with any loose constraint
+    (``basis_gates``, ``coupling_map``, or ``dt``). If a ``backend`` is provided
+    together with any loose constraint
     from the list above, the loose constraint will take priority over the corresponding backend
     constraint. This behavior is summarized in the table below. The first column
     in the table summarizes the potential user-provided constraints, and each cell shows whether
@@ -103,9 +80,7 @@ def transpile(  # pylint: disable=too-many-return-statements
     ============================ ========= ========================
     **basis_gates**              target    basis_gates
     **coupling_map**             target    coupling_map
-    **instruction_durations**    target    instruction_durations
     **dt**                       target    dt
-    **timing_constraints**       target    timing_constraints
     ============================ ========= ========================
 
     Args:
@@ -176,40 +151,10 @@ def transpile(  # pylint: disable=too-many-return-statements
             to use for the ``scheduling`` stage. You can see a list of installed plugins by
             using :func:`~.list_stage_plugins` with ``"scheduling"`` for the ``stage_name``
             argument.
-        instruction_durations: Durations of instructions.
-            Applicable only if scheduling_method is specified.
-            The gate lengths defined in ``backend.properties`` are used as default.
-            They are overwritten if this ``instruction_durations`` is specified.
-            The format of ``instruction_durations`` must be as follows.
-            The `instruction_durations` must be given as a list of tuples
-            [(instruction_name, qubits, duration, unit), ...].
-            | [('cx', [0, 1], 12.3, 'ns'), ('u3', [0], 4.56, 'ns')]
-            | [('cx', [0, 1], 1000), ('u3', [0], 300)]
-            If unit is omitted, the default is 'dt', which is a sample time depending on backend.
-            If the time unit is 'dt', the duration must be an integer.
         dt: Backend sample time (resolution) in seconds.
             If ``None`` (default), ``backend.dt`` is used.
         approximation_degree (float): heuristic dial used for circuit approximation
             (1.0=no approximation, 0.0=maximal approximation)
-        timing_constraints: An optional control hardware restriction on instruction time resolution.
-            A quantum computer backend may report a set of restrictions, namely:
-
-            - granularity: An integer value representing minimum pulse gate
-              resolution in units of ``dt``. A user-defined pulse gate should have
-              duration of a multiple of this granularity value.
-            - min_length: An integer value representing minimum pulse gate
-              length in units of ``dt``. A user-defined pulse gate should be longer
-              than this length.
-            - pulse_alignment: An integer value representing a time resolution of gate
-              instruction starting time. Gate instruction should start at time which
-              is a multiple of the alignment value.
-            - acquire_alignment: An integer value representing a time resolution of measure
-              instruction starting time. Measure instruction should start at time which
-              is a multiple of the alignment value.
-
-            This information will be provided by the backend configuration.
-            If the backend doesn't have any restriction on the instruction time allocation,
-            then ``timing_constraints`` is None and no adjustment will be performed.
         seed_transpiler: Sets random seed for the stochastic parts of the transpiler
         optimization_level: How much optimization to perform on the circuits.
             Higher levels generate more optimized circuits,
@@ -308,18 +253,6 @@ def callback_func(**kwargs):
         config = user_config.get_config()
         optimization_level = config.get("transpile_optimization_level", 2)
 
-    if (
-        scheduling_method is not None
-        and backend is None
-        and target is None
-        and not instruction_durations
-    ):
-        warnings.warn(
-            "When scheduling circuits without backend,"
-            " 'instruction_durations' should be usually provided.",
-            UserWarning,
-        )
-
     if not ignore_backend_supplied_default_methods:
         if scheduling_method is None and hasattr(backend, "get_scheduling_stage_plugin"):
             scheduling_method = backend.get_scheduling_stage_plugin()
@@ -333,43 +266,27 @@ def callback_func(**kwargs):
     # Edge cases require using the old model (loose constraints) instead of building a target,
     # but we don't populate the passmanager config with loose constraints unless it's one of
     # the known edge cases to control the execution path.
-    # Filter instruction_durations and timing_constraints deprecation
-    with warnings.catch_warnings():
-        warnings.filterwarnings(
-            "ignore",
-            category=DeprecationWarning,
-            message=".*``timing_constraints`` is deprecated as of Qiskit 1.3.*",
-            module="qiskit",
-        )
-        warnings.filterwarnings(
-            "ignore",
-            category=DeprecationWarning,
-            message=".*``instruction_durations`` is deprecated as of Qiskit 1.3.*",
-            module="qiskit",
-        )
-        pm = generate_preset_pass_manager(
-            optimization_level,
-            target=target,
-            backend=backend,
-            basis_gates=basis_gates,
-            coupling_map=coupling_map,
-            instruction_durations=instruction_durations,
-            timing_constraints=timing_constraints,
-            initial_layout=initial_layout,
-            layout_method=layout_method,
-            routing_method=routing_method,
-            translation_method=translation_method,
-            scheduling_method=scheduling_method,
-            approximation_degree=approximation_degree,
-            seed_transpiler=seed_transpiler,
-            unitary_synthesis_method=unitary_synthesis_method,
-            unitary_synthesis_plugin_config=unitary_synthesis_plugin_config,
-            hls_config=hls_config,
-            init_method=init_method,
-            optimization_method=optimization_method,
-            dt=dt,
-            qubits_initially_zero=qubits_initially_zero,
-        )
+    pm = generate_preset_pass_manager(
+        optimization_level,
+        target=target,
+        backend=backend,
+        basis_gates=basis_gates,
+        coupling_map=coupling_map,
+        initial_layout=initial_layout,
+        layout_method=layout_method,
+        routing_method=routing_method,
+        translation_method=translation_method,
+        scheduling_method=scheduling_method,
+        approximation_degree=approximation_degree,
+        seed_transpiler=seed_transpiler,
+        unitary_synthesis_method=unitary_synthesis_method,
+        unitary_synthesis_plugin_config=unitary_synthesis_plugin_config,
+        hls_config=hls_config,
+        init_method=init_method,
+        optimization_method=optimization_method,
+        dt=dt,
+        qubits_initially_zero=qubits_initially_zero,
+    )
 
     out_circuits = pm.run(circuits, callback=callback, num_processes=num_processes)
 

qiskit/transpiler/passes/basis/basis_translator.py

@@ -98,15 +98,16 @@ def __init__(self, equivalence_library, target_basis, target=None, min_qubits=0)
             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
-        self._target = target
+        # 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 target is not None:
+        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:

qiskit/transpiler/passes/layout/vf2_utils.py

@@ -177,7 +177,7 @@ def build_average_error_map(target, coupling_map):
     # running the fallback heuristic
     if not built and target is not None and coupling_map is None:
         coupling_map = target.build_coupling_map()
-    if not built and coupling_map is not None:
+    if not built and coupling_map is not None and num_qubits is not None:
         for qubit in range(num_qubits):
             avg_map.add_error(
                 (qubit, qubit),

qiskit/transpiler/passes/optimization/consolidate_blocks.py

@@ -91,7 +91,9 @@ def __init__(
         """
         super().__init__()
         self.basis_gates = None
-        self.target = target
+        # 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
         if basis_gates is not None:
             self.basis_gates = set(basis_gates)
         self.force_consolidate = force_consolidate

qiskit/transpiler/passes/optimization/optimize_1q_decomposition.py

@@ -80,17 +80,19 @@ def __init__(self, basis=None, target=None):
         """
         super().__init__()
 
-        if basis:
+        if basis and len(basis) > 0:
             self._basis_gates = set(basis)
         else:
             self._basis_gates = None
-        self._target = target
+        # 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._global_decomposers = None
         self._local_decomposers_cache = {}
 
-        if basis:
+        if self._basis_gates:
             self._global_decomposers = _possible_decomposers(set(basis))
-        elif target is None:
+        elif target is None or len(target.operation_names) == 0:
             self._global_decomposers = _possible_decomposers(None)
             self._basis_gates = None
 
@@ -114,7 +116,11 @@ def _build_error_map(self):
 
     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 (
+            self._target is not None
+            and self._target.num_qubits is not None
+            and len(self._target.operation_names) > 0
+        ):
             if qubit is not None:
                 qubits_tuple = (qubit,)
             else:

qiskit/transpiler/passes/synthesis/high_level_synthesis.py

@@ -234,7 +234,10 @@ def __init__(
         if target is not None:
             coupling_map = target.build_coupling_map()
 
-        unroll_definitions = not (basis_gates is None and target is None)
+        unroll_definitions = not (
+            (basis_gates is None or len(basis_gates) == 0)
+            and (target is None or len(target.operation_names) == 0)
+        )
 
         # include path for when target exists but target.num_qubits is None (BasicSimulator)
         if unroll_definitions and (target is None or target.num_qubits is None):

qiskit/transpiler/passes/synthesis/unitary_synthesis.py

@@ -138,9 +138,11 @@ def __init__(
         self._pulse_optimize = pulse_optimize
         self._natural_direction = natural_direction
         self._plugin_config = plugin_config
-        self._target = target
+        # Bypass target if it doesn't contain any basis gates (i.e it's _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
         if target is not None:
-            self._coupling_map = self._target.build_coupling_map()
+            self._coupling_map = target.build_coupling_map()
         if synth_gates:
             self._synth_gates = synth_gates
         else:

qiskit/transpiler/passes/utils/check_gate_direction.py

@@ -45,8 +45,16 @@ def run(self, dag):
         Args:
             dag (DAGCircuit): DAG to check.
         """
-        self.property_set["is_direction_mapped"] = (
-            check_gate_direction_target(dag, self.target)
-            if self.target
-            else check_gate_direction_coupling(dag, set(self.coupling_map.get_edges()))
-        )
+        # Only use "check_gate_direction_target" if a target exists and target.operation_names
+        # is not empty, else use "check_gate_direction_coupling".
+        if self.target is None:
+            self.property_set["is_direction_mapped"] = check_gate_direction_coupling(
+                dag, set(self.coupling_map.get_edges())
+            )
+        elif len(self.target.operation_names) == 0:
+            # A  _FakeTarget path, no basis gates, just use the coupling map
+            self.property_set["is_direction_mapped"] = check_gate_direction_coupling(
+                dag, set(self.target.build_coupling_map().get_edges())
+            )
+        else:
+            self.property_set["is_direction_mapped"] = check_gate_direction_target(dag, self.target)

qiskit/transpiler/passes/utils/gate_direction.py

@@ -81,6 +81,13 @@ def run(self, dag):
             TranspilerError: If the circuit cannot be mapped just by flipping the
                 cx nodes.
         """
+        # Only use "fix_gate_direction_target" if a target exists and target.operation_names
+        # is not empty, else use "fix_gate_direction_coupling".
         if self.target is None:
             return fix_gate_direction_coupling(dag, set(self.coupling_map.get_edges()))
+        elif len(self.target.operation_names) == 0:
+            # A  _FakeTarget path, no basis gates, just use the coupling map
+            return fix_gate_direction_coupling(
+                dag, set(self.target.build_coupling_map().get_edges())
+            )
         return fix_gate_direction_target(dag, self.target)