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

qiskit/converters/dagdependency_to_circuit.py

@@ -34,12 +34,6 @@ def dagdependency_to_circuit(dagdependency):
     )
     circuit.metadata = dagdependency.metadata
 
-    if hasattr(dagdependency, "_calibrations_prop"):
-        circuit._calibrations_prop = dagdependency._calibrations_prop
-    else:
-        # This can be _DAGDependencyV2
-        circuit._calibrations_prop = dagdependency.calibrations
-
     for node in dagdependency.topological_nodes():
         circuit._append(CircuitInstruction(node.op.copy(), node.qargs, node.cargs))
 

qiskit/converters/dagdependency_to_dag.py

@@ -12,7 +12,6 @@
 
 """Helper function for converting a dag dependency to a dag circuit"""
 from qiskit.dagcircuit.dagcircuit import DAGCircuit
-from qiskit.dagcircuit.dagdependency import DAGDependency
 
 
 def dagdependency_to_dag(dagdependency):
@@ -45,10 +44,5 @@ def dagdependency_to_dag(dagdependency):
 
     # copy metadata
     dagcircuit.global_phase = dagdependency.global_phase
-    if isinstance(dagdependency, DAGDependency):
-        dagcircuit._calibrations_prop = dagdependency._calibrations_prop
-    else:
-        # This can be _DAGDependencyV2
-        dagcircuit._calibrations_prop = dagdependency.calibrations
 
     return dagcircuit

qiskit/dagcircuit/collect_blocks.py

@@ -139,7 +139,9 @@ class BlockCollector:
         """Returns whether there are uncollected (pending) nodes"""
         return len(self._pending_nodes) > 0
 
-    def collect_matching_block(self, filter_fn: Callable) -> list[DAGOpNode | DAGDepNode]:
+    def collect_matching_block(
+        self, filter_fn: Callable, max_block_width: int | None
+    ) -> list[DAGOpNode | DAGDepNode]:
         """Iteratively collects the largest block of input nodes (that is, nodes with
         ``_in_degree`` equal to 0) that match a given filtering function.
         Examples of this include collecting blocks of swap gates,
@@ -150,6 +152,7 @@ class BlockCollector:
         Returns the block of collected nodes.
         """
         current_block = []
+        current_block_qargs = set()
         unprocessed_pending_nodes = self._pending_nodes
         self._pending_nodes = []
 
@@ -158,19 +161,28 @@ class BlockCollector:
         # - any node that match filter_fn is added to the current_block,
         #   and some of its successors may be moved to unprocessed_pending_nodes.
         while unprocessed_pending_nodes:
-            new_pending_nodes = []
-            for node in unprocessed_pending_nodes:
-                if filter_fn(node):
-                    current_block.append(node)
-
-                    # update the _in_degree of node's successors
-                    for suc in self._direct_succs(node):
-                        self._in_degree[suc] -= 1
-                        if self._in_degree[suc] == 0:
-                            new_pending_nodes.append(suc)
-                else:
-                    self._pending_nodes.append(node)
-            unprocessed_pending_nodes = new_pending_nodes
+            node = unprocessed_pending_nodes.pop()
+
+            if max_block_width is not None:
+                # for efficiency, only update new_qargs when max_block_width is specified
+                new_qargs = current_block_qargs.copy()
+                new_qargs.update(node.qargs)
+                width_within_budget = len(new_qargs) <= max_block_width
+            else:
+                new_qargs = set()
+                width_within_budget = True
+
+            if filter_fn(node) and width_within_budget:
+                current_block.append(node)
+                current_block_qargs = new_qargs
+
+                # update the _in_degree of node's successors
+                for suc in self._direct_succs(node):
+                    self._in_degree[suc] -= 1
+                    if self._in_degree[suc] == 0:
+                        unprocessed_pending_nodes.append(suc)
+            else:
+                self._pending_nodes.append(node)
 
         return current_block
 
@@ -181,6 +193,7 @@ class BlockCollector:
         min_block_size=2,
         split_layers=False,
         collect_from_back=False,
+        max_block_width=None,
     ):
         """Collects all blocks that match a given filtering function filter_fn.
         This iteratively finds the largest block that does not match filter_fn,
@@ -193,6 +206,8 @@ class BlockCollector:
         qubit subsets. The option ``split_layers`` allows to split collected blocks
         into layers of non-overlapping instructions. The option ``min_block_size``
         specifies the minimum number of gates in the block for the block to be collected.
+        The option ``max_block_width`` specificies the maximum number of qubits over
+        which a block can be defined.
 
         By default, blocks are collected in the direction from the inputs towards the outputs
         of the circuit. The option ``collect_from_back`` allows to change this direction,
@@ -212,8 +227,8 @@ class BlockCollector:
         # Iteratively collect non-matching and matching blocks.
         matching_blocks: list[list[DAGOpNode | DAGDepNode]] = []
         while self._have_uncollected_nodes():
-            self.collect_matching_block(not_filter_fn)
-            matching_block = self.collect_matching_block(filter_fn)
+            self.collect_matching_block(not_filter_fn, max_block_width=None)
+            matching_block = self.collect_matching_block(filter_fn, max_block_width=max_block_width)
             if matching_block:
                 matching_blocks.append(matching_block)
 
@@ -377,10 +392,7 @@ class BlockCollapser:
             wire_pos_map.update({qb: ix for ix, qb in enumerate(sorted_clbits)})
 
             for node in block:
-                instructions = qc.append(CircuitInstruction(node.op, node.qargs, node.cargs))
-                cond = getattr(node.op, "_condition", None)
-                if cond is not None:
-                    instructions.c_if(*cond)
+                qc.append(CircuitInstruction(node.op, node.qargs, node.cargs))
 
             # Collapse this quantum circuit into an operation.
             op = collapse_fn(qc)

qiskit/dagcircuit/dagdependency.py

@@ -17,19 +17,17 @@ from __future__ import annotations
 import math
 import heapq
 import typing
-from collections import OrderedDict, defaultdict
+from collections import OrderedDict
 from collections.abc import Iterator
 
 import rustworkx as rx
 
 from qiskit.circuit.commutation_library import SessionCommutationChecker as scc
 from qiskit.circuit.controlflow import condition_resources
-from qiskit.circuit.quantumregister import QuantumRegister, Qubit
-from qiskit.circuit.classicalregister import ClassicalRegister, Clbit
+from qiskit.circuit import QuantumRegister, Qubit
+from qiskit.circuit import ClassicalRegister, Clbit
 from qiskit.dagcircuit.exceptions import DAGDependencyError
 from qiskit.dagcircuit.dagdepnode import DAGDepNode
-from qiskit.pulse import Schedule
-from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
 
 if typing.TYPE_CHECKING:
     from qiskit.circuit.parameterexpression import ParameterExpression
@@ -115,7 +113,6 @@ class DAGDependency:
         self.clbits = []
 
         self._global_phase: float | ParameterExpression = 0.0
-        self._calibrations: dict[str, dict[tuple, Schedule]] = defaultdict(dict)
 
         self.duration = None
         self.unit = "dt"
@@ -146,37 +143,6 @@ class DAGDependency:
             else:
                 self._global_phase = angle % (2 * math.pi)
 
-    @property
-    @deprecate_pulse_dependency(is_property=True)
-    def calibrations(self) -> dict[str, dict[tuple, Schedule]]:
-        """Return calibration dictionary.
-
-        The custom pulse definition of a given gate is of the form
-        ``{'gate_name': {(qubits, params): schedule}}``.
-        """
-        return self._calibrations_prop
-
-    @calibrations.setter
-    @deprecate_pulse_dependency(is_property=True)
-    def calibrations(self, calibrations: dict[str, dict[tuple, Schedule]]):
-        """Set the circuit calibration data from a dictionary of calibration definition.
-
-        Args:
-            calibrations (dict): A dictionary of input in the format
-                {'gate_name': {(qubits, gate_params): schedule}}
-        """
-        self._calibrations_prop = calibrations
-
-    @property
-    def _calibrations_prop(self) -> dict[str, dict[tuple, Schedule]]:
-        """An alternative path to be used internally to avoid deprecation warnings"""
-        return dict(self._calibrations)
-
-    @_calibrations_prop.setter
-    def _calibrations_prop(self, calibrations: dict[str, dict[tuple, Schedule]]):
-        """An alternative path to be used internally to avoid deprecation warnings"""
-        self._calibrations = defaultdict(dict, calibrations)
-
     def to_retworkx(self):
         """Returns the DAGDependency in retworkx format."""
         return self._multi_graph

qiskit/dagcircuit/dagdependency_v2.py

@@ -15,10 +15,9 @@
 
 import itertools
 import math
-from collections import OrderedDict, defaultdict, namedtuple
+from collections import OrderedDict, namedtuple
 from typing import Dict, List, Generator, Any
 
-import numpy as np
 import rustworkx as rx
 
 from qiskit.circuit import (
@@ -26,11 +25,10 @@ from qiskit.circuit import (
     ClassicalRegister,
     Qubit,
     Clbit,
-    Gate,
     ParameterExpression,
 )
 from qiskit.circuit.controlflow import condition_resources
-from qiskit.circuit.bit import Bit
+from qiskit.circuit import Bit
 from qiskit.dagcircuit.dagnode import DAGOpNode
 from qiskit.dagcircuit.exceptions import DAGDependencyError
 from qiskit.circuit.commutation_checker import CommutationChecker
@@ -110,7 +108,6 @@ class _DAGDependencyV2:
         self._clbit_indices: Dict[Clbit, BitLocations] = {}
 
         self._global_phase = 0
-        self._calibrations = defaultdict(dict)
 
         # Map of number of each kind of op, keyed on op name
         self._op_names = {}
@@ -142,81 +139,6 @@ class _DAGDependencyV2:
             else:
                 self._global_phase = angle % (2 * math.pi)
 
-    @property
-    def calibrations(self):
-        """Return calibration dictionary.
-
-        The custom pulse definition of a given gate is of the form
-        ``{'gate_name': {(qubits, params): schedule}}``.
-        """
-        return dict(self._calibrations)
-
-    @calibrations.setter
-    def calibrations(self, calibrations):
-        """Set the circuit calibration data from a dictionary of calibration definition.
-
-        Args:
-            calibrations (dict): A dictionary of input in the format
-                {'gate_name': {(qubits, gate_params): schedule}}
-        """
-        self._calibrations = defaultdict(dict, calibrations)
-
-    def add_calibration(self, gate, qubits, schedule, params=None):
-        """Register a low-level, custom pulse definition for the given gate.
-
-        Args:
-            gate (Union[Gate, str]): Gate information.
-            qubits (Union[int, Tuple[int]]): List of qubits to be measured.
-            schedule (Schedule): Schedule information.
-            params (Optional[List[Union[float, Parameter]]]): A list of parameters.
-
-        Raises:
-            Exception: if the gate is of type string and params is None.
-        """
-
-        def _format(operand):
-            try:
-                # Using float/complex value as a dict key is not good idea.
-                # This makes the mapping quite sensitive to the rounding error.
-                # However, the mechanism is already tied to the execution model (i.e. pulse gate)
-                # and we cannot easily update this rule.
-                # The same logic exists in QuantumCircuit.add_calibration.
-                evaluated = complex(operand)
-                if np.isreal(evaluated):
-                    evaluated = float(evaluated.real)
-                    if evaluated.is_integer():
-                        evaluated = int(evaluated)
-                return evaluated
-            except TypeError:
-                # Unassigned parameter
-                return operand
-
-        if isinstance(gate, Gate):
-            params = gate.params
-            gate = gate.name
-        if params is not None:
-            params = tuple(map(_format, params))
-        else:
-            params = ()
-
-        self._calibrations[gate][(tuple(qubits), params)] = schedule
-
-    def has_calibration_for(self, node):
-        """Return True if the dag has a calibration defined for the node operation. In this
-        case, the operation does not need to be translated to the device basis.
-        """
-        if not self.calibrations or node.op.name not in self.calibrations:
-            return False
-        qubits = tuple(self.qubits.index(qubit) for qubit in node.qargs)
-        params = []
-        for p in node.op.params:
-            if isinstance(p, ParameterExpression) and not p.parameters:
-                params.append(float(p))
-            else:
-                params.append(p)
-        params = tuple(params)
-        return (qubits, params) in self.calibrations[node.op.name]
-
     def size(self):
         """Returns the number of gates in the circuit"""
         return len(self._multi_graph)

qiskit/dagcircuit/dagnode.py

@@ -19,6 +19,7 @@ import uuid
 
 import qiskit._accelerate.circuit
 from qiskit.circuit import (
+    BoxOp,
     Clbit,
     ClassicalRegister,
     IfElseOp,
@@ -92,8 +93,12 @@ def _make_expr_key(bit_indices):
 
 
 def _condition_op_eq(node1, node2, bit_indices1, bit_indices2):
-    cond1 = node1.condition
-    cond2 = node2.condition
+    cond1 = None
+    cond2 = None
+    if node1.is_control_flow():
+        cond1 = node1.op.condition
+    if node2.is_control_flow():
+        cond2 = node2.op.condition
     if isinstance(cond1, expr.Expr) and isinstance(cond2, expr.Expr):
         if not expr.structurally_equivalent(
             cond1, cond2, _make_expr_key(bit_indices1), _make_expr_key(bit_indices2)
@@ -166,11 +171,18 @@ def _for_loop_eq(node1, node2, bit_indices1, bit_indices2):
     )
 
 
+def _box_eq(node1, node2, bit_indices1, bit_indices2):
+    return node1.op.duration == node2.op.duration and _circuit_to_dag(
+        node1.op.blocks[0], node1.qargs, node1.cargs, bit_indices1
+    ) == _circuit_to_dag(node2.op.blocks[0], node2.qargs, node2.cargs, bit_indices2)
+
+
 _SEMANTIC_EQ_CONTROL_FLOW = {
     IfElseOp: _condition_op_eq,
     WhileLoopOp: _condition_op_eq,
     SwitchCaseOp: _switch_case_eq,
     ForLoopOp: _for_loop_eq,
+    BoxOp: _box_eq,
 }
 
 _SEMANTIC_EQ_SYMMETRIC = frozenset({"barrier", "swap", "break_loop", "continue_loop"})

qiskit/passmanager/__init__.py

@@ -87,7 +87,10 @@ Such task might be easily done by converting the input numbers into string.
 We use the pass manager framework here, putting the efficiency aside for
 a moment to learn how to build a custom Qiskit compiler.
 
-.. code-block:: python
+.. plot::
+   :include-source:
+   :nofigs:
+   :context:
 
     from qiskit.passmanager import BasePassManager, GenericPass, ConditionalController
 
@@ -111,7 +114,10 @@ the final conversion.
 
 Next, we implement a pass that removes a digit when the number is five.
 
-.. code-block:: python
+.. plot::
+   :include-source:
+   :nofigs:
+   :context:
 
     class RemoveFive(GenericPass):
 
@@ -124,7 +130,10 @@ Finally, we instantiate a pass manager and schedule the task with it.
 Running the pass manager with random row of numbers returns
 new numbers that don't contain five.
 
-.. code-block:: python
+.. plot::
+   :include-source:
+   :nofigs:
+   :context:
 
     pm = ToyPassManager()
     pm.append(task)
@@ -143,7 +152,10 @@ six digits or less. Such control can be implemented by a flow controller.
 We start from an analysis pass that provides the flow controller
 with information about the number of digits.
 
-.. code-block:: python
+.. plot::
+   :include-source:
+   :nofigs:
+   :context:
 
     class CountDigits(GenericPass):
 
@@ -155,7 +167,10 @@ with information about the number of digits.
 Then, we wrap the remove five task with the :class:`.ConditionalController`
 that runs the stored tasks only when the condition is met.
 
-.. code-block:: python
+.. plot::
+   :include-source:
+   :nofigs:
+   :context:
 
     def digit_condition(property_set):
         # Return True when condition is met.
@@ -168,7 +183,10 @@ that runs the stored tasks only when the condition is met.
 
 As before, we schedule these passes with the pass manager and run.
 
-.. code-block:: python
+.. plot::
+   :include-source:
+   :nofigs:
+   :context:
 
     pm = ToyPassManager()
     pm.append(analysis_task)

qiskit/passmanager/passmanager.py

@@ -14,7 +14,6 @@
 from __future__ import annotations
 
 import logging
-import warnings
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Iterable
 from itertools import chain
@@ -30,8 +29,6 @@ from .compilation_status import PropertySet, WorkflowStatus, PassManagerState
 
 logger = logging.getLogger(__name__)
 
-_MISSING = object()
-
 
 class BasePassManager(ABC):
     """Pass manager base class."""
@@ -178,7 +175,7 @@ class BasePassManager(ABC):
         callback: Callable = None,
         num_processes: int = None,
         *,
-        property_set: object = _MISSING,
+        property_set: dict[str, object] | None = None,
         **kwargs,
     ) -> Any:
         """Run all the passes on the specified ``in_programs``.
@@ -216,25 +213,16 @@ class BasePassManager(ABC):
                 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: Currently a key that will be interpreted as all other arbitrary
-                ``kwargs``.  In Qiskit 2.0, this will instead seed the :class:`.PropertySet` of the
-                compilation (but does not do so in this version).
+            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.
             kwargs: Arbitrary arguments passed to the compiler frontend and backend.
 
         Returns:
             The transformed program(s).
         """
-        if property_set is not _MISSING:
-            warnings.warn(
-                "From Qiskit 2.0, 'property_set' will be a reserved keyword argument of"
-                " 'BasePassManager.run', and not passed on to the conversion functions."
-                " This subclass of 'BasePassManager' needs to use a different keyword argument"
-                " for passing on this data.",
-                FutureWarning,
-                stacklevel=2,
-            )
-            kwargs["property_set"] = property_set
-
         if not self._tasks and not kwargs and callback is None:
             return in_programs
 
@@ -247,7 +235,13 @@ class BasePassManager(ABC):
         # ourselves, since that can be quite expensive.
         if len(in_programs) == 1 or not should_run_in_parallel(num_processes):
             out = [
-                _run_workflow(program=program, pass_manager=self, callback=callback, **kwargs)
+                _run_workflow(
+                    program=program,
+                    pass_manager=self,
+                    callback=callback,
+                    initial_property_set=property_set,
+                    **kwargs,
+                )
                 for program in in_programs
             ]
             if len(in_programs) == 1 and not is_list:
@@ -264,7 +258,10 @@ class BasePassManager(ABC):
         return parallel_map(
             _run_workflow_in_new_process,
             values=in_programs,
-            task_kwargs={"pass_manager_bin": dill.dumps(self)},
+            task_kwargs={
+                "pass_manager_bin": dill.dumps(self),
+                "initial_property_set": property_set,
+            },
             num_processes=num_processes,
         )
 
@@ -288,6 +285,8 @@ class BasePassManager(ABC):
 def _run_workflow(
     program: Any,
     pass_manager: BasePassManager,
+    *,
+    initial_property_set: dict[str, object] | None = None,
     **kwargs,
 ) -> Any:
     """Run single program optimization with a pass manager.
@@ -307,12 +306,12 @@ def _run_workflow(
         input_program=program,
         **kwargs,
     )
+    property_set = (
+        PropertySet() if initial_property_set is None else PropertySet(initial_property_set)
+    )
     passmanager_ir, final_state = flow_controller.execute(
         passmanager_ir=passmanager_ir,
-        state=PassManagerState(
-            workflow_status=initial_status,
-            property_set=PropertySet(),
-        ),
+        state=PassManagerState(workflow_status=initial_status, property_set=property_set),
         callback=kwargs.get("callback", None),
     )
     # The `property_set` has historically been returned as a mutable attribute on `PassManager`
@@ -335,6 +334,8 @@ def _run_workflow(
 def _run_workflow_in_new_process(
     program: Any,
     pass_manager_bin: bytes,
+    *,
+    initial_property_set: dict[str, object] | None,
 ) -> Any:
     """Run single program optimization in new process.
 
@@ -348,4 +349,5 @@ def _run_workflow_in_new_process(
     return _run_workflow(
         program=program,
         pass_manager=dill.loads(pass_manager_bin),
+        initial_property_set=initial_property_set,
     )