qiskit 1.1.2__cp38-abi3-macosx_10_9_universal2.whl → 1.2.0rc1__cp38-abi3-macosx_10_9_universal2.whl

qiskit/transpiler/preset_passmanagers/__init__.py

@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2017, 2019.
+# (C) Copyright IBM 2017, 2024.
 #
 # This code is licensed under the Apache License, Version 2.0. You may
 # obtain a copy of this license in the LICENSE.txt file in the root directory
@@ -21,7 +21,8 @@ This module contains functions for generating the preset pass managers
 for the transpiler. The preset pass managers are instances of
 :class:`~.StagedPassManager` which are used to execute the circuit
 transformations as part of Qiskit's compiler inside the
-:func:`~.transpile` function at the different optimization levels.
+:func:`~.transpile` function at the different optimization levels, but
+can also be used in a standalone manner.
 The functionality here is divided into two parts, the first includes the
 functions used generate the entire pass manager which is used by
 :func:`~.transpile` (:ref:`preset_pass_manager_generators`) and the
@@ -56,238 +57,13 @@ Stage Generator Functions
 .. autofunction:: generate_scheduling
 .. currentmodule:: qiskit.transpiler.preset_passmanagers
 """
-
-import warnings
-
-from qiskit.transpiler.passmanager_config import PassManagerConfig
-from qiskit.transpiler.target import target_to_backend_properties
-from qiskit.transpiler import CouplingMap
-
+from .generate_preset_pass_manager import generate_preset_pass_manager
 from .level0 import level_0_pass_manager
 from .level1 import level_1_pass_manager
 from .level2 import level_2_pass_manager
 from .level3 import level_3_pass_manager
 
 
-def generate_preset_pass_manager(
-    optimization_level,
-    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,
-    translation_method=None,
-    scheduling_method=None,
-    approximation_degree=1.0,
-    seed_transpiler=None,
-    unitary_synthesis_method="default",
-    unitary_synthesis_plugin_config=None,
-    hls_config=None,
-    init_method=None,
-    optimization_method=None,
-    *,
-    _skip_target=False,
-):
-    """Generate a preset :class:`~.PassManager`
-
-    This function is used to quickly generate a preset pass manager. Preset pass
-    managers are the default pass managers used by the :func:`~.transpile`
-    function. This function provides a convenient and simple method to construct
-    a standalone :class:`~.PassManager` object that mirrors what the :func:`~.transpile`
-    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``).
-    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
-    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
-    ============================ ========= ======================== =======================
-
-    Args:
-        optimization_level (int): The optimization level to generate a
-            :class:`~.PassManager` for. This can be 0, 1, 2, or 3. Higher
-            levels generate more optimized circuits, at the expense of
-            longer transpilation time:
-
-                * 0: no optimization
-                * 1: light optimization
-                * 2: heavy optimization
-                * 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
-            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``.
-        basis_gates (list): List of basis gate names to unroll to
-            (e.g: ``['u1', 'u2', 'u3', 'cx']``).
-        inst_map (InstructionScheduleMap): Mapping object that maps gate 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.
-        instruction_durations (InstructionDurations): Dictionary of duration
-            (in dt) for each instruction.
-        timing_constraints (TimingConstraints): Hardware time alignment restrictions.
-        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
-            placement. Valid choices are ``'trivial'``, ``'dense'``,
-            and ``'sabre'``, representing :class:`~.TrivialLayout`, :class:`~.DenseLayout` and
-            :class:`~.SabreLayout` respectively. This can also
-            be the external plugin name to use for the ``layout`` stage of the output
-            :class:`~.StagedPassManager`. You can see a list of installed plugins by using
-            :func:`~.list_stage_plugins` with ``"layout"`` for the ``stage_name`` argument.
-        routing_method (str): The pass to use for routing qubits on the
-            architecture. Valid choices are ``'basic'``, ``'lookahead'``, ``'stochastic'``,
-            ``'sabre'``, and ``'none'`` representing :class:`~.BasicSwap`,
-            :class:`~.LookaheadSwap`, :class:`~.StochasticSwap`, :class:`~.SabreSwap`, and
-            erroring if routing is required respectively. This can also be the external plugin
-            name to use for the ``routing`` stage of the output :class:`~.StagedPassManager`.
-            You can see a list of installed plugins by using :func:`~.list_stage_plugins` with
-            ``"routing"`` for the ``stage_name`` argument.
-        translation_method (str): The method to use for translating gates to
-            basis gates. Valid choices ``'translator'``, ``'synthesis'`` representing
-            :class:`~.BasisTranslator`, and :class:`~.UnitarySynthesis` respectively. This can
-            also be the external plugin name to use for the ``translation`` stage of the output
-            :class:`~.StagedPassManager`. You can see a list of installed plugins by using
-            :func:`~.list_stage_plugins` with ``"translation"`` for the ``stage_name`` argument.
-        scheduling_method (str): The pass to use for scheduling instructions. Valid choices
-            are ``'alap'`` and ``'asap'``. This can also be the external plugin name to use
-            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
-            the transpiler.
-        unitary_synthesis_method (str): The name of the unitary synthesis
-            method to use. By default ``'default'`` is used. You can see a list of
-            installed plugins with :func:`.unitary_synthesis_plugin_names`.
-        unitary_synthesis_plugin_config (dict): An optional configuration dictionary
-            that will be passed directly to the unitary synthesis plugin. By
-            default this setting will have no effect as the default unitary
-            synthesis method does not take custom configuration. This should
-            only be necessary when a unitary synthesis plugin is specified with
-            the ``unitary_synthesis_method`` argument. As this is custom for each
-            unitary synthesis plugin refer to the plugin documentation for how
-            to use this option.
-        hls_config (HLSConfig): An optional configuration class :class:`~.HLSConfig`
-            that will be passed directly to :class:`~.HighLevelSynthesis` transformation pass.
-            This configuration class allows to specify for various high-level objects
-            the lists of synthesis algorithms and their parameters.
-        init_method (str): The plugin name to use for the ``init`` stage of
-            the output :class:`~.StagedPassManager`. By default an external
-            plugin is not used. You can see a list of installed plugins by
-            using :func:`~.list_stage_plugins` with ``"init"`` for the stage
-            name argument.
-        optimization_method (str): The plugin name to use for the
-            ``optimization`` stage of the output
-            :class:`~.StagedPassManager`. By default an external
-            plugin is not used. You can see a list of installed plugins by
-            using :func:`~.list_stage_plugins` with ``"optimization"`` for the
-            ``stage_name`` argument.
-
-    Returns:
-        StagedPassManager: The preset pass manager for the given options
-
-    Raises:
-        ValueError: if an invalid value for ``optimization_level`` is passed in.
-    """
-
-    if coupling_map is not None and not isinstance(coupling_map, CouplingMap):
-        coupling_map = CouplingMap(coupling_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.instruction_schedule_map()
-        if timing_constraints is None:
-            timing_constraints = target.timing_constraints()
-        if backend_properties is None:
-            backend_properties = target_to_backend_properties(target)
-
-    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,
-        "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,
-        "initial_layout": initial_layout,
-        "hls_config": hls_config,
-        "init_method": init_method,
-        "optimization_method": optimization_method,
-    }
-
-    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
-
-
 __all__ = [
     "level_0_pass_manager",
     "level_1_pass_manager",

qiskit/transpiler/preset_passmanagers/builtin_plugins.py

@@ -12,6 +12,10 @@
 
 """Built-in transpiler stage plugins for preset pass managers."""
 
+import os
+
+from qiskit.circuit import Instruction
+from qiskit.transpiler.passes.optimization.split_2q_unitaries import Split2QUnitaries
 from qiskit.transpiler.passmanager import PassManager
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.transpiler.passes import BasicSwap
@@ -62,7 +66,22 @@ from qiskit.circuit.library.standard_gates import (
     CYGate,
     SXGate,
     SXdgGate,
+    get_standard_gate_name_mapping,
 )
+from qiskit.utils.parallel import CPU_COUNT
+from qiskit import user_config
+
+CONFIG = user_config.get_config()
+
+_discrete_skipped_ops = {
+    "delay",
+    "reset",
+    "measure",
+    "switch_case",
+    "if_else",
+    "for_loop",
+    "while_loop",
+}
 
 
 class DefaultInitPassManager(PassManagerStagePlugin):
@@ -154,6 +173,58 @@ class DefaultInitPassManager(PassManagerStagePlugin):
                 )
             )
             init.append(CommutativeCancellation())
+            # skip peephole optimization before routing if target basis gate set is discrete,
+            # i.e. only consists of Cliffords that an user might want to keep
+            # use rz, sx, x, cx as basis, rely on physical optimziation to fix everything later one
+            stdgates = get_standard_gate_name_mapping()
+
+            def _is_one_op_non_discrete(ops):
+                """Checks if one operation in `ops` is not discrete, i.e. is parameterizable
+                Args:
+                    ops (List(Operation)): list of operations to check
+                Returns
+                    True if at least one operation in `ops` is not discrete, False otherwise
+                """
+                found_one_continuous_gate = False
+                for op in ops:
+                    if isinstance(op, str):
+                        if op in _discrete_skipped_ops:
+                            continue
+                        op = stdgates.get(op, None)
+
+                    if op is not None and op.name in _discrete_skipped_ops:
+                        continue
+
+                    if op is None or not isinstance(op, Instruction):
+                        return False
+
+                    if len(op.params) > 0:
+                        found_one_continuous_gate = True
+                return found_one_continuous_gate
+
+            target = pass_manager_config.target
+            basis = pass_manager_config.basis_gates
+            # consolidate gates before routing if the user did not specify a discrete basis gate, i.e.
+            # * no target or basis gate set has been specified
+            # * target has been specified, and we have one non-discrete gate in the target's spec
+            # * basis gates have been specified, and we have one non-discrete gate in that set
+            do_consolidate_blocks_init = target is None and basis is None
+            do_consolidate_blocks_init |= target is not None and _is_one_op_non_discrete(
+                target.operations
+            )
+            do_consolidate_blocks_init |= basis is not None and _is_one_op_non_discrete(basis)
+
+            if do_consolidate_blocks_init:
+                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
+                # qubits being used to figure out the fidelity so just use the default fidelity parameter
+                # in this case.
+                if pass_manager_config.approximation_degree is not None:
+                    init.append(Split2QUnitaries(pass_manager_config.approximation_degree))
+                else:
+                    init.append(Split2QUnitaries())
         else:
             raise TranspilerError(f"Invalid optimization level {optimization_level}")
         return init
@@ -397,11 +468,12 @@ class SabreSwapPassManager(PassManagerStagePlugin):
             pass_manager_config.initial_layout,
         )
         if optimization_level == 0:
+            trial_count = _get_trial_count(5)
             routing_pass = SabreSwap(
                 coupling_map_routing,
                 heuristic="basic",
                 seed=seed_transpiler,
-                trials=5,
+                trials=trial_count,
             )
             return common.generate_routing_passmanager(
                 routing_pass,
@@ -411,11 +483,12 @@ class SabreSwapPassManager(PassManagerStagePlugin):
                 use_barrier_before_measurement=True,
             )
         if optimization_level == 1:
+            trial_count = _get_trial_count(5)
             routing_pass = SabreSwap(
                 coupling_map_routing,
                 heuristic="decay",
                 seed=seed_transpiler,
-                trials=5,
+                trials=trial_count,
             )
             return common.generate_routing_passmanager(
                 routing_pass,
@@ -429,11 +502,13 @@ class SabreSwapPassManager(PassManagerStagePlugin):
                 use_barrier_before_measurement=True,
             )
         if optimization_level == 2:
+            trial_count = _get_trial_count(20)
+
             routing_pass = SabreSwap(
                 coupling_map_routing,
                 heuristic="decay",
                 seed=seed_transpiler,
-                trials=10,
+                trials=trial_count,
             )
             return common.generate_routing_passmanager(
                 routing_pass,
@@ -446,11 +521,12 @@ class SabreSwapPassManager(PassManagerStagePlugin):
                 use_barrier_before_measurement=True,
             )
         if optimization_level == 3:
+            trial_count = _get_trial_count(20)
             routing_pass = SabreSwap(
                 coupling_map_routing,
                 heuristic="decay",
                 seed=seed_transpiler,
-                trials=20,
+                trials=trial_count,
             )
             return common.generate_routing_passmanager(
                 routing_pass,
@@ -737,12 +813,15 @@ class DefaultLayoutPassManager(PassManagerStagePlugin):
                 max_trials=2500,  # Limits layout scoring to < 600ms on ~400 qubit devices
             )
             layout.append(ConditionalController(choose_layout_1, condition=_layout_not_perfect))
+
+            trial_count = _get_trial_count(5)
+
             choose_layout_2 = SabreLayout(
                 coupling_map,
                 max_iterations=2,
                 seed=pass_manager_config.seed_transpiler,
-                swap_trials=5,
-                layout_trials=5,
+                swap_trials=trial_count,
+                layout_trials=trial_count,
                 skip_routing=pass_manager_config.routing_method is not None
                 and pass_manager_config.routing_method != "sabre",
             )
@@ -769,12 +848,15 @@ class DefaultLayoutPassManager(PassManagerStagePlugin):
             layout.append(
                 ConditionalController(choose_layout_0, condition=_choose_layout_condition)
             )
+
+            trial_count = _get_trial_count(20)
+
             choose_layout_1 = SabreLayout(
                 coupling_map,
                 max_iterations=2,
                 seed=pass_manager_config.seed_transpiler,
-                swap_trials=20,
-                layout_trials=20,
+                swap_trials=trial_count,
+                layout_trials=trial_count,
                 skip_routing=pass_manager_config.routing_method is not None
                 and pass_manager_config.routing_method != "sabre",
             )
@@ -801,12 +883,15 @@ class DefaultLayoutPassManager(PassManagerStagePlugin):
             layout.append(
                 ConditionalController(choose_layout_0, condition=_choose_layout_condition)
             )
+
+            trial_count = _get_trial_count(20)
+
             choose_layout_1 = SabreLayout(
                 coupling_map,
                 max_iterations=4,
                 seed=pass_manager_config.seed_transpiler,
-                swap_trials=20,
-                layout_trials=20,
+                swap_trials=trial_count,
+                layout_trials=trial_count,
                 skip_routing=pass_manager_config.routing_method is not None
                 and pass_manager_config.routing_method != "sabre",
             )
@@ -902,42 +987,50 @@ class SabreLayoutPassManager(PassManagerStagePlugin):
         layout = PassManager()
         layout.append(_given_layout)
         if optimization_level == 0:
+            trial_count = _get_trial_count(5)
+
             layout_pass = SabreLayout(
                 coupling_map,
                 max_iterations=1,
                 seed=pass_manager_config.seed_transpiler,
-                swap_trials=5,
-                layout_trials=5,
+                swap_trials=trial_count,
+                layout_trials=trial_count,
                 skip_routing=pass_manager_config.routing_method is not None
                 and pass_manager_config.routing_method != "sabre",
             )
         elif optimization_level == 1:
+            trial_count = _get_trial_count(5)
+
             layout_pass = SabreLayout(
                 coupling_map,
                 max_iterations=2,
                 seed=pass_manager_config.seed_transpiler,
-                swap_trials=5,
-                layout_trials=5,
+                swap_trials=trial_count,
+                layout_trials=trial_count,
                 skip_routing=pass_manager_config.routing_method is not None
                 and pass_manager_config.routing_method != "sabre",
             )
         elif optimization_level == 2:
+            trial_count = _get_trial_count(20)
+
             layout_pass = SabreLayout(
                 coupling_map,
                 max_iterations=2,
                 seed=pass_manager_config.seed_transpiler,
-                swap_trials=20,
-                layout_trials=20,
+                swap_trials=trial_count,
+                layout_trials=trial_count,
                 skip_routing=pass_manager_config.routing_method is not None
                 and pass_manager_config.routing_method != "sabre",
             )
         elif optimization_level == 3:
+            trial_count = _get_trial_count(20)
+
             layout_pass = SabreLayout(
                 coupling_map,
                 max_iterations=4,
                 seed=pass_manager_config.seed_transpiler,
-                swap_trials=20,
-                layout_trials=20,
+                swap_trials=trial_count,
+                layout_trials=trial_count,
                 skip_routing=pass_manager_config.routing_method is not None
                 and pass_manager_config.routing_method != "sabre",
             )
@@ -957,3 +1050,9 @@ class SabreLayoutPassManager(PassManagerStagePlugin):
         embed = common.generate_embed_passmanager(coupling_map)
         layout.append(ConditionalController(embed.to_flow_controller(), condition=_swap_mapped))
         return layout
+
+
+def _get_trial_count(default_trials=5):
+    if CONFIG.get("sabre_all_threads", None) or os.getenv("QISKIT_SABRE_ALL_THREADS"):
+        return max(CPU_COUNT, default_trials)
+    return default_trials

qiskit/transpiler/preset_passmanagers/common.py

@@ -364,10 +364,7 @@ def generate_routing_passmanager(
         routing.append(ConditionalController(ApplyLayout(), condition=_apply_post_layout_condition))
 
     def filter_fn(node):
-        return (
-            getattr(node.op, "label", None)
-            != "qiskit.transpiler.internal.routing.protection.barrier"
-        )
+        return node.label != "qiskit.transpiler.internal.routing.protection.barrier"
 
     routing.append([FilterOpNodes(filter_fn)])
 
@@ -518,7 +515,7 @@ def generate_translation_passmanager(
             ),
         ]
     else:
-        raise TranspilerError("Invalid translation method %s." % method)
+        raise TranspilerError(f"Invalid translation method {method}.")
     return PassManager(unroll)
 
 
@@ -557,7 +554,7 @@ def generate_scheduling(
         try:
             scheduling.append(scheduler[scheduling_method](instruction_durations, target=target))
         except KeyError as ex:
-            raise TranspilerError("Invalid scheduling method %s." % scheduling_method) from ex
+            raise TranspilerError(f"Invalid scheduling method {scheduling_method}.") from ex
     elif instruction_durations:
         # No scheduling. But do unit conversion for delays.
         def _contains_delay(property_set):