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/padding/base_padding.py

@@ -22,6 +22,7 @@ from qiskit.dagcircuit import DAGCircuit, DAGNode
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.transpiler.target import Target
+from qiskit.transpiler.instruction_durations import InstructionDurations
 
 logger = logging.getLogger(__name__)
 
@@ -57,6 +58,7 @@ class BasePadding(TransformationPass):
     def __init__(
         self,
         target: Target = None,
+        durations: InstructionDurations = None,
     ):
         """BasePadding initializer.
 
@@ -67,6 +69,30 @@ class BasePadding(TransformationPass):
         """
         super().__init__()
         self.target = target
+        self.durations = durations
+
+    def get_duration(self, node, dag):  # pylint: disable=too-many-return-statements
+        """Get duration of a given node in the circuit."""
+        if node.name == "delay":
+            return node.op.duration
+        if node.name == "barrier":
+            return 0
+        if not self.target and not self.durations:
+            return None
+        indices = [dag.find_bit(qarg).index for qarg in node.qargs]
+
+        if self.target:
+            props_dict = self.target.get(node.name)
+            if not props_dict:
+                return None
+            props = props_dict.get(tuple(indices))
+            if not props:
+                return None
+            if self.target.dt is None:
+                return props.duration
+            else:
+                return self.target.seconds_to_dt(props.duration)
+        return self.durations.get(node.name, indices)
 
     def run(self, dag: DAGCircuit):
         """Run the padding pass on ``dag``.
@@ -98,8 +124,7 @@ class BasePadding(TransformationPass):
 
         new_dag.name = dag.name
         new_dag.metadata = dag.metadata
-        new_dag.unit = self.property_set["time_unit"]
-        new_dag._calibrations_prop = dag._calibrations_prop
+        new_dag._unit = self.property_set["time_unit"]
         new_dag.global_phase = dag.global_phase
 
         idle_after = {bit: 0 for bit in dag.qubits}
@@ -112,7 +137,7 @@ class BasePadding(TransformationPass):
         for node in dag.topological_op_nodes():
             if node in node_start_time:
                 t0 = node_start_time[node]
-                t1 = t0 + node.op.duration
+                t1 = t0 + self.get_duration(node, dag)
                 circuit_duration = max(circuit_duration, t1)
 
                 if isinstance(node.op, Delay):
@@ -161,7 +186,7 @@ class BasePadding(TransformationPass):
                     prev_node=prev_node,
                 )
 
-        new_dag.duration = circuit_duration
+        new_dag._duration = circuit_duration
 
         return new_dag
 
@@ -185,6 +210,9 @@ class BasePadding(TransformationPass):
                 f"The input circuit {dag.name} is not scheduled. Call one of scheduling passes "
                 f"before running the {self.__class__.__name__} pass."
             )
+        if self.property_set["time_unit"] == "stretch":
+            # This should have already been raised during scheduling, but just in case.
+            raise TranspilerError("Scheduling cannot run on circuits with stretch durations.")
         for qarg, _ in enumerate(dag.qubits):
             if not self.__delay_supported(qarg):
                 logger.debug(

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()
@@ -348,14 +310,14 @@ class PadDynamicalDecoupling(BasePadding):
 
         if not self.__is_dd_qubit(dag.qubits.index(qubit)):
             # Target physical qubit is not the target of this DD sequence.
-            self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag.unit), qubit)
+            self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag._unit), qubit)
             return
 
         if self._skip_reset_qubits and (
             isinstance(prev_node, DAGInNode) or isinstance(prev_node.op, Reset)
         ):
             # Previous node is the start edge or reset, i.e. qubit is ground state.
-            self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag.unit), qubit)
+            self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag._unit), qubit)
             return
 
         slack = time_interval - np.sum(self._dd_sequence_lengths[qubit])
@@ -363,7 +325,7 @@ class PadDynamicalDecoupling(BasePadding):
 
         if slack <= 0:
             # Interval too short.
-            self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag.unit), qubit)
+            self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag._unit), qubit)
             return
 
         if len(self._dd_sequence) == 1:
@@ -382,14 +344,14 @@ 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
                 sequence_gphase += phase
             else:
                 # Don't do anything if there's no single-qubit gate to absorb the inverse
-                self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag.unit), qubit)
+                self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag._unit), qubit)
                 return
 
         def _constrained_length(values):
@@ -425,7 +387,7 @@ class PadDynamicalDecoupling(BasePadding):
             if dd_ind < len(taus):
                 tau = taus[dd_ind]
                 if tau > 0:
-                    self._apply_scheduled_op(dag, idle_after, Delay(tau, dag.unit), qubit)
+                    self._apply_scheduled_op(dag, idle_after, Delay(tau, dag._unit), qubit)
                     idle_after += tau
             if dd_ind < len(self._dd_sequence):
                 gate = self._dd_sequence[dd_ind]

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(
@@ -79,4 +87,4 @@ class PadDelay(BasePadding):
             return
 
         time_interval = t_end - t_start
-        self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag.unit), qubit)
+        self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag._unit), qubit)

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(