qiskit 1.4.0__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0rc1__cp39-abi3-macosx_11_0_arm64.whl

qiskit/transpiler/passes/utils/__init__.py

@@ -24,7 +24,6 @@ from .error import Error
 from .remove_barriers import RemoveBarriers
 from .contains_instruction import ContainsInstruction
 from .gates_basis import GatesInBasis
-from .convert_conditions_to_if_ops import ConvertConditionsToIfOps
 from .unroll_forloops import UnrollForLoops
 from .minimum_point import MinimumPoint
 from .filter_op_nodes import FilterOpNodes

qiskit/transpiler/passes/utils/check_gate_direction.py

@@ -45,8 +45,16 @@ class CheckGateDirection(AnalysisPass):
         Args:
             dag (DAGCircuit): DAG to check.
         """
-        self.property_set["is_direction_mapped"] = (
-            check_gate_direction_target(dag, self.target)
-            if self.target
-            else check_gate_direction_coupling(dag, set(self.coupling_map.get_edges()))
-        )
+        # Only use "check_gate_direction_target" if a target exists and target.operation_names
+        # is not empty, else use "check_gate_direction_coupling".
+        if self.target is None:
+            self.property_set["is_direction_mapped"] = check_gate_direction_coupling(
+                dag, set(self.coupling_map.get_edges())
+            )
+        elif len(self.target.operation_names) == 0:
+            # A  _FakeTarget path, no basis gates, just use the coupling map
+            self.property_set["is_direction_mapped"] = check_gate_direction_coupling(
+                dag, set(self.target.build_coupling_map().get_edges())
+            )
+        else:
+            self.property_set["is_direction_mapped"] = check_gate_direction_target(dag, self.target)

qiskit/transpiler/passes/utils/control_flow.py

@@ -54,12 +54,8 @@ def trivial_recurse(method):
         def bound_wrapped_method(dag):
             return out(self, dag)
 
-        control_flow_nodes = dag.control_flow_op_nodes()
-        if control_flow_nodes is not None:
-            for node in control_flow_nodes:
-                dag.substitute_node(
-                    node, map_blocks(bound_wrapped_method, node.op), propagate_condition=False
-                )
+        for node in dag.control_flow_op_nodes():
+            dag.substitute_node(node, map_blocks(bound_wrapped_method, node.op))
         return method(self, dag)
 
     return out

qiskit/transpiler/passes/utils/gate_direction.py

@@ -81,6 +81,13 @@ class GateDirection(TransformationPass):
             TranspilerError: If the circuit cannot be mapped just by flipping the
                 cx nodes.
         """
+        # Only use "fix_gate_direction_target" if a target exists and target.operation_names
+        # is not empty, else use "fix_gate_direction_coupling".
         if self.target is None:
             return fix_gate_direction_coupling(dag, set(self.coupling_map.get_edges()))
+        elif len(self.target.operation_names) == 0:
+            # A  _FakeTarget path, no basis gates, just use the coupling map
+            return fix_gate_direction_coupling(
+                dag, set(self.target.build_coupling_map().get_edges())
+            )
         return fix_gate_direction_target(dag, self.target)

qiskit/transpiler/passes/utils/remove_final_measurements.py

@@ -13,7 +13,45 @@
 """Remove final measurements and barriers at the end of a circuit."""
 
 from qiskit.transpiler.basepasses import TransformationPass
-from qiskit.dagcircuit import DAGOpNode
+from qiskit.dagcircuit import DAGCircuit, DAGOpNode
+
+
+def calc_final_ops(dag: DAGCircuit, final_op_names: set[str]) -> list[DAGOpNode]:
+    """Find the final operations of a circuit of a given type.
+    Args:
+        dag: the DAG circuit
+        final_op_names: names of the operations to find at the end of the circuit.
+
+    Returns:
+    List of nodes corresponding the the relevant operations at the end of the circuit.
+    """
+    final_ops = []
+
+    to_visit = [next(dag.predecessors(dag.output_map[qubit])) for qubit in dag.qubits]
+    barrier_encounters_remaining = {}
+
+    while to_visit:
+        node = to_visit.pop()
+        if not isinstance(node, DAGOpNode):
+            continue
+
+        if node.op.name == "barrier":
+            # Barrier is final if all children are final, so we track
+            # how many times we still need to encounter each barrier
+            # via a child node.
+            if node not in barrier_encounters_remaining:
+                barrier_encounters_remaining[node] = sum(1 for _ in dag.quantum_successors(node))
+            if barrier_encounters_remaining[node] - 1 > 0:
+                # We've encountered the barrier, but not (yet) via all children.
+                # Record the encounter, and bail!
+                barrier_encounters_remaining[node] -= 1
+                continue
+        if node.name in final_op_names:
+            # Current node is either a measure, or a barrier with all final op children.
+            final_ops.append(node)
+            to_visit.extend(dag.quantum_predecessors(node))
+
+    return final_ops
 
 
 class RemoveFinalMeasurements(TransformationPass):
@@ -32,37 +70,6 @@ class RemoveFinalMeasurements(TransformationPass):
     in a classical register that will remain.
     """
 
-    def _calc_final_ops(self, dag):
-        final_op_types = {"measure", "barrier"}
-        final_ops = []
-
-        to_visit = [next(dag.predecessors(dag.output_map[qubit])) for qubit in dag.qubits]
-        barrier_encounters_remaining = {}
-
-        while to_visit:
-            node = to_visit.pop()
-            if not isinstance(node, DAGOpNode):
-                continue
-            if node.op.name == "barrier":
-                # Barrier is final if all children are final, so we track
-                # how many times we still need to encounter each barrier
-                # via a child node.
-                if node not in barrier_encounters_remaining:
-                    barrier_encounters_remaining[node] = sum(
-                        1 for _ in dag.quantum_successors(node)
-                    )
-                if barrier_encounters_remaining[node] - 1 > 0:
-                    # We've encountered the barrier, but not (yet) via all children.
-                    # Record the encounter, and bail!
-                    barrier_encounters_remaining[node] -= 1
-                    continue
-            if node.name in final_op_types:
-                # Current node is either a measure, or a barrier with all final op children.
-                final_ops.append(node)
-                to_visit.extend(dag.quantum_predecessors(node))
-
-        return final_ops
-
     def run(self, dag):
         """Run the RemoveFinalMeasurements pass on `dag`.
 
@@ -72,7 +79,7 @@ class RemoveFinalMeasurements(TransformationPass):
         Returns:
             DAGCircuit: the optimized DAG.
         """
-        final_ops = self._calc_final_ops(dag)
+        final_ops = calc_final_ops(dag, {"measure", "barrier"})
         if not final_ops:
             return dag
 

qiskit/transpiler/passmanager.py

@@ -174,6 +174,8 @@ class PassManager(BasePassManager):
         output_name: str | None = None,
         callback: Callable = None,
         num_processes: int = None,
+        *,
+        property_set: dict[str, object] | None = None,
     ) -> _CircuitsT:
         """Run all the passes on the specified ``circuits``.
 
@@ -216,6 +218,11 @@ class PassManager(BasePassManager):
                 execution is enabled. This argument overrides ``num_processes`` in the user
                 configuration file, and the ``QISKIT_NUM_PROCS`` environment variable. If set
                 to ``None`` the system default or local user configuration will be used.
+            property_set: If given, the initial value to use as the :class:`.PropertySet` for the
+                pass manager pipeline.  This can be used to persist analysis from one run to
+                another, in cases where you know the analysis is safe to share.  Beware that some
+                analysis will be specific to the input circuit and the particular :class:`.Target`,
+                so you should take a lot of care when using this argument.
 
         Returns:
             The transformed circuit(s).
@@ -228,6 +235,7 @@ class PassManager(BasePassManager):
             callback=callback,
             output_name=output_name,
             num_processes=num_processes,
+            property_set=property_set,
         )
 
     def draw(self, filename=None, style=None, raw=False):
@@ -436,6 +444,8 @@ class StagedPassManager(PassManager):
         output_name: str | None = None,
         callback: Callable | None = None,
         num_processes: int = None,
+        *,
+        property_set: dict[str, object] | None = None,
     ) -> _CircuitsT:
         self._update_passmanager()
         return super().run(circuits, output_name, callback, num_processes=num_processes)
@@ -462,6 +472,9 @@ def _replace_error(meth):
     def wrapper(*meth_args, **meth_kwargs):
         try:
             return meth(*meth_args, **meth_kwargs)
+        except TranspilerError:
+            # If it's already a `TranspilerError` subclass, don't erase the extra information.
+            raise
         except PassManagerError as ex:
             raise TranspilerError(ex.message) from ex
 

qiskit/transpiler/passmanager_config.py

@@ -12,41 +12,20 @@
 
 """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
-from qiskit.utils.deprecation import deprecate_arg
-
 
 class PassManagerConfig:
     """Pass Manager Configuration."""
 
-    @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 `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.",
-    )
-    @deprecate_pulse_arg("inst_map", predicate=lambda inst_map: inst_map is not None)
     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,
@@ -64,7 +43,6 @@ class PassManagerConfig:
             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
@@ -80,9 +58,6 @@ class PassManagerConfig:
                 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
@@ -104,7 +79,6 @@ class PassManagerConfig:
         """
         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
@@ -113,7 +87,6 @@ class PassManagerConfig:
         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
@@ -130,14 +103,8 @@ class PassManagerConfig:
         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 or BackendV2): The backend that provides the configuration.
+            backend (BackendV2): The backend that provides the configuration.
             pass_manager_options: User-defined option-value pairs.
 
         Returns:
@@ -146,51 +113,15 @@ class PassManagerConfig:
         Raises:
             AttributeError: If the backend does not support a `configuration()` method.
         """
-        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)
-            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
+            res.basis_gates = backend.operation_names
         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
+            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()
+            res.instruction_durations = backend.instruction_durations
         if res.target is None and not _skip_target:
-            if backend_version >= 2:
-                res.target = backend.target
+            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"):
@@ -200,23 +131,16 @@ class PassManagerConfig:
     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"