qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/transpiler/passmanager_config.py

@@ -0,0 +1,193 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2020.
+#
+# 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
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Pass Manager Configuration class."""
+
+import pprint
+
+from qiskit.transpiler.coupling import CouplingMap
+from qiskit.transpiler.instruction_durations import InstructionDurations
+
+
+class PassManagerConfig:
+    """Pass Manager Configuration."""
+
+    def __init__(
+        self,
+        initial_layout=None,
+        basis_gates=None,
+        inst_map=None,
+        coupling_map=None,
+        layout_method=None,
+        routing_method=None,
+        translation_method=None,
+        scheduling_method=None,
+        instruction_durations=None,
+        backend_properties=None,
+        approximation_degree=None,
+        seed_transpiler=None,
+        timing_constraints=None,
+        unitary_synthesis_method="default",
+        unitary_synthesis_plugin_config=None,
+        target=None,
+        hls_config=None,
+        init_method=None,
+        optimization_method=None,
+    ):
+        """Initialize a PassManagerConfig object
+
+        Args:
+            initial_layout (Layout): Initial position of virtual qubits on
+                physical qubits.
+            basis_gates (list): List of basis gate names to unroll to.
+            inst_map (InstructionScheduleMap): Mapping object that maps gate to schedule.
+            coupling_map (CouplingMap): Directed graph represented a coupling
+                map.
+            layout_method (str): the pass to use for choosing initial qubit
+                placement. This will be the plugin name if an external layout stage
+                plugin is being used.
+            routing_method (str): the pass to use for routing qubits on the
+                architecture. This will be a plugin name if an external routing stage
+                plugin is being used.
+            translation_method (str): the pass to use for translating gates to
+                basis_gates. This will be a plugin name if an external translation stage
+                plugin is being used.
+            scheduling_method (str): the pass to use for scheduling instructions. This will
+                be a plugin name if an external scheduling stage plugin is being used.
+            instruction_durations (InstructionDurations): Dictionary of duration
+                (in dt) for each instruction.
+            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.
+            timing_constraints (TimingConstraints): Hardware time alignment restrictions.
+            unitary_synthesis_method (str): The string method to use for the
+                :class:`~qiskit.transpiler.passes.UnitarySynthesis` pass. Will
+                search installed plugins for a valid method. You can see a list of
+                installed plugins with :func:`.unitary_synthesis_plugin_names`.
+            target (Target): The backend target
+            hls_config (HLSConfig): An optional configuration class to use for
+                :class:`~qiskit.transpiler.passes.HighLevelSynthesis` pass.
+                Specifies how to synthesize various high-level objects.
+            init_method (str): The plugin name for the init stage plugin to use
+            optimization_method (str): The plugin name for the optimization stage plugin
+                to use.
+        """
+        self.initial_layout = initial_layout
+        self.basis_gates = basis_gates
+        self.inst_map = inst_map
+        self.coupling_map = coupling_map
+        self.init_method = init_method
+        self.layout_method = layout_method
+        self.routing_method = routing_method
+        self.translation_method = translation_method
+        self.optimization_method = optimization_method
+        self.scheduling_method = scheduling_method
+        self.instruction_durations = instruction_durations
+        self.backend_properties = backend_properties
+        self.approximation_degree = approximation_degree
+        self.seed_transpiler = seed_transpiler
+        self.timing_constraints = timing_constraints
+        self.unitary_synthesis_method = unitary_synthesis_method
+        self.unitary_synthesis_plugin_config = unitary_synthesis_plugin_config
+        self.target = target
+        self.hls_config = hls_config
+
+    @classmethod
+    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
+        features. User options can be used to overwrite the configuration.
+
+        Args:
+            backend (BackendV1): The backend that provides the configuration.
+            pass_manager_options: User-defined option-value pairs.
+
+        Returns:
+            PassManagerConfig: The configuration generated based on the arguments.
+
+        Raises:
+            AttributeError: If the backend does not support a `configuration()` method.
+        """
+        res = cls(**pass_manager_options)
+        backend_version = getattr(backend, "version", 0)
+        if not isinstance(backend_version, int):
+            backend_version = 0
+        if backend_version < 2:
+            config = backend.configuration()
+        if res.basis_gates is None:
+            if backend_version < 2:
+                res.basis_gates = getattr(config, "basis_gates", None)
+            else:
+                res.basis_gates = backend.operation_names
+        if res.inst_map is None:
+            if backend_version < 2:
+                if hasattr(backend, "defaults"):
+                    defaults = backend.defaults()
+                    if defaults is not None:
+                        res.inst_map = defaults.instruction_schedule_map
+            else:
+                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)
+                if cmap_edge_list is not None:
+                    res.coupling_map = CouplingMap(cmap_edge_list)
+            else:
+                res.coupling_map = backend.coupling_map
+        if res.instruction_durations is None:
+            if backend_version < 2:
+                res.instruction_durations = InstructionDurations.from_backend(backend)
+            else:
+                res.instruction_durations = backend.instruction_durations
+        if res.backend_properties is None and backend_version < 2:
+            res.backend_properties = backend.properties()
+        if res.target is None and not _skip_target:
+            if backend_version >= 2:
+                res.target = backend.target
+        if res.scheduling_method is None and hasattr(backend, "get_scheduling_stage_plugin"):
+            res.scheduling_method = backend.get_scheduling_stage_plugin()
+        if res.translation_method is None and hasattr(backend, "get_translation_stage_plugin"):
+            res.translation_method = backend.get_translation_stage_plugin()
+        return res
+
+    def __str__(self):
+        newline = "\n"
+        newline_tab = "\n\t"
+        if self.backend_properties is not None:
+            backend_props = pprint.pformat(self.backend_properties.to_dict())
+            backend_props = backend_props.replace(newline, newline_tab)
+        else:
+            backend_props = str(None)
+        return (
+            "Pass Manager Config:\n"
+            f"\tinitial_layout: {self.initial_layout}\n"
+            f"\tbasis_gates: {self.basis_gates}\n"
+            f"\tinst_map: {str(self.inst_map).replace(newline, newline_tab)}\n"
+            f"\tcoupling_map: {self.coupling_map}\n"
+            f"\tlayout_method: {self.layout_method}\n"
+            f"\trouting_method: {self.routing_method}\n"
+            f"\ttranslation_method: {self.translation_method}\n"
+            f"\tscheduling_method: {self.scheduling_method}\n"
+            f"\tinstruction_durations: {str(self.instruction_durations).replace(newline, newline_tab)}\n"
+            f"\tbackend_properties: {backend_props}\n"
+            f"\tapproximation_degree: {self.approximation_degree}\n"
+            f"\tseed_transpiler: {self.seed_transpiler}\n"
+            f"\ttiming_constraints: {self.timing_constraints}\n"
+            f"\tunitary_synthesis_method: {self.unitary_synthesis_method}\n"
+            f"\tunitary_synthesis_plugin_config: {self.unitary_synthesis_plugin_config}\n"
+            f"\ttarget: {str(self.target).replace(newline, newline_tab)}\n"
+        )

qiskit/transpiler/preset_passmanagers/__init__.py

@@ -0,0 +1,280 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# 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
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""
+==================================================================
+Preset Passmanagers (:mod:`qiskit.transpiler.preset_passmanagers`)
+==================================================================
+
+.. currentmodule:: qiskit.transpiler.preset_passmanagers
+
+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.
+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
+second includes functions which are used to build (either entirely or in
+part) the stages which the preset pass managers are composed of
+(:ref:`stage_generators`).
+
+.. _preset_pass_manager_generators:
+
+Preset Pass Manager Generation
+------------------------------
+
+.. autofunction:: generate_preset_pass_manager
+.. autofunction:: level_0_pass_manager
+.. autofunction:: level_1_pass_manager
+.. autofunction:: level_2_pass_manager
+.. autofunction:: level_3_pass_manager
+
+.. _stage_generators:
+
+Stage Generator Functions
+-------------------------
+
+.. currentmodule:: qiskit.transpiler.preset_passmanagers.common
+.. autofunction:: generate_control_flow_options_check
+.. autofunction:: generate_error_on_control_flow
+.. autofunction:: generate_unroll_3q
+.. autofunction:: generate_embed_passmanager
+.. autofunction:: generate_routing_passmanager
+.. autofunction:: generate_pre_op_passmanager
+.. autofunction:: generate_translation_passmanager
+.. 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 .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=None,
+    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. A preset pass
+    manager 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 transpile
+
+
+    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``,
+            ``couplig_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): 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'``, ``'noise_adaptive'``,
+            and, ``'sabre'`` representing :class:`~.TrivialLayout`, :class:`~DenseLayout`,
+            :class:`~.NoiseAdaptiveLayout`, :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 ``'unroller'``, ``'translator'``, ``'synthesis'``
+            representing :class:`~.Unroller`, :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`` 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 translation_method == "unroller":
+        warnings.warn(
+            "The 'unroller' translation_method plugin is deprecated as of Qiskit 0.45.0 and "
+            "will be removed in a future release. Instead you should use the default "
+            "'translator' method or another plugin.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+    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",
+    "level_2_pass_manager",
+    "level_3_pass_manager",
+    "generate_preset_pass_manager",
+]