qiskit 1.4.2__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/transpiler/preset_passmanagers/generate_preset_pass_manager.py

@@ -13,30 +13,20 @@
 """
 Preset pass manager generation function
 """
-
 import copy
 import warnings
 
-from qiskit.circuit.controlflow import (
-    CONTROL_FLOW_OP_NAMES,
-    IfElseOp,
-    WhileLoopOp,
-    ForLoopOp,
-    SwitchCaseOp,
-)
+from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES, get_control_flow_name_mapping
 from qiskit.circuit.library.standard_gates import get_standard_gate_name_mapping
-from qiskit.circuit.quantumregister import Qubit
+from qiskit.circuit import Qubit
 from qiskit.providers.backend import Backend
-from qiskit.providers.backend_compat import BackendV2Converter
 from qiskit.transpiler.coupling import CouplingMap
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.transpiler.instruction_durations import InstructionDurations
 from qiskit.transpiler.layout import Layout
 from qiskit.transpiler.passmanager_config import PassManagerConfig
-from qiskit.transpiler.target import Target, target_to_backend_properties
+from qiskit.transpiler.target import Target, _FakeTarget
 from qiskit.transpiler.timing_constraints import TimingConstraints
-from qiskit.utils import deprecate_arg
-from qiskit.utils.deprecate_pulse import deprecate_pulse_arg
 
 from .level0 import level_0_pass_manager
 from .level1 import level_1_pass_manager
@@ -44,43 +34,15 @@ from .level2 import level_2_pass_manager
 from .level3 import level_3_pass_manager
 
 
-@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=...)`",
-)
-@deprecate_arg(
-    name="backend_properties",
-    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 properties with Target.from_configuration(..., backend_properties=...)",
-)
-@deprecate_pulse_arg("inst_map", predicate=lambda inst_map: inst_map is not None)
+OVER_3Q_GATES = ["ccx", "ccz", "cswap", "rccx", "c3x", "c3sx", "rc3x"]
+
+
 def generate_preset_pass_manager(
     optimization_level=2,
     backend=None,
     target=None,
     basis_gates=None,
-    inst_map=None,
     coupling_map=None,
-    instruction_durations=None,
-    backend_properties=None,
-    timing_constraints=None,
     initial_layout=None,
     layout_method=None,
     routing_method=None,
@@ -107,30 +69,24 @@ def generate_preset_pass_manager(
     function internally builds and uses.
 
     The target constraints for the pass manager construction can be specified through a :class:`.Target`
-    instance, a :class:`.BackendV1` or :class:`.BackendV2` instance, or via loose constraints
-    (``basis_gates``, ``inst_map``, ``coupling_map``, ``backend_properties``, ``instruction_durations``,
-    ``dt`` or ``timing_constraints``).
+    instance, a :class:`.BackendV2` instance, or via loose constraints
+    (``basis_gates``, ``coupling_map``, or ``dt``).
     The order of priorities for target constraints works as follows: if a ``target``
     input is provided, it will take priority over any ``backend`` input or loose constraints.
     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 independent of whether the ``backend`` instance is of type
-    :class:`.BackendV1` or :class:`.BackendV2`, as summarized in the table below. The first column
+    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
     the priority is assigned to that specific constraint input or another input
     (`target`/`backend(V1)`/`backend(V2)`).
 
-    ============================ ========= ======================== =======================
-    User Provided                target    backend(V1)              backend(V2)
-    ============================ ========= ======================== =======================
-    **basis_gates**              target    basis_gates              basis_gates
-    **coupling_map**             target    coupling_map             coupling_map
-    **instruction_durations**    target    instruction_durations    instruction_durations
-    **inst_map**                 target    inst_map                 inst_map
-    **dt**                       target    dt                       dt
-    **timing_constraints**       target    timing_constraints       timing_constraints
-    **backend_properties**       target    backend_properties       backend_properties
-    ============================ ========= ======================== =======================
+    ============================ ========= ========================
+    User Provided                target    backend(V2)
+    ============================ ========= ========================
+    **basis_gates**              target    basis_gates
+    **coupling_map**             target    coupling_map
+    **dt**                       target    dt
+    ============================ ========= ========================
 
     Args:
         optimization_level (int): The optimization level to generate a
@@ -145,23 +101,15 @@ def generate_preset_pass_manager(
                 * 3: even heavier optimization
 
         backend (Backend): An optional backend object which can be used as the
-            source of the default values for the ``basis_gates``, ``inst_map``,
-            ``coupling_map``, ``backend_properties``, ``instruction_durations``,
-            ``timing_constraints``, and ``target``. If any of those other arguments
+            source of the default values for the ``basis_gates``,
+            ``coupling_map``, and ``target``. If any of those other arguments
             are specified in addition to ``backend`` they will take precedence
             over the value contained in the backend.
         target (Target): The :class:`~.Target` representing a backend compilation
             target. The following attributes will be inferred from this
-            argument if they are not set: ``coupling_map``, ``basis_gates``,
-            ``instruction_durations``, ``inst_map``, ``timing_constraints``
-            and ``backend_properties``.
+            argument if they are not set: ``coupling_map`` and ``basis_gates``.
         basis_gates (list): List of basis gate names to unroll to
             (e.g: ``['u1', 'u2', 'u3', 'cx']``).
-        inst_map (InstructionScheduleMap): DEPRECATED. Mapping object that maps gates to schedules.
-            If any user defined calibration is found in the map and this is used in a
-            circuit, transpiler attaches the custom gate definition to the circuit.
-            This enables one to flexibly override the low-level instruction
-            implementation.
         coupling_map (CouplingMap or list): Directed graph represented a coupling
             map. Multiple formats are supported:
 
@@ -169,45 +117,8 @@ def generate_preset_pass_manager(
             #. List, must be given as an adjacency matrix, where each entry
                specifies all directed two-qubit interactions supported by backend,
                e.g: ``[[0, 1], [0, 3], [1, 2], [1, 5], [2, 5], [4, 1], [5, 3]]``
-
-        instruction_durations (InstructionDurations or list): Dictionary of duration
-            (in dt) for each instruction. If specified, these durations overwrite the
-            gate lengths in ``backend.properties``. Applicable only if ``scheduling_method``
-            is specified.
-            The format of ``instruction_durations`` must be as follows:
-            They must be given as an :class:`.InstructionDurations` instance or 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 (float): Backend sample time (resolution) in seconds.
-            If provided, this value will overwrite the ``dt`` value in ``instruction_durations``.
             If ``None`` (default) and a backend is provided, ``backend.dt`` is used.
-        timing_constraints (TimingConstraints): Hardware time alignment restrictions.
-             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.
-
         initial_layout (Layout | List[int]): Initial position of virtual qubits on
             physical qubits.
         layout_method (str): The :class:`~.Pass` to use for choosing initial qubit
@@ -236,9 +147,6 @@ def generate_preset_pass_manager(
             for the ``scheduling`` stage of the output :class:`~.StagedPassManager`. You can
             see a list of installed plugins by using :func:`~.list_stage_plugins` with
             ``"scheduling"`` for the ``stage_name`` argument.
-        backend_properties (BackendProperties): Properties returned by a
-            backend, including information on gate errors, readout errors,
-            qubit coherence times, etc.
         approximation_degree (float): Heuristic dial used for circuit approximation
             (1.0=no approximation, 0.0=maximal approximation).
         seed_transpiler (int): Sets random seed for the stochastic parts of
@@ -289,98 +197,55 @@ def generate_preset_pass_manager(
         backend = optimization_level
         optimization_level = 2
 
-    if backend is not None and getattr(backend, "version", 0) <= 1:
-        # This is a temporary conversion step to allow for a smoother transition
-        # to a fully target-based transpiler pipeline while maintaining the behavior
-        # of `transpile` with BackendV1 inputs.
+    # If there are no loose constraints => use backend target if available
+    _no_loose_constraints = basis_gates is None and coupling_map is None and dt is None
+
+    # If the only loose constraint is dt => use backend target and modify dt
+    _adjust_dt = backend is not None and dt is not None
+
+    # Warn about inconsistencies in backend + loose constraints path (dt shouldn't be a problem)
+    if backend is not None and (coupling_map is not None or basis_gates is not None):
         warnings.warn(
-            "The `generate_preset_pass_manager` function will stop supporting inputs of "
-            f"type `BackendV1` ( {backend} ) in the `backend` parameter in a future "
-            "release no earlier than 2.0. `BackendV1` is deprecated and implementations "
-            "should move to `BackendV2`.",
-            category=DeprecationWarning,
+            "Providing `coupling_map` and/or `basis_gates` along with `backend` is not "
+            "recommended, as this will invalidate the backend's gate durations and error rates.",
+            category=UserWarning,
             stacklevel=2,
         )
-        backend = BackendV2Converter(backend)
-
-    # Check if a custom inst_map was specified before overwriting inst_map
-    _given_inst_map = bool(inst_map)
-    # If there are no loose constraints => use backend target if available
-    _no_loose_constraints = (
-        basis_gates is None
-        and coupling_map is None
-        and dt is None
-        and instruction_durations is None
-        and backend_properties is None
-        and timing_constraints is None
-    )
-    # If it's an edge case => do not build target
-    _skip_target = (
-        target is None
-        and backend is None
-        # Note: instruction_durations is deprecated and will be removed in 2.0 (no need for alternative)
-        and (basis_gates is None or coupling_map is None or instruction_durations is not None)
-    )
 
     # Resolve loose constraints case-by-case against backend constraints.
     # The order of priority is loose constraints > backend.
     dt = _parse_dt(dt, backend)
-    instruction_durations = _parse_instruction_durations(backend, instruction_durations, dt)
-    timing_constraints = _parse_timing_constraints(backend, timing_constraints)
-    inst_map = _parse_inst_map(inst_map, backend)
-    # The basis gates parser will set _skip_target to True if a custom basis gate is found
-    # (known edge case).
-    basis_gates, name_mapping, _skip_target = _parse_basis_gates(
-        basis_gates, backend, inst_map, _skip_target
-    )
+    instruction_durations = _parse_instruction_durations(backend, dt)
+    timing_constraints = _parse_timing_constraints(backend)
     coupling_map = _parse_coupling_map(coupling_map, backend)
+    basis_gates, name_mapping = _parse_basis_gates(basis_gates, backend)
+
+    # Check if coupling map has been provided (either standalone or through backend)
+    # with user-defined basis_gates, and whether these have 3q or more.
+    if coupling_map is not None and basis_gates is not None:
+        for gate in OVER_3Q_GATES:
+            if gate in basis_gates:
+                raise ValueError(
+                    f"Gates with 3 or more qubits ({gate}) in `basis_gates` or `backend` are "
+                    "incompatible with a custom `coupling_map`. To include 3-qubit or larger "
+                    " gates in the transpilation basis, provide a custom `target` instead."
+                )
 
     if target is None:
         if backend is not None and _no_loose_constraints:
             # If a backend is specified without loose constraints, use its target directly.
             target = backend.target
-        elif not _skip_target:
-            # Only parse backend properties when the target isn't skipped to
-            # preserve the former behavior of transpile.
-            backend_properties = _parse_backend_properties(backend_properties, backend)
-            with warnings.catch_warnings():
-                # TODO: inst_map and backend_properties will be removed in 2.0
-                warnings.filterwarnings(
-                    "ignore",
-                    category=DeprecationWarning,
-                    message=".*``inst_map`` is deprecated as of Qiskit 1.3.*",
-                    module="qiskit",
-                )
-                warnings.filterwarnings(
-                    "ignore",
-                    category=DeprecationWarning,
-                    message=".* ``backend_properties`` is deprecated as of Qiskit 1.4",
-                    module="qiskit",
-                )
-                warnings.filterwarnings(
-                    "ignore",
-                    category=DeprecationWarning,
-                    message=".*``qiskit.providers.exceptions.BackendPropertyError``",
-                )
-                # TODO: This is a temporary usage of deprecated backend_properties in
-                #   Target.from_configuration. Probably the logic needs to be restructured
-                #   in a more target-centric transpiler
-                #   https://github.com/Qiskit/qiskit/issues/9256
-                warnings.filterwarnings(
-                    "ignore",
-                    category=DeprecationWarning,
-                    message=r".+qiskit\.transpiler\.target\.Target\.from_configuration.+",
-                    module="qiskit",
-                )
+        elif _adjust_dt:
+            # If a backend is specified with loose dt, use its target and adjust the dt value.
+            target = copy.deepcopy(backend.target)
+            target.dt = dt
+        else:
+            if basis_gates is not None:
                 # Build target from constraints.
                 target = Target.from_configuration(
                     basis_gates=basis_gates,
                     num_qubits=backend.num_qubits if backend is not None else None,
                     coupling_map=coupling_map,
-                    # If the instruction map has custom gates, do not give as config, the information
-                    # will be added to the target with update_from_instruction_schedule_map
-                    inst_map=inst_map if inst_map and not inst_map.has_custom_gate() else None,
-                    backend_properties=backend_properties,
                     instruction_durations=instruction_durations,
                     concurrent_measurements=(
                         backend.target.concurrent_measurements if backend is not None else None
@@ -389,48 +254,33 @@ def generate_preset_pass_manager(
                     timing_constraints=timing_constraints,
                     custom_name_mapping=name_mapping,
                 )
-
-    # Update target with custom gate information. Note that this is an exception to the priority
-    # order (target > loose constraints), added to handle custom gates for scheduling passes.
-    if target is not None and _given_inst_map and inst_map.has_custom_gate():
-        target = copy.deepcopy(target)
-        target.update_from_instruction_schedule_map(inst_map)
-
-    if target is not None:
-        if coupling_map is None:
-            coupling_map = target.build_coupling_map()
-        if basis_gates is None:
-            basis_gates = target.operation_names
-        if instruction_durations is None:
-            instruction_durations = target.durations()
-        if inst_map is None:
-            inst_map = target._get_instruction_schedule_map()
-        if timing_constraints is None:
-            timing_constraints = target.timing_constraints()
-        if backend_properties is None:
-            with warnings.catch_warnings():
-                # TODO this approach (target-to-properties) is going to be removed soon (1.3) in favor
-                #   of backend-to-target approach
-                #   https://github.com/Qiskit/qiskit/pull/12850
-                warnings.filterwarnings(
-                    "ignore",
-                    category=DeprecationWarning,
-                    message=r".+qiskit\.transpiler\.target\.target_to_backend_properties.+",
-                    module="qiskit",
+            else:
+                target = _FakeTarget.from_configuration(
+                    num_qubits=backend.num_qubits if backend is not None else None,
+                    coupling_map=coupling_map,
+                    dt=dt,
                 )
-                backend_properties = target_to_backend_properties(target)
+
+    # Update loose constraints to populate pm options
+    if coupling_map is None:
+        coupling_map = target.build_coupling_map()
+    if basis_gates is None and len(target.operation_names) > 0:
+        basis_gates = target.operation_names
+    if instruction_durations is None:
+        instruction_durations = target.durations()
+    if timing_constraints is None:
+        timing_constraints = target.timing_constraints()
 
     # Parse non-target dependent pm options
     initial_layout = _parse_initial_layout(initial_layout)
     approximation_degree = _parse_approximation_degree(approximation_degree)
     seed_transpiler = _parse_seed_transpiler(seed_transpiler)
+
     pm_options = {
         "target": target,
         "basis_gates": basis_gates,
-        "inst_map": inst_map,
         "coupling_map": coupling_map,
         "instruction_durations": instruction_durations,
-        "backend_properties": backend_properties,
         "timing_constraints": timing_constraints,
         "layout_method": layout_method,
         "routing_method": routing_method,
@@ -447,47 +297,29 @@ def generate_preset_pass_manager(
         "qubits_initially_zero": qubits_initially_zero,
     }
 
-    with warnings.catch_warnings():
-        # inst_map and backend_properties are deprecated in the PassManagerConfig initializer
-        warnings.filterwarnings(
-            "ignore",
-            category=DeprecationWarning,
-            message=".*argument ``inst_map`` is deprecated as of Qiskit 1.3",
-        )
-        warnings.filterwarnings(
-            "ignore",
-            category=DeprecationWarning,
-            message=".*argument ``backend_properties`` is deprecated as of Qiskit 1.4",
-            module="qiskit",
-        )
-        if backend is not None:
-            pm_options["_skip_target"] = _skip_target
-            pm_config = PassManagerConfig.from_backend(backend, **pm_options)
-        else:
-            pm_config = PassManagerConfig(**pm_options)
-        if optimization_level == 0:
-            pm = level_0_pass_manager(pm_config)
-        elif optimization_level == 1:
-            pm = level_1_pass_manager(pm_config)
-        elif optimization_level == 2:
-            pm = level_2_pass_manager(pm_config)
-        elif optimization_level == 3:
-            pm = level_3_pass_manager(pm_config)
-        else:
-            raise ValueError(f"Invalid optimization level {optimization_level}")
+    if backend is not None:
+        pm_options["_skip_target"] = _skip_target
+        pm_config = PassManagerConfig.from_backend(backend, **pm_options)
+    else:
+        pm_config = PassManagerConfig(**pm_options)
+    if optimization_level == 0:
+        pm = level_0_pass_manager(pm_config)
+    elif optimization_level == 1:
+        pm = level_1_pass_manager(pm_config)
+    elif optimization_level == 2:
+        pm = level_2_pass_manager(pm_config)
+    elif optimization_level == 3:
+        pm = level_3_pass_manager(pm_config)
+    else:
+        raise ValueError(f"Invalid optimization level {optimization_level}")
     return pm
 
 
-def _parse_basis_gates(basis_gates, backend, inst_map, skip_target):
+def _parse_basis_gates(basis_gates, backend):
     standard_gates = get_standard_gate_name_mapping()
     # Add control flow gates by default to basis set and name mapping
     default_gates = {"measure", "delay", "reset"}.union(CONTROL_FLOW_OP_NAMES)
-    name_mapping = {
-        "if_else": IfElseOp,
-        "while_loop": WhileLoopOp,
-        "for_loop": ForLoopOp,
-        "switch_case": SwitchCaseOp,
-    }
+    name_mapping = get_control_flow_name_mapping()
     try:
         instructions = set(basis_gates)
         for name in default_gates:
@@ -499,77 +331,38 @@ def _parse_basis_gates(basis_gates, backend, inst_map, skip_target):
     if backend is None:
         # Check for custom instructions
         if instructions is None:
-            return None, name_mapping, skip_target
+            return None, name_mapping
 
         for inst in instructions:
             if inst not in standard_gates and inst not in default_gates:
-                warnings.warn(
-                    category=DeprecationWarning,
-                    message=f"Providing non-standard gates ({inst}) through the ``basis_gates`` "
-                    "argument is deprecated for both ``transpile`` and ``generate_preset_pass_manager`` "
-                    "as of Qiskit 1.3.0. "
-                    "It will be removed in Qiskit 2.0. The ``target`` parameter should be used instead. "
+                raise ValueError(
+                    f"Providing non-standard gates ({inst}) through the ``basis_gates`` "
+                    "argument is not allowed. Use the ``target`` parameter instead. "
                     "You can build a target instance using ``Target.from_configuration()`` and provide "
-                    "custom gate definitions with the ``custom_name_mapping`` argument.",
+                    "custom gate definitions with the ``custom_name_mapping`` argument."
                 )
-                skip_target = True
-                break
 
-        return list(instructions), name_mapping, skip_target
+        return list(instructions), name_mapping
 
     instructions = instructions or backend.operation_names
     name_mapping.update(
         {name: backend.target.operation_from_name(name) for name in backend.operation_names}
     )
 
-    # Check for custom instructions before removing calibrations
+    # Check for custom instructions
     for inst in instructions:
         if inst not in standard_gates and inst not in default_gates:
             if inst not in backend.operation_names:
-                # do not raise warning when the custom instruction comes from the backend
+                # do not raise error when the custom instruction comes from the backend
                 # (common case with BasicSimulator)
-                warnings.warn(
-                    category=DeprecationWarning,
-                    message="Providing custom gates through the ``basis_gates`` argument is deprecated "
-                    "for both ``transpile`` and ``generate_preset_pass_manager`` as of Qiskit 1.3.0. "
-                    "It will be removed in Qiskit 2.0. The ``target`` parameter should be used instead. "
-                    "You can build a target instance using ``Target.from_configuration()`` and provide"
-                    "custom gate definitions with the ``custom_name_mapping`` argument.",
+                raise ValueError(
+                    f"Providing non-standard gates ({inst}) through the ``basis_gates`` "
+                    "argument is not allowed. Use the ``target`` parameter instead. "
+                    "You can build a target instance using ``Target.from_configuration()`` and provide "
+                    "custom gate definitions with the ``custom_name_mapping`` argument."
                 )
-            skip_target = True
-            break
-
-    # Remove calibrated instructions, as they will be added later from the instruction schedule map
-    if inst_map is not None and not skip_target:
-        for inst in inst_map.instructions:
-            for qubit in inst_map.qubits_with_instruction(inst):
-                entry = inst_map._get_calibration_entry(inst, qubit)
-                if entry.user_provided and inst in instructions:
-                    instructions.remove(inst)
-
-    return list(instructions) if instructions else None, name_mapping, skip_target
-
-
-def _parse_inst_map(inst_map, backend):
-    # try getting inst_map from user, else backend
-    if inst_map is None and backend is not None:
-        inst_map = backend.target._get_instruction_schedule_map()
-    return inst_map
-
-
-def _parse_backend_properties(backend_properties, backend):
-    # try getting backend_props from user, else backend
-    if backend_properties is None and backend is not None:
-        with warnings.catch_warnings():
-            # filter target_to_backend_properties warning
-            warnings.filterwarnings(
-                "ignore",
-                category=DeprecationWarning,
-                message=".*``qiskit.transpiler.target.target_to_backend_properties\\(\\)``.*",
-                module="qiskit",
-            )
-            backend_properties = target_to_backend_properties(backend.target)
-    return backend_properties
+
+    return list(instructions) if instructions else None, name_mapping
 
 
 def _parse_dt(dt, backend):
@@ -597,28 +390,20 @@ def _parse_coupling_map(coupling_map, backend):
         )
 
 
-def _parse_instruction_durations(backend, inst_durations, dt):
-    """Create a list of ``InstructionDuration``s. If ``inst_durations`` is provided,
-    the backend will be ignored, otherwise, the durations will be populated from the
-    backend.
-    """
+def _parse_instruction_durations(backend, dt):
+    """Create a list of ``InstructionDuration``s populated from the backend."""
     final_durations = InstructionDurations()
-    if not inst_durations:
-        backend_durations = InstructionDurations()
-        if backend is not None:
-            backend_durations = backend.instruction_durations
-        final_durations.update(backend_durations, dt or backend_durations.dt)
-    else:
-        final_durations.update(inst_durations, dt or getattr(inst_durations, "dt", None))
+    backend_durations = InstructionDurations()
+    if backend is not None:
+        backend_durations = backend.instruction_durations
+    final_durations.update(backend_durations, dt or backend_durations.dt)
     return final_durations
 
 
-def _parse_timing_constraints(backend, timing_constraints):
-    if isinstance(timing_constraints, TimingConstraints):
-        return timing_constraints
-    if backend is None and timing_constraints is None:
+def _parse_timing_constraints(backend):
+    if backend is None:
         timing_constraints = TimingConstraints()
-    elif backend is not None:
+    else:
         timing_constraints = backend.target.timing_constraints()
     return timing_constraints
 

qiskit/transpiler/preset_passmanagers/level0.py

@@ -48,8 +48,8 @@ def level_0_pass_manager(pass_manager_config: PassManagerConfig) -> StagedPassMa
     initial_layout = pass_manager_config.initial_layout
     init_method = pass_manager_config.init_method or "default"
     layout_method = pass_manager_config.layout_method or "default"
-    routing_method = pass_manager_config.routing_method or "sabre"
-    translation_method = pass_manager_config.translation_method or "translator"
+    routing_method = pass_manager_config.routing_method or "default"
+    translation_method = pass_manager_config.translation_method or "default"
     optimization_method = pass_manager_config.optimization_method or "default"
     scheduling_method = pass_manager_config.scheduling_method or "default"
     target = pass_manager_config.target
@@ -73,14 +73,6 @@ def level_0_pass_manager(pass_manager_config: PassManagerConfig) -> StagedPassMa
         "translation", translation_method, pass_manager_config, optimization_level=0
     )
 
-    if (coupling_map and not coupling_map.is_symmetric) or (
-        target is not None and target.get_non_global_operation_names(strict_direction=True)
-    ):
-        pre_opt = common.generate_pre_op_passmanager(target, coupling_map)
-        pre_opt += translation
-    else:
-        pre_opt = None
-
     sched = plugin_manager.get_passmanager_stage(
         "scheduling", scheduling_method, pass_manager_config, optimization_level=0
     )
@@ -107,7 +99,6 @@ def level_0_pass_manager(pass_manager_config: PassManagerConfig) -> StagedPassMa
         layout=layout,
         routing=routing,
         translation=translation,
-        pre_optimization=pre_opt,
         optimization=optimization,
         scheduling=sched,
     )