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

qiskit/transpiler/passes/scheduling/padding/dynamical_decoupling.py

@@ -14,7 +14,6 @@
 from __future__ import annotations
 
 import logging
-import warnings
 import numpy as np
 
 from qiskit.circuit import Gate, ParameterExpression, Qubit
@@ -59,9 +58,10 @@ class PadDynamicalDecoupling(BasePadding):
         import numpy as np
         from qiskit.circuit import QuantumCircuit
         from qiskit.circuit.library import XGate
-        from qiskit.transpiler import PassManager, InstructionDurations
+        from qiskit.transpiler import PassManager, InstructionDurations, Target, CouplingMap
         from qiskit.transpiler.passes import ALAPScheduleAnalysis, PadDynamicalDecoupling
         from qiskit.visualization import timeline_drawer
+
         circ = QuantumCircuit(4)
         circ.h(0)
         circ.cx(0, 1)
@@ -71,7 +71,15 @@ class PadDynamicalDecoupling(BasePadding):
         durations = InstructionDurations(
             [("h", 0, 50), ("cx", [0, 1], 700), ("reset", None, 10),
              ("cx", [1, 2], 200), ("cx", [2, 3], 300),
-             ("x", None, 50), ("measure", None, 1000)]
+             ("x", None, 50), ("measure", None, 1000)],
+            dt=1e-7
+        )
+        target = Target.from_configuration(
+            ["h", "cx", "reset", "x", "measure"],
+            num_qubits=4,
+            coupling_map=CouplingMap.from_line(4, bidirectional=False),
+            instruction_durations=durations,
+            dt=1e-7,
         )
 
         # balanced X-X sequence on all qubits
@@ -79,7 +87,7 @@ class PadDynamicalDecoupling(BasePadding):
         pm = PassManager([ALAPScheduleAnalysis(durations),
                           PadDynamicalDecoupling(durations, dd_sequence)])
         circ_dd = pm.run(circ)
-        timeline_drawer(circ_dd)
+        timeline_drawer(circ_dd, target=target)
 
         # Uhrig sequence on qubit 0
         n = 8
@@ -97,7 +105,7 @@ class PadDynamicalDecoupling(BasePadding):
             ]
         )
         circ_dd = pm.run(circ)
-        timeline_drawer(circ_dd)
+        timeline_drawer(circ_dd, target=target)
 
     .. note::
 
@@ -158,7 +166,7 @@ class PadDynamicalDecoupling(BasePadding):
                 non-multiple of the alignment constraint value is found.
             TypeError: If ``dd_sequence`` is not specified
         """
-        super().__init__(target=target)
+        super().__init__(target=target, durations=durations)
         self._durations = durations
         if dd_sequence is None:
             raise TypeError("required argument 'dd_sequence' is not specified")
@@ -173,6 +181,7 @@ class PadDynamicalDecoupling(BasePadding):
         self._dd_sequence_lengths: dict[Qubit, list[int]] = {}
         self._sequence_phase = 0
         if target is not None:
+            # The priority order for instruction durations is: target > standalone.
             self._durations = target.durations()
             self._alignment = target.pulse_alignment
             for gate in dd_sequence:
@@ -181,35 +190,12 @@ class PadDynamicalDecoupling(BasePadding):
                         f"{gate.name} in dd_sequence is not supported in the target"
                     )
 
-    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 is not None:
-            circ_durations.update(self._durations, getattr(self._durations, "dt", None))
-
-        return circ_durations
-
     def _pre_runhook(self, dag: DAGCircuit):
         super()._pre_runhook(dag)
 
-        durations = self._update_inst_durations(dag)
-
+        durations = InstructionDurations()
+        if self._durations is not None:
+            durations.update(self._durations, getattr(self._durations, "dt", None))
         num_pulses = len(self._dd_sequence)
 
         # Check if physical circuit is given
@@ -255,31 +241,7 @@ class PadDynamicalDecoupling(BasePadding):
 
             sequence_lengths = []
             for index, gate in enumerate(self._dd_sequence):
-                try:
-                    # Check calibration.
-                    params = self._resolve_params(gate)
-                    with warnings.catch_warnings():
-                        warnings.simplefilter(action="ignore", category=DeprecationWarning)
-                        # `schedule.duration` emits pulse deprecation warnings which we don't want
-                        # to see here
-                        gate_length = dag._calibrations_prop[gate.name][
-                            ((physical_index,), params)
-                        ].duration
-                    if gate_length % self._alignment != 0:
-                        # This is necessary to implement lightweight scheduling logic for this pass.
-                        # Usually the pulse alignment constraint and pulse data chunk size take
-                        # the same value, however, we can intentionally violate this pattern
-                        # at the gate level. For example, we can create a schedule consisting of
-                        # a pi-pulse of 32 dt followed by a post buffer, i.e. delay, of 4 dt
-                        # on the device with 16 dt constraint. Note that the pi-pulse length
-                        # is multiple of 16 dt but the gate length of 36 is not multiple of it.
-                        # Such pulse gate should be excluded.
-                        raise TranspilerError(
-                            f"Pulse gate {gate.name} with length non-multiple of {self._alignment} "
-                            f"is not acceptable in {self.__class__.__name__} pass."
-                        )
-                except KeyError:
-                    gate_length = durations.get(gate, physical_index)
+                gate_length = durations.get(gate, physical_index)
                 sequence_lengths.append(gate_length)
                 # Update gate duration. This is necessary for current timeline drawer, i.e. scheduled.
                 gate = gate.to_mutable()
@@ -382,7 +344,7 @@ class PadDynamicalDecoupling(BasePadding):
                 op = prev_node.op
                 theta_l, phi_l, lam_l = op.params
                 op.params = Optimize1qGates.compose_u3(theta, phi, lam, theta_l, phi_l, lam_l)
-                new_prev_node = dag.substitute_node(prev_node, op, propagate_condition=False)
+                new_prev_node = dag.substitute_node(prev_node, op)
                 start_time = self.property_set["node_start_time"].pop(prev_node)
                 if start_time is not None:
                     self.property_set["node_start_time"][new_prev_node] = start_time

qiskit/transpiler/passes/scheduling/padding/pad_delay.py

@@ -16,6 +16,7 @@ from qiskit.circuit import Qubit
 from qiskit.circuit.delay import Delay
 from qiskit.dagcircuit import DAGCircuit, DAGNode, DAGOutNode
 from qiskit.transpiler.target import Target
+from qiskit.transpiler.instruction_durations import InstructionDurations
 
 from .base_padding import BasePadding
 
@@ -25,7 +26,9 @@ class PadDelay(BasePadding):
 
     Consecutive delays will be merged in the output of this pass.
 
-    .. code-block:: python
+    .. plot::
+       :include-source:
+       :nofigs:
 
         from qiskit import QuantumCircuit
         from qiskit.transpiler import InstructionDurations
@@ -54,7 +57,12 @@ class PadDelay(BasePadding):
     See :class:`BasePadding` pass for details.
     """
 
-    def __init__(self, fill_very_end: bool = True, target: Target = None):
+    def __init__(
+        self,
+        fill_very_end: bool = True,
+        target: Target = None,
+        durations: InstructionDurations = None,
+    ):
         """Create new padding delay pass.
 
         Args:
@@ -63,7 +71,7 @@ class PadDelay(BasePadding):
                 If it is supplied and does not support delay instruction on a qubit,
                 padding passes do not pad any idle time of the qubit.
         """
-        super().__init__(target=target)
+        super().__init__(target=target, durations=durations)
         self.fill_very_end = fill_very_end
 
     def _pad(

qiskit/transpiler/passes/scheduling/scheduling/alap.py

@@ -21,8 +21,7 @@ class ALAPScheduleAnalysis(BaseScheduler):
     """ALAP Scheduling pass, which schedules the **stop** time of instructions as late as possible.
 
     See the :ref:`transpiler-scheduling-description` section in the :mod:`qiskit.transpiler`
-    module documentation for the detailed behavior of the control flow
-    operation, i.e. ``c_if``.
+    module documentation for a more detailed explanation.
     """
 
     def run(self, dag):
@@ -40,8 +39,9 @@ class ALAPScheduleAnalysis(BaseScheduler):
         """
         if len(dag.qregs) != 1 or dag.qregs.get("q", None) is None:
             raise TranspilerError("ALAP schedule runs on physical circuits only")
+        if self.property_set["time_unit"] == "stretch":
+            raise TranspilerError("Scheduling cannot run on circuits with stretch durations.")
 
-        conditional_latency = self.property_set.get("conditional_latency", 0)
         clbit_write_latency = self.property_set.get("clbit_write_latency", 0)
 
         node_start_time = {}
@@ -58,43 +58,9 @@ class ALAPScheduleAnalysis(BaseScheduler):
             # the physical meaning of t0 and t1 is flipped here.
             if isinstance(node.op, self.CONDITIONAL_SUPPORTED):
                 t0q = max(idle_before[q] for q in node.qargs)
-                if node.op.condition_bits:
-                    # conditional is bit tricky due to conditional_latency
-                    t0c = max(idle_before[c] for c in node.op.condition_bits)
-                    # Assume following case (t0c > t0q):
-                    #
-                    #                |t0q
-                    # Q ░░░░░░░░░░░░░▒▒▒
-                    # C ░░░░░░░░▒▒▒▒▒▒▒▒
-                    #           |t0c
-                    #
-                    # In this case, there is no actual clbit read before gate.
-                    #
-                    #             |t0q' = t0c - conditional_latency
-                    # Q ░░░░░░░░▒▒▒░░▒▒▒
-                    # C ░░░░░░▒▒▒▒▒▒▒▒▒▒
-                    #         |t1c' = t0c + conditional_latency
-                    #
-                    # rather than naively doing
-                    #
-                    #        |t1q' = t0c + duration
-                    # Q ░░░░░▒▒▒░░░░░▒▒▒
-                    # C ░░▒▒░░░░▒▒▒▒▒▒▒▒
-                    #     |t1c' = t0c + duration + conditional_latency
-                    #
-                    t0 = max(t0q, t0c - op_duration)
-                    t1 = t0 + op_duration
-                    for clbit in node.op.condition_bits:
-                        idle_before[clbit] = t1 + conditional_latency
-                else:
-                    t0 = t0q
-                    t1 = t0 + op_duration
+                t0 = t0q
+                t1 = t0 + op_duration
             else:
-                if node.op.condition_bits:
-                    raise TranspilerError(
-                        f"Conditional instruction {node.op.name} is not supported in ALAP scheduler."
-                    )
-
                 if isinstance(node.op, Measure):
                     # clbit time is always right (alap) justified
                     t0 = max(idle_before[bit] for bit in node.qargs + node.cargs)

qiskit/transpiler/passes/scheduling/scheduling/asap.py

@@ -21,8 +21,7 @@ class ASAPScheduleAnalysis(BaseScheduler):
     """ASAP Scheduling pass, which schedules the start time of instructions as early as possible.
 
     See the :ref:`transpiler-scheduling-description` section in the :mod:`qiskit.transpiler`
-    module documentation for the detailed behavior of the control flow
-    operation, i.e. ``c_if``.
+    module documentation for a more detailed description.
     """
 
     def run(self, dag):
@@ -40,8 +39,9 @@ class ASAPScheduleAnalysis(BaseScheduler):
         """
         if len(dag.qregs) != 1 or dag.qregs.get("q", None) is None:
             raise TranspilerError("ASAP schedule runs on physical circuits only")
+        if self.property_set["time_unit"] == "stretch":
+            raise TranspilerError("Scheduling cannot run on circuits with stretch durations.")
 
-        conditional_latency = self.property_set.get("conditional_latency", 0)
         clbit_write_latency = self.property_set.get("clbit_write_latency", 0)
 
         node_start_time = {}
@@ -54,40 +54,9 @@ class ASAPScheduleAnalysis(BaseScheduler):
             # t1: end time of instruction
             if isinstance(node.op, self.CONDITIONAL_SUPPORTED):
                 t0q = max(idle_after[q] for q in node.qargs)
-                if node.op.condition_bits:
-                    # conditional is bit tricky due to conditional_latency
-                    t0c = max(idle_after[bit] for bit in node.op.condition_bits)
-                    if t0q > t0c:
-                        # This is situation something like below
-                        #
-                        #           |t0q
-                        # Q ▒▒▒▒▒▒▒▒▒░░
-                        # C ▒▒▒░░░░░░░░
-                        #     |t0c
-                        #
-                        # In this case, you can insert readout access before tq0
-                        #
-                        #           |t0q
-                        # Q ▒▒▒▒▒▒▒▒▒▒▒
-                        # C ▒▒▒░░░▒▒░░░
-                        #         |t0q - conditional_latency
-                        #
-                        t0c = max(t0q - conditional_latency, t0c)
-                    t1c = t0c + conditional_latency
-                    for bit in node.op.condition_bits:
-                        # Lock clbit until state is read
-                        idle_after[bit] = t1c
-                    # It starts after register read access
-                    t0 = max(t0q, t1c)
-                else:
-                    t0 = t0q
+                t0 = t0q
                 t1 = t0 + op_duration
             else:
-                if node.op.condition_bits:
-                    raise TranspilerError(
-                        f"Conditional instruction {node.op.name} is not supported in ASAP scheduler."
-                    )
-
                 if isinstance(node.op, Measure):
                     # measure instruction handling is bit tricky due to clbit_write_latency
                     t0q = max(idle_after[q] for q in node.qargs)

qiskit/transpiler/passes/scheduling/scheduling/base_scheduler.py

@@ -56,29 +56,23 @@ class BaseScheduler(AnalysisPass):
             )
         self.property_set["node_start_time"] = {}
 
-    @staticmethod
     def _get_node_duration(
+        self,
         node: DAGOpNode,
         dag: DAGCircuit,
     ) -> int:
-        """A helper method to get duration from node or calibration."""
+        """A helper method to get duration from node"""
         indices = [dag.find_bit(qarg).index for qarg in node.qargs]
 
-        if dag._has_calibration_for(node):
-            # If node has calibration, this value should be the highest priority
-            cal_key = tuple(indices), tuple(float(p) for p in node.op.params)
-            with warnings.catch_warnings():
-                warnings.simplefilter(action="ignore", category=DeprecationWarning)
-                # `schedule.duration` emits pulse deprecation warnings which we don't want
-                # to see here
-                duration = dag._calibrations_prop[node.op.name][cal_key].duration
-
-            # Note that node duration is updated (but this is analysis pass)
-            op = node.op.to_mutable()
-            op.duration = duration
-            dag.substitute_node(node, op, propagate_condition=False)
+        if node.name == "delay":
+            # `TimeUnitConversion` already handled the unit conversions.
+            duration = node.op.duration
         else:
-            duration = node.duration
+            unit = "s" if self.durations.dt is None else "dt"
+            try:
+                duration = self.durations.get(node.name, indices, unit=unit)
+            except TranspilerError:
+                duration = None
 
         if isinstance(duration, ParameterExpression):
             raise TranspilerError(

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,84 +70,87 @@ 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."
                 )
-            units_other = inst_durations.units_used()
-            if self._unified(units_other) == "mixed":
-                raise TranspilerError(
-                    "Fail to unify time units in instruction_durations. 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 inst_durations.dt is None:
+            # Check what units are used in other instructions: dt or SI or mixed
+            units_other = inst_durations.units_used()
+            unified_unit = self._unified(units_other)
+            if unified_unit == "SI" and not has_dt:
                 time_unit = "s"
-            elif unified_unit == "dt":
+            elif unified_unit == "dt" and not has_si:
                 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."
                 )
+        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:
@@ -163,3 +169,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)