qiskit 1.4.2__cp39-abi3-win_amd64.whl → 2.0.0rc2__cp39-abi3-win_amd64.whl

qiskit/transpiler/preset_passmanagers/common.py

@@ -14,7 +14,6 @@
 """Common preset passmanager generators."""
 
 import collections
-import warnings
 from typing import Optional
 
 from qiskit.circuit.equivalence_library import SessionEquivalenceLibrary as sel
@@ -42,34 +41,34 @@ from qiskit.transpiler.passes import EnlargeWithAncilla
 from qiskit.transpiler.passes import ApplyLayout
 from qiskit.transpiler.passes import RemoveResetInZeroState
 from qiskit.transpiler.passes import FilterOpNodes
-from qiskit.transpiler.passes import ValidatePulseGates
 from qiskit.transpiler.passes import PadDelay
 from qiskit.transpiler.passes import InstructionDurationCheck
 from qiskit.transpiler.passes import ConstrainedReschedule
-from qiskit.transpiler.passes import PulseGates
 from qiskit.transpiler.passes import ContainsInstruction
 from qiskit.transpiler.passes import VF2PostLayout
 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
-from qiskit.utils.deprecation import deprecate_arg
+from qiskit.utils import deprecate_func
+
 
 _ControlFlowState = collections.namedtuple("_ControlFlowState", ("working", "not_working"))
 
 # Any method neither known good nor known bad (i.e. not a Terra-internal pass) is passed through
 # without error, since it is being supplied by a plugin and we don't have any knowledge of these.
 _CONTROL_FLOW_STATES = {
-    "layout_method": _ControlFlowState(working={"trivial", "dense", "sabre"}, not_working=set()),
+    "layout_method": _ControlFlowState(
+        working={"default", "trivial", "dense", "sabre"}, not_working=set()
+    ),
     "routing_method": _ControlFlowState(
-        working={"none", "stochastic", "sabre"}, not_working={"lookahead", "basic"}
+        working={"default", "none", "stochastic", "sabre"}, not_working={"lookahead", "basic"}
     ),
     "translation_method": _ControlFlowState(
-        working={"translator", "synthesis"},
+        working={"default", "translator", "synthesis"},
         not_working=set(),
     ),
-    "optimization_method": _ControlFlowState(working=set(), not_working=set()),
+    "optimization_method": _ControlFlowState(working={"default"}, not_working=set()),
     "scheduling_method": _ControlFlowState(working=set(), not_working={"alap", "asap"}),
 }
 
@@ -86,9 +85,9 @@ class _InvalidControlFlowForBackend:
     # Explicitly stateful closure to allow pickling.
 
     def __init__(self, basis_gates=(), target=None):
-        if target is not None:
+        if target is not None and len(target.operation_names) > 0:
             self.unsupported = [op for op in CONTROL_FLOW_OP_NAMES if op not in target]
-        elif basis_gates is not None:
+        elif basis_gates is not None and len(basis_gates) > 0:
             basis_gates = set(basis_gates)
             self.unsupported = [op for op in CONTROL_FLOW_OP_NAMES if op not in basis_gates]
         else:
@@ -276,23 +275,12 @@ def _apply_post_layout_condition(property_set):
     )
 
 
-@deprecate_arg(
-    name="backend_properties",
-    since="1.4",
-    package_name="Qiskit",
-    removal_timeline="in Qiskit 2.0",
-    additional_msg="The BackendProperties data structure has been deprecated and will be "
-    "removed in Qiskit 2.0. The required `target` input argument should be used "
-    "instead. You can use Target.from_configuration() to build the target from the properties "
-    "object, but in 2.0 you will need to generate a target directly.",
-)
 def generate_routing_passmanager(
     routing_pass,
     target,
     coupling_map=None,
     vf2_call_limit=None,
-    backend_properties=None,
-    seed_transpiler=None,
+    seed_transpiler=-1,
     check_trivial=False,
     use_barrier_before_measurement=True,
     vf2_max_trials=None,
@@ -308,10 +296,11 @@ def generate_routing_passmanager(
         vf2_call_limit (int): The internal call limit for the vf2 post layout
             pass. If this is ``None`` or ``0`` the vf2 post layout will not be
             run.
-        backend_properties (BackendProperties): Properties of a backend to
-            synthesize for (e.g. gate fidelities).
         seed_transpiler (int): Sets random seed for the stochastic parts of
-            the transpiler.
+            the transpiler. This is currently only used for :class:`.VF2PostLayout` and the
+            default value of ``-1`` is strongly recommended (which is no randomization).
+            If a value of ``None`` is provided this will seed from system
+            entropy.
         check_trivial (bool): If set to true this will condition running the
             :class:`~.VF2PostLayout` pass after routing on whether a trivial
             layout was tried and was found to not be perfect. This is only
@@ -362,34 +351,19 @@ def generate_routing_passmanager(
         routing.append(ConditionalController(routing_pass, condition=_swap_condition))
 
     is_vf2_fully_bounded = vf2_call_limit and vf2_max_trials
-    if (target is not None or backend_properties is not None) and is_vf2_fully_bounded:
-        with warnings.catch_warnings():
-            warnings.filterwarnings(
-                "ignore",
-                category=DeprecationWarning,
-                message=".*argument ``properties`` is deprecated as of Qiskit 1.4",
-                module="qiskit",
-            )
-            warnings.filterwarnings(
-                "ignore",
-                category=DeprecationWarning,
-                message=".*argument ``coupling_map`` is deprecated as of Qiskit 1.4",
-                module="qiskit",
-            )
-            routing.append(
-                ConditionalController(
-                    VF2PostLayout(
-                        target,
-                        coupling_map,
-                        backend_properties,
-                        seed_transpiler,
-                        call_limit=vf2_call_limit,
-                        max_trials=vf2_max_trials,
-                        strict_direction=False,
-                    ),
-                    condition=_run_post_layout_condition,
-                )
+    if target is not None and is_vf2_fully_bounded:
+        routing.append(
+            ConditionalController(
+                VF2PostLayout(
+                    target,
+                    seed=seed_transpiler,
+                    call_limit=vf2_call_limit,
+                    max_trials=vf2_max_trials,
+                    strict_direction=False,
+                ),
+                condition=_run_post_layout_condition,
             )
+        )
         routing.append(ConditionalController(ApplyLayout(), condition=_apply_post_layout_condition))
 
     def filter_fn(node):
@@ -400,11 +374,19 @@ def generate_routing_passmanager(
     return routing
 
 
+@deprecate_func(
+    since="2.0",
+    additional_msg=(
+        "Translation plugins are now required to respect ISA directionality,"
+        " so typically no replacement is necessary."
+    ),
+    removal_timeline="in Qiskit 3.0",
+)
 def generate_pre_op_passmanager(target=None, coupling_map=None, remove_reset_in_zero=False):
     """Generate a pre-optimization loop :class:`~qiskit.transpiler.PassManager`
 
     This pass manager will check to ensure that directionality from the coupling
-    map is respected
+    map is respected.
 
     Args:
         target (Target): the :class:`~.Target` object representing the backend
@@ -433,23 +415,12 @@ def generate_pre_op_passmanager(target=None, coupling_map=None, remove_reset_in_
     return pre_opt
 
 
-@deprecate_arg(
-    name="backend_properties",
-    since="1.4",
-    package_name="Qiskit",
-    removal_timeline="in Qiskit 2.0",
-    additional_msg="The BackendProperties data structure has been deprecated and will be "
-    "removed in Qiskit 2.0. The required `target` input argument should be used "
-    "instead. You can use Target.from_configuration() to build the target from the properties "
-    "object, but in 2.0 you will need to generate a target directly.",
-)
 def generate_translation_passmanager(
     target,
     basis_gates=None,
     method="translator",
     approximation_degree=None,
     coupling_map=None,
-    backend_props=None,
     unitary_synthesis_method="default",
     unitary_synthesis_plugin_config=None,
     hls_config=None,
@@ -472,8 +443,6 @@ def generate_translation_passmanager(
         unitary_synthesis_plugin_config (dict): The optional dictionary plugin
             configuration, this is plugin specific refer to the specified plugin's
             documentation for how to use.
-        backend_props (BackendProperties): Properties of a backend to
-            synthesize for (e.g. gate fidelities).
         unitary_synthesis_method (str): The unitary synthesis method to use. You can
             see a list of installed plugins with :func:`.unitary_synthesis_plugin_names`.
         hls_config (HLSConfig): An optional configuration class to use for
@@ -488,102 +457,116 @@ def generate_translation_passmanager(
     Raises:
         TranspilerError: If the ``method`` kwarg is not a valid value
     """
+    if basis_gates is None and target is None:
+        return PassManager([])
+
     if method == "translator":
-        with warnings.catch_warnings():
-            warnings.filterwarnings(
-                "ignore",
-                category=DeprecationWarning,
-                message=".*argument ``backend_props`` is deprecated as of Qiskit 1.4",
-                module="qiskit",
-            )
-            unroll = [
-                # Use unitary synthesis for basis aware decomposition of
-                # UnitaryGates before custom unrolling
-                UnitarySynthesis(
-                    basis_gates,
-                    approximation_degree=approximation_degree,
-                    coupling_map=coupling_map,
-                    backend_props=backend_props,
-                    plugin_config=unitary_synthesis_plugin_config,
-                    method=unitary_synthesis_method,
-                    target=target,
-                ),
-                HighLevelSynthesis(
-                    hls_config=hls_config,
-                    coupling_map=coupling_map,
-                    target=target,
-                    use_qubit_indices=True,
-                    equivalence_library=sel,
-                    basis_gates=basis_gates,
-                    qubits_initially_zero=qubits_initially_zero,
-                ),
-                BasisTranslator(sel, basis_gates, target),
-            ]
+        translator = BasisTranslator(sel, basis_gates, target)
+        unroll = [
+            # Use unitary synthesis for basis aware decomposition of
+            # UnitaryGates before custom unrolling
+            UnitarySynthesis(
+                basis_gates,
+                approximation_degree=approximation_degree,
+                coupling_map=coupling_map,
+                plugin_config=unitary_synthesis_plugin_config,
+                method=unitary_synthesis_method,
+                target=target,
+            ),
+            HighLevelSynthesis(
+                hls_config=hls_config,
+                coupling_map=coupling_map,
+                target=target,
+                use_qubit_indices=True,
+                equivalence_library=sel,
+                basis_gates=basis_gates,
+                qubits_initially_zero=qubits_initially_zero,
+            ),
+            translator,
+        ]
+        fix_1q = [translator]
     elif method == "synthesis":
-        with warnings.catch_warnings():
-            warnings.filterwarnings(
-                "ignore",
-                category=DeprecationWarning,
-                message=".*argument ``backend_props`` is deprecated as of Qiskit 1.4",
-                module="qiskit",
-            )
-            unroll = [
-                # Use unitary synthesis for basis aware decomposition of
-                # UnitaryGates > 2q before collection
-                UnitarySynthesis(
-                    basis_gates,
-                    approximation_degree=approximation_degree,
-                    coupling_map=coupling_map,
-                    backend_props=backend_props,
-                    plugin_config=unitary_synthesis_plugin_config,
-                    method=unitary_synthesis_method,
-                    min_qubits=3,
-                    target=target,
-                ),
-                HighLevelSynthesis(
-                    hls_config=hls_config,
-                    coupling_map=coupling_map,
-                    target=target,
-                    use_qubit_indices=True,
-                    basis_gates=basis_gates,
-                    min_qubits=3,
-                    qubits_initially_zero=qubits_initially_zero,
-                ),
-                Unroll3qOrMore(target=target, basis_gates=basis_gates),
-                Collect2qBlocks(),
-                Collect1qRuns(),
-                ConsolidateBlocks(
-                    basis_gates=basis_gates,
-                    target=target,
-                    approximation_degree=approximation_degree,
-                ),
-                UnitarySynthesis(
-                    basis_gates=basis_gates,
-                    approximation_degree=approximation_degree,
-                    coupling_map=coupling_map,
-                    backend_props=backend_props,
-                    plugin_config=unitary_synthesis_plugin_config,
-                    method=unitary_synthesis_method,
-                    target=target,
-                ),
-                HighLevelSynthesis(
-                    hls_config=hls_config,
-                    coupling_map=coupling_map,
-                    target=target,
-                    use_qubit_indices=True,
-                    basis_gates=basis_gates,
-                    qubits_initially_zero=qubits_initially_zero,
-                ),
-            ]
+        unroll = [
+            # # Use unitary synthesis for basis aware decomposition of
+            # UnitaryGates > 2q before collection
+            UnitarySynthesis(
+                basis_gates,
+                approximation_degree=approximation_degree,
+                coupling_map=coupling_map,
+                plugin_config=unitary_synthesis_plugin_config,
+                method=unitary_synthesis_method,
+                min_qubits=3,
+                target=target,
+            ),
+            HighLevelSynthesis(
+                hls_config=hls_config,
+                coupling_map=coupling_map,
+                target=target,
+                use_qubit_indices=True,
+                basis_gates=basis_gates,
+                min_qubits=3,
+                qubits_initially_zero=qubits_initially_zero,
+            ),
+            Unroll3qOrMore(target=target, basis_gates=basis_gates),
+            Collect2qBlocks(),
+            Collect1qRuns(),
+            ConsolidateBlocks(
+                basis_gates=basis_gates, target=target, approximation_degree=approximation_degree
+            ),
+            UnitarySynthesis(
+                basis_gates=basis_gates,
+                approximation_degree=approximation_degree,
+                coupling_map=coupling_map,
+                plugin_config=unitary_synthesis_plugin_config,
+                method=unitary_synthesis_method,
+                target=target,
+            ),
+            HighLevelSynthesis(
+                hls_config=hls_config,
+                coupling_map=coupling_map,
+                target=target,
+                use_qubit_indices=True,
+                basis_gates=basis_gates,
+                qubits_initially_zero=qubits_initially_zero,
+            ),
+        ]
+        fix_1q = [
+            Collect1qRuns(),
+            ConsolidateBlocks(
+                basis_gates=basis_gates, target=target, approximation_degree=approximation_degree
+            ),
+            UnitarySynthesis(
+                basis_gates=basis_gates,
+                approximation_degree=approximation_degree,
+                coupling_map=coupling_map,
+                plugin_config=unitary_synthesis_plugin_config,
+                method=unitary_synthesis_method,
+                target=target,
+            ),
+        ]
     else:
         raise TranspilerError(f"Invalid translation method {method}.")
+    # Our built-ins don't 100% guarantee that 2q gate direction is respected, so we might need to
+    # run a little bit of fix up on them.  `GateDirection` doesn't guarantee that 1q gates are
+    # ISA safe after it runs, so we need another run too.
+    if (coupling_map and not coupling_map.is_symmetric) or (
+        target is not None and target.get_non_global_operation_names(strict_direction=True)
+    ):
+        unroll.append(CheckGateDirection(coupling_map, target=target))
+
+        def _direction_condition(property_set):
+            return not property_set["is_direction_mapped"]
+
+        unroll.append(
+            ConditionalController(
+                [GateDirection(coupling_map, target=target)] + fix_1q,
+                condition=_direction_condition,
+            )
+        )
     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
-):
+def generate_scheduling(instruction_durations, scheduling_method, timing_constraints, target=None):
     """Generate a post optimization scheduling :class:`~qiskit.transpiler.PassManager`
 
     Args:
@@ -592,7 +575,6 @@ def generate_scheduling(
             ``'asap'``/``'as_soon_as_possible'`` or
             ``'alap'``/``'as_late_as_possible'``
         timing_constraints (TimingConstraints): Hardware time alignment restrictions.
-        inst_map (InstructionScheduleMap): DEPRECATED. Mapping object that maps gate to schedule.
         target (Target): The :class:`~.Target` object representing the backend
 
     Returns:
@@ -602,8 +584,6 @@ def generate_scheduling(
         TranspilerError: If the ``scheduling_method`` kwarg is not a valid value
     """
     scheduling = PassManager()
-    if inst_map and inst_map.has_custom_gate():
-        scheduling.append(PulseGates(inst_map=inst_map, target=target))
     if scheduling_method:
         # Do scheduling after unit conversion.
         scheduler = {
@@ -656,16 +636,9 @@ def generate_scheduling(
                 condition=_require_alignment,
             )
         )
-        scheduling.append(
-            ValidatePulseGates(
-                granularity=timing_constraints.granularity,
-                min_length=timing_constraints.min_length,
-                target=target,
-            )
-        )
     if scheduling_method:
         # Call padding pass if circuit is scheduled
-        scheduling.append(PadDelay(target=target))
+        scheduling.append(PadDelay(target=target, durations=instruction_durations))
 
     return scheduling