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

qiskit/transpiler/passes/optimization/light_cone.py

@@ -0,0 +1,135 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Cancel the redundant (self-adjoint) gates through commutation relations."""
+from __future__ import annotations
+import warnings
+from qiskit.circuit import Gate, Qubit
+from qiskit.circuit.commutation_library import SessionCommutationChecker as scc
+from qiskit.circuit.library import PauliGate, ZGate
+from qiskit.dagcircuit import DAGCircuit
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.passes.utils.remove_final_measurements import calc_final_ops
+
+translation_table = str.maketrans({"+": "X", "-": "X", "l": "Y", "r": "Y", "0": "Z", "1": "Z"})
+
+
+class LightCone(TransformationPass):
+    """Remove the gates that do not affect the outcome of a measurement on a circuit.
+
+    Pass for computing the light-cone of an observable or measurement. The Pass can handle
+    either an observable one would like to measure or a measurement on a set of qubits.
+    """
+
+    def __init__(self, bit_terms: str | None = None, indices: list[int] | None = None) -> None:
+        """
+        Args:
+            bit_terms: If ``None`` the light-cone will be computed for the set of measurements
+                in the circuit. If a string is specified, the light-cone will correspond to the
+                reduced circuit with the same expectation value for the observable.
+            indices: list of non-trivial indices corresponding to the observable in ``bit_terms``.
+        """
+        super().__init__()
+        valid_characters = {"X", "Y", "Z", "+", "-", "l", "r", "0", "1"}
+        self.bit_terms = None
+        if bit_terms is not None:
+            if not indices:
+                raise ValueError("`indices` must be non-empty when providing `bit_terms`.")
+            if not set(bit_terms).issubset(valid_characters):
+                raise ValueError(
+                    f"`bit_terms` should contain only characters in {valid_characters}."
+                )
+            if len(bit_terms) != len(indices):
+                raise ValueError("`bit_terms` must be the same length as `indices`.")
+            self.bit_terms = bit_terms.translate(translation_table)
+        self.indices = indices
+
+    @staticmethod
+    def _find_measurement_qubits(dag: DAGCircuit) -> set[Qubit]:
+        final_nodes = calc_final_ops(dag, {"measure"})
+        qubits_measured = set()
+        for node in final_nodes:
+            qubits_measured |= set(node.qargs)
+        return qubits_measured
+
+    def _get_initial_lightcone(
+        self, dag: DAGCircuit
+    ) -> tuple[set[Qubit], list[tuple[Gate, list[Qubit]]]]:
+        """Returns the initial light-cone.
+        If observable is `None`, the light-cone is the set of measured qubits.
+        If a `bit_terms` is provided, the qubits corresponding to the
+        non-trivial Paulis define the light-cone.
+        """
+        lightcone_qubits = self._find_measurement_qubits(dag)
+        if self.bit_terms is None:
+            lightcone_operations = [(ZGate(), [qubit_index]) for qubit_index in lightcone_qubits]
+        else:
+            # Having both measurements and an observable is not allowed
+            if len(dag.qubits) < max(self.indices) + 1:
+                raise ValueError("`indices` contains values outside the qubit range.")
+            if lightcone_qubits:
+                raise ValueError(
+                    "The circuit contains measurements and an observable has been given: "
+                    "remove the observable or the measurements."
+                )
+            lightcone_qubits = [dag.qubits[i] for i in self.indices]
+            # `lightcone_operations` is a list of tuples, each containing (operation, list_of_qubits)
+            lightcone_operations = [(PauliGate(self.bit_terms), lightcone_qubits)]
+
+        return set(lightcone_qubits), lightcone_operations
+
+    def run(self, dag: DAGCircuit) -> DAGCircuit:
+        """Run the LightCone pass on `dag`.
+
+        Args:
+            dag: The DAG to reduce.
+
+        Returns:
+            The DAG reduced to the light-cone of the observable.
+        """
+
+        # Get the initial light-cone and operations
+        lightcone_qubits, lightcone_operations = self._get_initial_lightcone(dag)
+
+        #  Initialize a new, empty DAG
+        new_dag = dag.copy_empty_like()
+
+        # Iterate over the nodes in reverse topological order
+        for node in reversed(list(dag.topological_op_nodes())):
+            # Check if the node belongs to the light-cone
+            if lightcone_qubits.intersection(node.qargs):
+                # Check commutation with all previous operations
+                commutes_bool = True
+                for op in lightcone_operations:
+                    max_num_qubits = max(len(op[1]), len(node.qargs))
+                    if max_num_qubits > 10:
+                        warnings.warn(
+                            "LightCone pass is checking commutation of"
+                            f"operators of size {max_num_qubits}."
+                            "This operation can be slow.",
+                            category=RuntimeWarning,
+                        )
+                    commute_bool = scc.commute(
+                        op[0], op[1], [], node.op, node.qargs, [], max_num_qubits=max_num_qubits
+                    )
+                    if not commute_bool:
+                        # If the current node does not commute, update the light-cone
+                        lightcone_qubits.update(node.qargs)
+                        lightcone_operations.append((node.op, node.qargs))
+                        commutes_bool = False
+                        break
+
+                # If the node is in the light-cone and commutes with previous `ops`,
+                # add it to the new DAG at the front
+                if not commutes_bool:
+                    new_dag.apply_operation_front(node.op, node.qargs, node.cargs)
+        return new_dag

qiskit/transpiler/passes/optimization/optimize_1q_commutation.py

@@ -224,7 +224,6 @@ class Optimize1qGatesSimpleCommutation(TransformationPass):
 
             # perform the replacement if it was indeed a good idea
             if self._optimize1q._substitution_checks(
-                dag,
                 (preceding_run or []) + run + (succeeding_run or []),
                 new_preceding_run.op_nodes() + new_run.op_nodes() + new_succeeding_run.op_nodes(),
                 self._optimize1q._basis_gates,

qiskit/transpiler/passes/optimization/optimize_1q_decomposition.py

@@ -63,7 +63,6 @@ class Optimize1qGatesDecomposition(TransformationPass):
     The decision to replace the original chain with a new re-synthesis depends on:
      - whether the original chain was out of basis: replace
      - whether the original chain was in basis but re-synthesis is lower error: replace
-     - whether the original chain contains a pulse gate: do not replace
      - whether the original chain amounts to identity: replace with null
 
      Error is computed as a multiplication of the errors of individual gates on that qubit.
@@ -81,17 +80,19 @@ class Optimize1qGatesDecomposition(TransformationPass):
         """
         super().__init__()
 
-        if basis:
+        if basis and len(basis) > 0:
             self._basis_gates = set(basis)
         else:
             self._basis_gates = None
-        self._target = target
+        # Bypass target if it doesn't contain any basis gates (i.e. it's a _FakeTarget), as this
+        # not part of the official target model.
+        self._target = target if target is not None and len(target.operation_names) > 0 else None
         self._global_decomposers = None
         self._local_decomposers_cache = {}
 
-        if basis:
+        if self._basis_gates:
             self._global_decomposers = _possible_decomposers(set(basis))
-        elif target is None:
+        elif target is None or len(target.operation_names) == 0:
             self._global_decomposers = _possible_decomposers(None)
             self._basis_gates = None
 
@@ -115,7 +116,11 @@ class Optimize1qGatesDecomposition(TransformationPass):
 
     def _get_decomposer(self, qubit=None):
         # include path for when target exists but target.num_qubits is None (BasicSimulator)
-        if self._target is not None and self._target.num_qubits is not None:
+        if (
+            self._target is not None
+            and self._target.num_qubits is not None
+            and len(self._target.operation_names) > 0
+        ):
             if qubit is not None:
                 qubits_tuple = (qubit,)
             else:
@@ -160,33 +165,24 @@ class Optimize1qGatesDecomposition(TransformationPass):
             out_dag.apply_operation_back(op.operation, qubits, check=False)
         return out_dag
 
-    def _substitution_checks(
-        self, dag, old_run, new_circ, basis, qubit, old_error=None, new_error=None
-    ):
+    def _substitution_checks(self, old_run, new_circ, basis, qubit, old_error=None, new_error=None):
         """
         Returns `True` when it is recommended to replace `old_run` with `new_circ` over `basis`.
         """
         if new_circ is None:
             return False
 
-        # do we even have calibrations?
-        has_cals_p = dag._calibrations_prop is not None and len(dag._calibrations_prop) > 0
-        # does this run have uncalibrated gates?
-        uncalibrated_p = not has_cals_p or any(not dag._has_calibration_for(g) for g in old_run)
-        # does this run have gates not in the image of ._decomposers _and_ uncalibrated?
+        # does this run have gates not in the image of ._decomposers?
         if basis is not None:
-            uncalibrated_and_not_basis_p = any(
-                g.name not in basis and (not has_cals_p or not dag._has_calibration_for(g))
-                for g in old_run
-            )
+            not_basis_p = any(g.name not in basis for g in old_run)
         else:
             # If no basis is specified then we're always in the basis
-            uncalibrated_and_not_basis_p = False
+            not_basis_p = False
 
         # if we're outside of the basis set, we're obligated to logically decompose.
         # if we're outside of the set of gates for which we have physical definitions,
         #    then we _try_ to decompose, using the results if we see improvement.
-        if not uncalibrated_and_not_basis_p:
+        if not not_basis_p:
             if new_error is None:
                 new_error = self._error(new_circ, qubit)
             if old_error is None:
@@ -196,8 +192,8 @@ class Optimize1qGatesDecomposition(TransformationPass):
             old_error = 0.0
 
         return (
-            uncalibrated_and_not_basis_p
-            or (uncalibrated_p and new_error < old_error)
+            not_basis_p
+            or (True and new_error < old_error)
             or (math.isclose(new_error[0], 0) and not math.isclose(old_error[0], 0))
         )
 

qiskit/transpiler/passes/optimization/optimize_annotated.py

@@ -126,7 +126,8 @@ class OptimizeAnnotated(TransformationPass):
         for node in dag.op_nodes():
             if isinstance(node.op, ControlFlowOp):
                 dag.substitute_node(
-                    node, control_flow.map_blocks(self.run, node.op), propagate_condition=False
+                    node,
+                    control_flow.map_blocks(self.run, node.op),
                 )
 
         # First, optimize every node in the DAG.
@@ -165,7 +166,7 @@ class OptimizeAnnotated(TransformationPass):
                 node.op.modifiers = canonical_modifiers
             else:
                 # no need for annotated operations
-                dag.substitute_node(node, cur, propagate_condition=False)
+                dag.substitute_node(node, cur)
             did_something = True
         return dag, did_something
 

qiskit/transpiler/passes/optimization/remove_identity_equiv.py

@@ -32,7 +32,7 @@ class RemoveIdentityEquivalent(TransformationPass):
 
     .. math::
 
-        \bar{F} = \frac{1 + F_{\text{process}}}{1 + d},\ 
+        \bar{F} = \frac{1 + d F_{\text{process}}}{1 + d},\ 
 
         F_{\text{process}} = \frac{|\mathrm{Tr}(G)|^2}{d^2}
 
@@ -47,9 +47,11 @@ class RemoveIdentityEquivalent(TransformationPass):
         Args:
             approximation_degree: The degree to approximate for the equivalence check. This can be a
                 floating point value between 0 and 1, or ``None``. If the value is 1 this does not
-                approximate above floating point precision. For a value < 1 this is used as a scaling
-                factor for the cutoff fidelity. If the value is ``None`` this approximates up to the
-                fidelity for the gate specified in ``target``.
+                approximate above the floating point precision. For a value < 1 this is used as a
+                scaling factor for the cutoff fidelity. If the value is ``None`` this approximates up
+                to the fidelity for the gate specified in ``target``. In case no ``target`` is set
+                we approximate up to ``16 * machine_eps`` as default to account for accumulations
+                on few-qubit systems.
 
             target: If ``approximation_degree`` is set to ``None`` and a :class:`.Target` is provided
                 for this field the tolerance for determining whether an operation is equivalent to

qiskit/transpiler/passes/optimization/reset_after_measure_simplification.py

@@ -14,7 +14,8 @@
 
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.passes.utils import control_flow
-from qiskit.circuit.library.standard_gates.x import XGate
+from qiskit.circuit import QuantumCircuit
+from qiskit.circuit import IfElseOp
 from qiskit.circuit.reset import Reset
 from qiskit.circuit.measure import Measure
 from qiskit.dagcircuit.dagcircuit import DAGCircuit
@@ -36,7 +37,9 @@ class ResetAfterMeasureSimplification(TransformationPass):
         for node in dag.op_nodes(Measure):
             succ = next(dag.quantum_successors(node))
             if isinstance(succ, DAGOpNode) and isinstance(succ.op, Reset):
-                new_x = XGate().c_if(node.cargs[0], 1)
+                x_body = QuantumCircuit(1)
+                x_body.x(0)
+                new_x = IfElseOp((node.cargs[0], 1), x_body)
                 new_dag = DAGCircuit()
                 new_dag.add_qubits(node.qargs)
                 new_dag.add_clbits(node.cargs)

qiskit/transpiler/passes/optimization/split_2q_unitaries.py

@@ -13,6 +13,7 @@
 """Splits each two-qubit gate in the `dag` into two single-qubit gates, if possible without error."""
 
 from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.layout import Layout
 from qiskit.dagcircuit.dagcircuit import DAGCircuit
 from qiskit._accelerate.split_2q_unitaries import split_2q_unitaries
 
@@ -24,17 +25,39 @@ class Split2QUnitaries(TransformationPass):
     matrix is actually a product of 2 single qubit gates. In these cases the 2q gate can be
     simplified into two single qubit gates and this pass will perform this optimization and will
     replace the two qubit gate with two single qubit :class:`.UnitaryGate`.
+
+    If some of the gates can be viewed as a swap joined by the product of 2 single qubit gates,
+    the pass will recreate the DAG, permuting the swapped qubits similar
+    to how it's done in :class:`ElidePermutations`.
     """
 
-    def __init__(self, fidelity: float = 1.0 - 1e-16):
+    def __init__(self, fidelity: float = 1.0 - 1e-16, split_swap: bool = False):
         """
         Args:
             fidelity: Allowed tolerance for splitting two-qubit unitaries and gate decompositions.
+            split_swap: Whether to attempt to split swap gates, resulting in a permutation of the qubits.
         """
         super().__init__()
         self.requested_fidelity = fidelity
+        self.split_swap = split_swap
 
     def run(self, dag: DAGCircuit) -> DAGCircuit:
         """Run the Split2QUnitaries pass on `dag`."""
-        split_2q_unitaries(dag, self.requested_fidelity)
-        return dag
+        result = split_2q_unitaries(dag, self.requested_fidelity, self.split_swap)
+        if result is None:
+            return dag
+
+        (new_dag, qubit_mapping) = result
+        input_qubit_mapping = {qubit: index for index, qubit in enumerate(dag.qubits)}
+        self.property_set["original_layout"] = Layout(input_qubit_mapping)
+        if self.property_set["original_qubit_indices"] is None:
+            self.property_set["original_qubit_indices"] = input_qubit_mapping
+
+        new_layout = Layout({dag.qubits[out]: idx for idx, out in enumerate(qubit_mapping)})
+        if current_layout := self.property_set["virtual_permutation_layout"]:
+            self.property_set["virtual_permutation_layout"] = new_layout.compose(
+                current_layout, dag.qubits
+            )
+        else:
+            self.property_set["virtual_permutation_layout"] = new_layout
+        return new_dag

qiskit/transpiler/passes/optimization/template_matching/template_substitution.py

@@ -443,6 +443,7 @@ class TemplateSubstitution:
         self.dag_dep_optimized = dag_dep_opt
         self.dag_optimized = dagdependency_to_dag(dag_dep_opt)
 
+    @_optionals.HAS_SYMPY.require_in_call("Bind parameters in templates")
     def _attempt_bind(self, template_sublist, circuit_sublist):
         """
         Copies the template and attempts to bind any parameters,

qiskit/transpiler/passes/routing/__init__.py

@@ -15,7 +15,6 @@
 from .basic_swap import BasicSwap
 from .layout_transformation import LayoutTransformation
 from .lookahead_swap import LookaheadSwap
-from .stochastic_swap import StochasticSwap
 from .sabre_swap import SabreSwap
 from .commuting_2q_gate_routing.commuting_2q_gate_router import Commuting2qGateRouter
 from .commuting_2q_gate_routing.swap_strategy import SwapStrategy

qiskit/transpiler/passes/routing/commuting_2q_gate_routing/commuting_2q_gate_router.py

@@ -52,7 +52,9 @@ class Commuting2qGateRouter(TransformationPass):
     To do this we use a line swap strategy for qubits 0, 1, 3, and 4 defined it in terms
     of virtual qubits 0, 1, 2, and 3.
 
-    .. code-block:: python
+    .. plot::
+       :include-source:
+       :nofigs:
 
         from qiskit import QuantumCircuit
         from qiskit.circuit.library import PauliEvolutionGate

qiskit/transpiler/passes/routing/sabre_swap.py

@@ -20,7 +20,7 @@ import rustworkx
 
 from qiskit.circuit import SwitchCaseOp, Clbit, ClassicalRegister
 from qiskit.circuit.library.standard_gates import SwapGate
-from qiskit.circuit.controlflow import condition_resources, node_resources
+from qiskit.circuit.controlflow import node_resources
 from qiskit.converters import dag_to_circuit
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.coupling import CouplingMap
@@ -29,7 +29,7 @@ from qiskit.transpiler.layout import Layout
 from qiskit.transpiler.target import Target
 from qiskit.transpiler.passes.layout import disjoint_utils
 from qiskit.dagcircuit import DAGCircuit, DAGOpNode
-from qiskit.utils.parallel import CPU_COUNT
+from qiskit.utils import default_num_processes
 
 from qiskit._accelerate.sabre import sabre_routing, Heuristic, SetScaling, NeighborTable, SabreDAG
 from qiskit._accelerate.nlayout import NLayout
@@ -167,7 +167,7 @@ class SabreSwap(TransformationPass):
         self.heuristic = heuristic
         self.seed = seed
         if trials is None:
-            self.trials = CPU_COUNT
+            self.trials = default_num_processes()
         else:
             self.trials = trials
 
@@ -301,8 +301,6 @@ def _build_sabre_dag(dag, num_physical_qubits, qubit_indices):
         node_blocks = {}
         for node in block_dag.topological_op_nodes():
             cargs_bits = set(node.cargs)
-            if node.condition is not None:
-                cargs_bits.update(condition_resources(node.condition).clbits)
             if node.is_control_flow() and isinstance(node.op, SwitchCaseOp):
                 target = node.op.target
                 if isinstance(target, Clbit):
@@ -416,6 +414,12 @@ def _apply_sabre_result(
                 block_root_logical_map = {
                     inner: root_logical_map[outer] for inner, outer in zip(block.qubits, node.qargs)
                 }
+                # The virtual qubits originally incident to the block should be retained even if not
+                # actually used; the user might be marking them out specially (like in `box`).
+                # There are other transpiler passes to remove those dependencies if desired.
+                incident_qubits = {
+                    layout.virtual_to_physical(block_root_logical_map[bit]) for bit in block.qubits
+                }
                 block_dag, block_layout = recurse(
                     empty_dag(block),
                     circuit_to_dag_dict[id(block)],
@@ -429,7 +433,11 @@ def _apply_sabre_result(
                 )
                 apply_swaps(block_dag, block_result.swap_epilogue, block_layout)
                 mapped_block_dags.append(block_dag)
-                idle_qubits.intersection_update(block_dag.idle_wires())
+                idle_qubits.intersection_update(
+                    bit
+                    for bit in block_dag.idle_wires()
+                    if block_dag.find_bit(bit).index not in incident_qubits
+                )
 
             mapped_blocks = []
             for mapped_block_dag in mapped_block_dags:

qiskit/transpiler/passes/routing/star_prerouting.py

@@ -388,7 +388,7 @@ def _extract_nodes(nodes, dag):
         qubit_indices = [dag.find_bit(qubit).index for qubit in node.qargs]
         classical_bit_indices = set()
 
-        if node.condition is not None:
+        if getattr(node, "condition", None) is not None:
             classical_bit_indices.update(condition_resources(node.op.condition).clbits)
 
         if isinstance(node.op, SwitchCaseOp):

qiskit/transpiler/passes/scheduling/__init__.py

@@ -12,16 +12,10 @@
 
 """Module containing circuit scheduling passes."""
 
-from .alap import ALAPSchedule
-from .asap import ASAPSchedule
-from .dynamical_decoupling import DynamicalDecoupling
 from .scheduling import ALAPScheduleAnalysis, ASAPScheduleAnalysis, SetIOLatency
 from .time_unit_conversion import TimeUnitConversion
 from .padding import PadDelay, PadDynamicalDecoupling
-from .alignments import InstructionDurationCheck, ValidatePulseGates, ConstrainedReschedule
+from .alignments import InstructionDurationCheck, ConstrainedReschedule
 
 # For backward compatibility
 from . import alignments as instruction_alignments
-
-# TODO Deprecated pass. Will be removed after deprecation period.
-from .alignments import AlignMeasures

qiskit/transpiler/passes/scheduling/alignments/__init__.py

@@ -63,7 +63,7 @@ Granularity constraint
     configuration in units of dt. This is the constraint for a single pulse :class:`Play`
     instruction that may constitute your pulse gate.
     The length of waveform samples should be multiple of this constraint value.
-    Violation of this constraint may result in failue in backend execution.
+    Violation of this constraint may result in failure in backend execution.
 
 Minimum pulse length constraint
 
@@ -71,11 +71,9 @@ Minimum pulse length constraint
     configuration in units of dt. This is the constraint for a single pulse :class:`Play`
     instruction that may constitute your pulse gate.
     The length of waveform samples should be greater than this constraint value.
-    Violation of this constraint may result in failue in backend execution.
+    Violation of this constraint may result in failure in backend execution.
 
 """
 
 from .check_durations import InstructionDurationCheck
-from .pulse_gate_validation import ValidatePulseGates
 from .reschedule import ConstrainedReschedule
-from .align_measures import AlignMeasures

qiskit/transpiler/passes/scheduling/alignments/check_durations.py

@@ -22,7 +22,7 @@ class InstructionDurationCheck(AnalysisPass):
 
     This pass investigates the input quantum circuit and checks if the circuit requires
     rescheduling for execution. Note that this pass can be triggered without scheduling.
-    This pass only checks the duration of delay instructions and user defined pulse gates,
+    This pass only checks the duration of delay instructions,
     which report duration values without pre-scheduling.
 
     This pass assumes backend supported instructions, i.e. basis gates, have no violation
@@ -68,11 +68,3 @@ class InstructionDurationCheck(AnalysisPass):
             if not (dur % self.acquire_align == 0 and dur % self.pulse_align == 0):
                 self.property_set["reschedule_required"] = True
                 return
-
-        # Check custom gate durations
-        for inst_defs in dag._calibrations_prop.values():
-            for caldef in inst_defs.values():
-                dur = caldef.duration
-                if not (dur % self.acquire_align == 0 and dur % self.pulse_align == 0):
-                    self.property_set["reschedule_required"] = True
-                    return

qiskit/transpiler/passes/scheduling/alignments/reschedule.py

@@ -84,6 +84,8 @@ class ConstrainedReschedule(AnalysisPass):
         self.acquire_align = acquire_alignment
         self.pulse_align = pulse_alignment
         if target is not None:
+            self.durations = target.durations()
+            self.target = target
             self.acquire_align = target.acquire_alignment
             self.pulse_align = target.pulse_alignment
 
@@ -117,7 +119,6 @@ class ConstrainedReschedule(AnalysisPass):
             node: Current node.
         """
         node_start_time = self.property_set["node_start_time"]
-        conditional_latency = self.property_set.get("conditional_latency", 0)
         clbit_write_latency = self.property_set.get("clbit_write_latency", 0)
 
         if isinstance(node.op, Gate):
@@ -142,20 +143,25 @@ class ConstrainedReschedule(AnalysisPass):
             node_start_time[node] = this_t0
 
         # Compute shifted t1 of this node separately for qreg and creg
-        new_t1q = this_t0 + node.op.duration
+        if self.target is not None:
+            try:
+                duration = self.durations.get(node.op, [dag.find_bit(x).index for x in node.qargs])
+            except TranspilerError:
+                duration = 0
+            new_t1q = this_t0 + duration
+
+        elif node.name == "delay":
+            new_t1q = this_t0 + node.op.duration
+        else:
+            new_t1q = this_t0
         this_qubits = set(node.qargs)
         if isinstance(node.op, (Measure, Reset)):
             # creg access ends at the end of instruction
             new_t1c = new_t1q
             this_clbits = set(node.cargs)
         else:
-            if node.op.condition_bits:
-                # conditional access ends at the beginning of node start time
-                new_t1c = this_t0
-                this_clbits = set(node.op.condition_bits)
-            else:
-                new_t1c = None
-                this_clbits = set()
+            new_t1c = None
+            this_clbits = set()
 
         # Check immediate successors for overlap
         for next_node in self._get_next_gate(dag, node):
@@ -167,13 +173,8 @@ class ConstrainedReschedule(AnalysisPass):
                 next_t0c = next_t0q + clbit_write_latency
                 next_clbits = set(next_node.cargs)
             else:
-                if next_node.op.condition_bits:
-                    # conditional access starts before node start time
-                    next_t0c = next_t0q - conditional_latency
-                    next_clbits = set(next_node.op.condition_bits)
-                else:
-                    next_t0c = None
-                    next_clbits = set()
+                next_t0c = None
+                next_clbits = set()
             # Compute overlap if there is qubits overlap
             if any(this_qubits & next_qubits):
                 qreg_overlap = new_t1q - next_t0q

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``.
@@ -99,7 +125,6 @@ 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.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):
@@ -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(