qiskit 1.3.0b1__cp39-abi3-win32.whl → 1.3.0rc2__cp39-abi3-win32.whl

qiskit/transpiler/passmanager_config.py

@@ -13,14 +13,17 @@
 """Pass Manager Configuration class."""
 
 import pprint
+import warnings
 
 from qiskit.transpiler.coupling import CouplingMap
 from qiskit.transpiler.instruction_durations import InstructionDurations
+from qiskit.utils.deprecate_pulse import deprecate_pulse_arg
 
 
 class PassManagerConfig:
     """Pass Manager Configuration."""
 
+    @deprecate_pulse_arg("inst_map", predicate=lambda inst_map: inst_map is not None)
     def __init__(
         self,
         initial_layout=None,
@@ -113,11 +116,17 @@ class PassManagerConfig:
     def from_backend(cls, backend, _skip_target=False, **pass_manager_options):
         """Construct a configuration based on a backend and user input.
 
-        This method automatically gererates a PassManagerConfig object based on the backend's
+        This method automatically generates a PassManagerConfig object based on the backend's
         features. User options can be used to overwrite the configuration.
 
+        .. deprecated:: 1.3
+            The method ``PassManagerConfig.from_backend`` will stop supporting inputs of type
+            :class:`.BackendV1` in the `backend` parameter in a future release no
+            earlier than 2.0. :class:`.BackendV1` is deprecated and implementations should move
+            to :class:`.BackendV2`.
+
         Args:
-            backend (BackendV1): The backend that provides the configuration.
+            backend (BackendV1 or BackendV2): The backend that provides the configuration.
             pass_manager_options: User-defined option-value pairs.
 
         Returns:
@@ -126,12 +135,21 @@ class PassManagerConfig:
         Raises:
             AttributeError: If the backend does not support a `configuration()` method.
         """
-        res = cls(**pass_manager_options)
         backend_version = getattr(backend, "version", 0)
+        if backend_version == 1:
+            warnings.warn(
+                "The method PassManagerConfig.from_backend 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,
+                stacklevel=2,
+            )
         if not isinstance(backend_version, int):
             backend_version = 0
         if backend_version < 2:
             config = backend.configuration()
+        res = cls(**pass_manager_options)
         if res.basis_gates is None:
             if backend_version < 2:
                 res.basis_gates = getattr(config, "basis_gates", None)
@@ -144,7 +162,7 @@ class PassManagerConfig:
                     if defaults is not None:
                         res.inst_map = defaults.instruction_schedule_map
             else:
-                res.inst_map = backend.instruction_schedule_map
+                res.inst_map = backend._instruction_schedule_map
         if res.coupling_map is None:
             if backend_version < 2:
                 cmap_edge_list = getattr(config, "coupling_map", None)

qiskit/transpiler/preset_passmanagers/builtin_plugins.py

@@ -13,6 +13,7 @@
 """Built-in transpiler stage plugins for preset pass managers."""
 
 import os
+import warnings
 
 from qiskit.transpiler.passes.optimization.split_2q_unitaries import Split2QUnitaries
 from qiskit.transpiler.passmanager import PassManager
@@ -39,9 +40,9 @@ from qiskit.transpiler.preset_passmanagers.plugin import (
 from qiskit.transpiler.passes.optimization import (
     Optimize1qGatesDecomposition,
     CommutativeCancellation,
-    Collect2qBlocks,
     ConsolidateBlocks,
     InverseCancellation,
+    RemoveIdentityEquivalent,
 )
 from qiskit.transpiler.passes import Depth, Size, FixedPoint, MinimumPoint
 from qiskit.transpiler.passes.utils.gates_basis import GatesInBasis
@@ -153,8 +154,16 @@ class DefaultInitPassManager(PassManagerStagePlugin):
                 pass_manager_config.hls_config,
                 pass_manager_config.qubits_initially_zero,
             )
-            init.append(ElidePermutations())
+            if pass_manager_config.routing_method != "none":
+                init.append(ElidePermutations())
             init.append(RemoveDiagonalGatesBeforeMeasure())
+            # Target not set on RemoveIdentityEquivalent because we haven't applied a Layout
+            # yet so doing anything relative to an error rate in the target is not valid.
+            init.append(
+                RemoveIdentityEquivalent(
+                    approximation_degree=pass_manager_config.approximation_degree
+                )
+            )
             init.append(
                 InverseCancellation(
                     [
@@ -174,7 +183,6 @@ class DefaultInitPassManager(PassManagerStagePlugin):
                 )
             )
             init.append(CommutativeCancellation())
-            init.append(Collect2qBlocks())
             init.append(ConsolidateBlocks())
             # If approximation degree is None that indicates a request to approximate up to the
             # error rates in the target. However, in the init stage we don't yet know the target
@@ -580,6 +588,10 @@ class OptimizationPassManager(PassManagerStagePlugin):
 
             elif optimization_level == 2:
                 _opt = [
+                    RemoveIdentityEquivalent(
+                        approximation_degree=pass_manager_config.approximation_degree,
+                        target=pass_manager_config.target,
+                    ),
                     Optimize1qGatesDecomposition(
                         basis=pass_manager_config.basis_gates, target=pass_manager_config.target
                     ),
@@ -588,7 +600,6 @@ class OptimizationPassManager(PassManagerStagePlugin):
             elif optimization_level == 3:
                 # Steps for optimization level 3
                 _opt = [
-                    Collect2qBlocks(),
                     ConsolidateBlocks(
                         basis_gates=pass_manager_config.basis_gates,
                         target=pass_manager_config.target,
@@ -603,6 +614,10 @@ class OptimizationPassManager(PassManagerStagePlugin):
                         plugin_config=pass_manager_config.unitary_synthesis_plugin_config,
                         target=pass_manager_config.target,
                     ),
+                    RemoveIdentityEquivalent(
+                        approximation_degree=pass_manager_config.approximation_degree,
+                        target=pass_manager_config.target,
+                    ),
                     Optimize1qGatesDecomposition(
                         basis=pass_manager_config.basis_gates, target=pass_manager_config.target
                     ),
@@ -632,7 +647,6 @@ class OptimizationPassManager(PassManagerStagePlugin):
             elif optimization_level == 2:
                 optimization.append(
                     [
-                        Collect2qBlocks(),
                         ConsolidateBlocks(
                             basis_gates=pass_manager_config.basis_gates,
                             target=pass_manager_config.target,
@@ -675,9 +689,13 @@ class AlapSchedulingPassManager(PassManagerStagePlugin):
         inst_map = pass_manager_config.inst_map
         target = pass_manager_config.target
 
-        return common.generate_scheduling(
-            instruction_durations, scheduling_method, timing_constraints, inst_map, target
-        )
+        with warnings.catch_warnings():
+            warnings.simplefilter(action="ignore", category=DeprecationWarning)
+            # Passing `inst_map` to `generate_scheduling` is deprecated in Qiskit 1.3
+            # so filtering these warning when building pass managers
+            return common.generate_scheduling(
+                instruction_durations, scheduling_method, timing_constraints, inst_map, target
+            )
 
 
 class AsapSchedulingPassManager(PassManagerStagePlugin):
@@ -692,9 +710,13 @@ class AsapSchedulingPassManager(PassManagerStagePlugin):
         inst_map = pass_manager_config.inst_map
         target = pass_manager_config.target
 
-        return common.generate_scheduling(
-            instruction_durations, scheduling_method, timing_constraints, inst_map, target
-        )
+        with warnings.catch_warnings():
+            warnings.simplefilter(action="ignore", category=DeprecationWarning)
+            # Passing `inst_map` to `generate_scheduling` is deprecated in Qiskit 1.3
+            # so filtering these warning when building pass managers
+            return common.generate_scheduling(
+                instruction_durations, scheduling_method, timing_constraints, inst_map, target
+            )
 
 
 class DefaultSchedulingPassManager(PassManagerStagePlugin):
@@ -709,9 +731,13 @@ class DefaultSchedulingPassManager(PassManagerStagePlugin):
         inst_map = pass_manager_config.inst_map
         target = pass_manager_config.target
 
-        return common.generate_scheduling(
-            instruction_durations, scheduling_method, timing_constraints, inst_map, target
-        )
+        with warnings.catch_warnings():
+            warnings.simplefilter(action="ignore", category=DeprecationWarning)
+            # Passing `inst_map` to `generate_scheduling` is deprecated in Qiskit 1.3
+            # so filtering these warning when building pass managers
+            return common.generate_scheduling(
+                instruction_durations, scheduling_method, timing_constraints, inst_map, target
+            )
 
 
 class DefaultLayoutPassManager(PassManagerStagePlugin):

qiskit/transpiler/preset_passmanagers/common.py

@@ -24,9 +24,9 @@ from qiskit.transpiler.passmanager import PassManager
 from qiskit.transpiler.passes import Error
 from qiskit.transpiler.passes import BasisTranslator
 from qiskit.transpiler.passes import Unroll3qOrMore
-from qiskit.transpiler.passes import Collect2qBlocks
-from qiskit.transpiler.passes import Collect1qRuns
 from qiskit.transpiler.passes import ConsolidateBlocks
+from qiskit.transpiler.passes import Collect1qRuns
+from qiskit.transpiler.passes import Collect2qBlocks
 from qiskit.transpiler.passes import UnitarySynthesis
 from qiskit.transpiler.passes import HighLevelSynthesis
 from qiskit.transpiler.passes import CheckMap
@@ -52,6 +52,7 @@ from qiskit.transpiler.passes.layout.vf2_layout import VF2LayoutStopReason
 from qiskit.transpiler.passes.layout.vf2_post_layout import VF2PostLayoutStopReason
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.transpiler.layout import Layout
+from qiskit.utils.deprecate_pulse import deprecate_pulse_arg
 
 
 _ControlFlowState = collections.namedtuple("_ControlFlowState", ("working", "not_working"))
@@ -529,6 +530,7 @@ def generate_translation_passmanager(
     return PassManager(unroll)
 
 
+@deprecate_pulse_arg("inst_map", predicate=lambda inst_map: inst_map is not None)
 def generate_scheduling(
     instruction_durations, scheduling_method, timing_constraints, inst_map, target=None
 ):
@@ -540,7 +542,7 @@ def generate_scheduling(
             ``'asap'``/``'as_soon_as_possible'`` or
             ``'alap'``/``'as_late_as_possible'``
         timing_constraints (TimingConstraints): Hardware time alignment restrictions.
-        inst_map (InstructionScheduleMap): Mapping object that maps gate to schedule.
+        inst_map (InstructionScheduleMap): DEPRECATED. Mapping object that maps gate to schedule.
         target (Target): The :class:`~.Target` object representing the backend
 
     Returns:

qiskit/transpiler/preset_passmanagers/generate_preset_pass_manager.py

@@ -17,7 +17,13 @@ Preset pass manager generation function
 import copy
 import warnings
 
-from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES
+from qiskit.circuit.controlflow import (
+    CONTROL_FLOW_OP_NAMES,
+    IfElseOp,
+    WhileLoopOp,
+    ForLoopOp,
+    SwitchCaseOp,
+)
 from qiskit.circuit.library.standard_gates import get_standard_gate_name_mapping
 from qiskit.circuit.quantumregister import Qubit
 from qiskit.providers.backend import Backend
@@ -29,6 +35,8 @@ 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.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
@@ -36,6 +44,33 @@ 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)
 def generate_preset_pass_manager(
     optimization_level=2,
     backend=None,
@@ -122,7 +157,7 @@ def generate_preset_pass_manager(
             and ``backend_properties``.
         basis_gates (list): List of basis gate names to unroll to
             (e.g: ``['u1', 'u2', 'u3', 'cx']``).
-        inst_map (InstructionScheduleMap): Mapping object that maps gates to schedules.
+        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
@@ -283,6 +318,7 @@ def generate_preset_pass_manager(
     _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)
     )
 
@@ -307,23 +343,31 @@ def generate_preset_pass_manager(
             # 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)
-            # 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
-                ),
-                dt=dt,
-                timing_constraints=timing_constraints,
-                custom_name_mapping=name_mapping,
-            )
+            with warnings.catch_warnings():
+                # TODO: inst_map will be removed in 2.0
+                warnings.filterwarnings(
+                    "ignore",
+                    category=DeprecationWarning,
+                    message=".*``inst_map`` is deprecated as of Qiskit 1.3.*",
+                    module="qiskit",
+                )
+                # 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
+                    ),
+                    dt=dt,
+                    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.
@@ -339,7 +383,7 @@ def generate_preset_pass_manager(
         if instruction_durations is None:
             instruction_durations = target.durations()
         if inst_map is None:
-            inst_map = target.instruction_schedule_map()
+            inst_map = target._get_instruction_schedule_map()
         if timing_constraints is None:
             timing_constraints = target.timing_constraints()
         if backend_properties is None:
@@ -383,30 +427,41 @@ def generate_preset_pass_manager(
         "qubits_initially_zero": qubits_initially_zero,
     }
 
-    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}")
+    with warnings.catch_warnings():
+        # inst_map is deprecated in the PassManagerConfig initializer
+        warnings.filterwarnings(
+            "ignore",
+            category=DeprecationWarning,
+            message=".*argument ``inst_map`` is deprecated as of Qiskit 1.3",
+        )
+        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):
-    name_mapping = {}
     standard_gates = get_standard_gate_name_mapping()
-    # Add control flow gates by default to basis set
+    # 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,
+    }
     try:
         instructions = set(basis_gates)
         for name in default_gates:
@@ -421,7 +476,16 @@ def _parse_basis_gates(basis_gates, backend, inst_map, skip_target):
             return None, name_mapping, skip_target
 
         for inst in instructions:
-            if inst not in standard_gates or inst not in default_gates:
+            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. "
+                    "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
 
@@ -434,7 +498,18 @@ def _parse_basis_gates(basis_gates, backend, inst_map, skip_target):
 
     # Check for custom instructions before removing calibrations
     for inst in instructions:
-        if inst not in standard_gates or inst not in default_gates:
+        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
+                # (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.",
+                )
             skip_target = True
             break
 
@@ -452,14 +527,22 @@ def _parse_basis_gates(basis_gates, backend, inst_map, 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.instruction_schedule_map()
+        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:
-        backend_properties = target_to_backend_properties(backend.target)
+        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
 
 

qiskit/transpiler/preset_passmanagers/plugin.py

@@ -145,7 +145,7 @@ subclass as a setuptools entry point in the package metadata. This can be done
 an ``entry-points`` table in ``pyproject.toml`` for the plugin package with the necessary entry
 points under the appropriate namespace for the stage your plugin is for. You can see the list of
 stages, entry points, and expectations from the stage in :ref:`stage_table`.  For example,
-continuing from the example plugin above::
+continuing from the example plugin above:
 
 .. code-block:: toml