qiskit 1.4.2__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/transpiler/passes/scheduling/time_unit_conversion.py

@@ -12,14 +12,16 @@
 
 """Unify time unit in circuit for scheduling and following passes."""
 from typing import Set
-import warnings
 
-from qiskit.circuit import Delay
+from qiskit.circuit import Delay, Duration
+from qiskit.circuit.classical import expr
+from qiskit.circuit.duration import duration_in_dt
 from qiskit.dagcircuit import DAGCircuit
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.transpiler.instruction_durations import InstructionDurations
 from qiskit.transpiler.target import Target
+from qiskit.utils import apply_prefix
 
 
 class TimeUnitConversion(TransformationPass):
@@ -51,6 +53,7 @@ class TimeUnitConversion(TransformationPass):
         super().__init__()
         self.inst_durations = inst_durations or InstructionDurations()
         if target is not None:
+            # The priority order for instruction durations is: target > standalone.
             self.inst_durations = target.durations()
         self._durations_provided = inst_durations is not None or target is not None
 
@@ -67,88 +70,95 @@ class TimeUnitConversion(TransformationPass):
             TranspilerError: if the units are not unifiable
         """
 
-        inst_durations = self._update_inst_durations(dag)
+        inst_durations = InstructionDurations()
+        if self._durations_provided:
+            inst_durations.update(self.inst_durations, getattr(self.inst_durations, "dt", None))
+
+        # The float-value converted units for delay expressions, either all in 'dt'
+        # or all in seconds.
+        expression_durations = {}
 
         # Choose unit
-        if inst_durations.dt is not None:
-            time_unit = "dt"
-        else:
-            # Check what units are used in delays and other instructions: dt or SI or mixed
-            units_delay = self._units_used_in_delays(dag)
-            if self._unified(units_delay) == "mixed":
+        has_dt = False
+        has_si = False
+
+        # We _always_ need to traverse duration expressions to convert them to
+        # a float. But we also use the opportunity to note if they intermix cycles
+        # and wall-time, in case we don't have a `dt` to use to unify all instruction
+        # durations.
+        for node in dag.op_nodes(op=Delay):
+            if isinstance(node.op.duration, expr.Expr):
+                if any(
+                    isinstance(x, expr.Stretch) for x in expr.iter_identifiers(node.op.duration)
+                ):
+                    # If any of the delays use a stretch expression, we can't run scheduling
+                    # passes anyway, so we bail out. In theory, we _could_ still traverse
+                    # through the stretch expression and replace any Duration value nodes it may
+                    # contain with ones of the same units, but it'd be complex and probably unuseful.
+                    self.property_set["time_unit"] = "stretch"
+                    return dag
+
+                visitor = _EvalDurationImpl(inst_durations.dt)
+                duration = node.op.duration.accept(visitor)
+                if visitor.in_cycles():
+                    has_dt = True
+                    # We need to round in case the expression evaluated to a non-integral 'dt'.
+                    duration = duration_in_dt(duration, 1.0)
+                else:
+                    has_si = True
+                if duration < 0:
+                    raise TranspilerError(
+                        f"Expression '{node.op.duration}' resolves to a negative duration!"
+                    )
+                expression_durations[node._node_id] = duration
+            else:
+                if node.op.unit == "dt":
+                    has_dt = True
+                else:
+                    has_si = True
+            if inst_durations.dt is None and has_dt and has_si:
                 raise TranspilerError(
                     "Fail to unify time units in delays. SI units "
                     "and dt unit must not be mixed when dt is not supplied."
                 )
+
+        if inst_durations.dt is None:
+            # Check what units are used in other instructions: dt or SI or mixed
             units_other = inst_durations.units_used()
-            if self._unified(units_other) == "mixed":
+            unified_unit = self._unified(units_other)
+            has_si = has_si or unified_unit in {"SI", "mixed"}
+            has_dt = has_dt or unified_unit in {"dt", "mixed"}
+            if has_si and has_dt:
                 raise TranspilerError(
-                    "Fail to unify time units in instruction_durations. SI units "
+                    "Fail to unify time units. SI units "
                     "and dt unit must not be mixed when dt is not supplied."
                 )
-
-            unified_unit = self._unified(units_delay | units_other)
-            if unified_unit == "SI":
+            if has_si:
                 time_unit = "s"
-            elif unified_unit == "dt":
-                time_unit = "dt"
             else:
-                raise TranspilerError(
-                    "Fail to unify time units. SI units "
-                    "and dt unit must not be mixed when dt is not supplied."
-                )
+                # Either dt units were used or no units were used and we
+                # default to dt
+                time_unit = "dt"
+        else:
+            time_unit = "dt"
 
-        # Make units consistent
-        for node in dag.op_nodes():
-            try:
-                duration = inst_durations.get(
-                    node.op, [dag.find_bit(qarg).index for qarg in node.qargs], unit=time_unit
-                )
-            except TranspilerError:
-                continue
+        # Make instructions with local durations consistent.
+        for node in dag.op_nodes(Delay):
             op = node.op.to_mutable()
-            op.duration = duration
+            if node._node_id in expression_durations:
+                op.duration = expression_durations[node._node_id]
+            else:
+                op.duration = inst_durations._convert_unit(op.duration, op.unit, time_unit)
             op.unit = time_unit
-            dag.substitute_node(node, op, propagate_condition=False)
+            dag.substitute_node(node, op)
 
         self.property_set["time_unit"] = time_unit
         return dag
 
-    def _update_inst_durations(self, dag):
-        """Update instruction durations with circuit information. If the dag contains gate
-        calibrations and no instruction durations were provided through the target or as a
-        standalone input, the circuit calibration durations will be used.
-        The priority order for instruction durations is: target > standalone > circuit.
-        """
-        circ_durations = InstructionDurations()
-
-        if dag._calibrations_prop:
-            cal_durations = []
-            with warnings.catch_warnings():
-                warnings.simplefilter(action="ignore", category=DeprecationWarning)
-                # `schedule.duration` emits pulse deprecation warnings which we don't want
-                # to see here
-                for gate, gate_cals in dag._calibrations_prop.items():
-                    for (qubits, parameters), schedule in gate_cals.items():
-                        cal_durations.append((gate, qubits, parameters, schedule.duration))
-            circ_durations.update(cal_durations, circ_durations.dt)
-
-        if self._durations_provided:
-            circ_durations.update(self.inst_durations, getattr(self.inst_durations, "dt", None))
-
-        return circ_durations
-
-    @staticmethod
-    def _units_used_in_delays(dag: DAGCircuit) -> Set[str]:
-        units_used = set()
-        for node in dag.op_nodes(op=Delay):
-            units_used.add(node.op.unit)
-        return units_used
-
     @staticmethod
     def _unified(unit_set: Set[str]) -> str:
         if not unit_set:
-            return "dt"
+            return "none"
 
         if len(unit_set) == 1 and "dt" in unit_set:
             return "dt"
@@ -163,3 +173,65 @@ class TimeUnitConversion(TransformationPass):
             return "SI"
 
         return "mixed"
+
+
+class _EvalDurationImpl(expr.ExprVisitor[float]):
+    """Evaluates the expression to a single float result.
+
+    If ``dt`` is provided or all durations are already in ``dt``, the result is in ``dt``.
+    Otherwise, the result will be in seconds, and all durations MUST be in wall-time (SI).
+    """
+
+    __slots__ = ("dt", "has_dt", "has_si")
+
+    def __init__(self, dt=None):
+        self.dt = dt
+        self.has_dt = False
+        self.has_si = False
+
+    def in_cycles(self):
+        """Returns ``True`` if units are 'dt' after visit."""
+        return self.has_dt or self.dt is not None
+
+    def visit_value(self, node, /) -> float:
+        if isinstance(node.value, float):
+            return node.value
+        if isinstance(node.value, Duration.dt):
+            if self.has_si and self.dt is None:
+                raise TranspilerError(
+                    "Fail to unify time units in delays. SI units "
+                    "and dt unit must not be mixed when dt is not supplied."
+                )
+            self.has_dt = True
+            return node.value[0]
+        if isinstance(node.value, Duration):
+            if self.has_dt and self.dt is None:
+                raise TranspilerError(
+                    "Fail to unify time units in delays. SI units "
+                    "and dt unit must not be mixed when dt is not supplied."
+                )
+            self.has_si = True
+            # Setting 'divisor' to 1 when there's no 'dt' is just to simplify
+            # the logic (we don't need to divide).
+            divisor = self.dt if self.dt is not None else 1
+            if isinstance(node.value, Duration.s):
+                return node.value[0] / divisor
+            from_unit = node.value.unit()
+            return apply_prefix(node.value[0], from_unit) / divisor
+        raise TranspilerError(f"invalid duration expression: {node}")
+
+    def visit_binary(self, node, /) -> float:
+        left = node.left.accept(self)
+        right = node.right.accept(self)
+        if node.op == expr.Binary.Op.ADD:
+            return left + right
+        if node.op == expr.Binary.Op.SUB:
+            return left - right
+        if node.op == expr.Binary.Op.MUL:
+            return left * right
+        if node.op == expr.Binary.Op.DIV:
+            return left / right
+        raise TranspilerError(f"invalid duration expression: {node}")
+
+    def visit_cast(self, node, /) -> float:
+        return node.operand.accept(self)