qiskit 1.2.0rc1__cp38-abi3-macosx_10_9_universal2.whl → 1.2.2__cp38-abi3-macosx_10_9_universal2.whl

qiskit/pulse/schedule.py

@@ -81,6 +81,7 @@ class Schedule:
 
       .. code-block:: python
 
+          from qiskit.pulse import Schedule, Gaussian, DriveChannel, Play
           sched = Schedule()
           sched += Play(Gaussian(160, 0.1, 40), DriveChannel(0))
 
@@ -653,8 +654,6 @@ class Schedule:
 
             sched += pulse.Schedule(old)
 
-            sched = sched.flatten()
-
             sched = sched.replace(old, new)
 
             assert sched == pulse.Schedule(new)
@@ -899,11 +898,8 @@ class ScheduleBlock:
                 pulse.reference("grand_child")
                 pulse.play(pulse.Constant(200, amp2), pulse.DriveChannel(0))
 
-    Now you assign the inner pulse program to this reference.
-
-    .. code-block::
-
-        sched_outer.assign_references({("grand_child", ): sched_inner})
+        # Now assign the inner pulse program to this reference
+        sched_outer.assign_references({("grand_child",): sched_inner})
         print(sched_outer.parameters)
 
     .. parsed-literal::
@@ -1459,7 +1455,7 @@ class ScheduleBlock:
 
             from qiskit import pulse
 
-            with pulse.build() as subroutine:
+            with pulse.build() as nested_prog:
                 pulse.delay(10, pulse.DriveChannel(0))
 
             with pulse.build() as sub_prog:
@@ -1490,7 +1486,7 @@ class ScheduleBlock:
         .. code-block:: python
 
             main_prog.assign_references({("B", ): sub_prog}, inplace=True)
-            main_prog.references[("B", )].assign_references({"A": nested_prog}, inplace=True)
+            main_prog.references[("B", )].assign_references({("A", ): nested_prog}, inplace=True)
 
         Here :attr:`.references` returns a dict-like object, and you can
         mutably update the nested reference of the particular subroutine.

qiskit/pulse/transforms/alignments.py

@@ -338,8 +338,10 @@ class AlignFunc(AlignmentKind):
 
     .. code-block:: python
 
+        import numpy as np
+
         def udd10_pos(j):
-        return np.sin(np.pi*j/(2*10 + 2))**2
+            return np.sin(np.pi*j/(2*10 + 2))**2
 
     .. note::
 

qiskit/pulse/transforms/dag.py

@@ -32,6 +32,11 @@ def block_to_dag(block: ScheduleBlock) -> rx.PyDAG:
 
     .. code-block:: python
 
+        from qiskit import pulse
+
+        my_gaussian0 = pulse.Gaussian(100, 0.5, 20)
+        my_gaussian1 = pulse.Gaussian(100, 0.3, 10)
+
         with pulse.build() as sched1:
             with pulse.align_left():
                 pulse.play(my_gaussian0, pulse.DriveChannel(0))
@@ -51,6 +56,8 @@ def block_to_dag(block: ScheduleBlock) -> rx.PyDAG:
 
     .. code-block:: python
 
+        from qiskit import pulse
+
         with pulse.build() as sched:
             with pulse.align_left():
                 pulse.shift_phase(1.57, pulse.DriveChannel(1))

qiskit/qasm2/parse.py

@@ -89,6 +89,35 @@ class CustomInstruction:
     There is a final ``builtin`` field.  This is optional, and if set true will cause the
     instruction to be defined and available within the parsing, even if there is no definition in
     any included OpenQASM 2 file.
+
+    Examples:
+
+        Instruct the importer to use Qiskit's :class:`.ECRGate` and :class:`.RZXGate` objects to
+        interpret ``gate`` statements that are known to have been created from those same objects
+        during OpenQASM 2 export::
+
+            from qiskit import qasm2
+            from qiskit.circuit import QuantumCircuit, library
+
+            qc = QuantumCircuit(2)
+            qc.ecr(0, 1)
+            qc.rzx(0.3, 0, 1)
+            qc.rzx(0.7, 1, 0)
+            qc.rzx(1.5, 0, 1)
+            qc.ecr(1, 0)
+
+            # This output string includes `gate ecr q0, q1 { ... }` and `gate rzx(p) q0, q1 { ... }`
+            # statements, since `ecr` and `rzx` are neither built-in gates nor in ``qelib1.inc``.
+            dumped = qasm2.dumps(qc)
+
+            # Tell the importer how to interpret the `gate` statements, which we know are safe
+            # because we controlled the input OpenQASM 2 source.
+            custom = [
+                qasm2.CustomInstruction("ecr", 0, 2, library.ECRGate),
+                qasm2.CustomInstruction("rzx", 1, 2, library.RZXGate),
+            ]
+
+            loaded = qasm2.loads(dumped, custom_instructions=custom)
     """
 
     name: str

qiskit/qasm3/exporter.py

@@ -140,9 +140,16 @@ class Exporter:
     ):
         """
         Args:
-            includes: the filenames that should be emitted as includes.  These files will be parsed
-                for gates, and any objects dumped from this exporter will use those definitions
-                where possible.
+            includes: the filenames that should be emitted as includes.
+
+                .. note::
+
+                    At present, only the standard-library file ``stdgates.inc`` is properly
+                    understood by the exporter, in the sense that it knows the gates it defines.
+                    You can specify other includes, but you will need to pass the names of the gates
+                    they define in the ``basis_gates`` argument to avoid the exporter outputting a
+                    separate ``gate`` definition.
+
             basis_gates: the basic defined gate set of the backend.
             disable_constants: if ``True``, always emit floating-point constants for numeric
                 parameter values.  If ``False`` (the default), then values close to multiples of
@@ -626,7 +633,13 @@ class QASM3Builder:
             if builtin in _BUILTIN_GATES:
                 # It's built into the langauge; we don't need to re-add it.
                 continue
-            self.symbols.register_gate_without_definition(builtin, None)
+            try:
+                self.symbols.register_gate_without_definition(builtin, None)
+            except QASM3ExporterError as exc:
+                raise QASM3ExporterError(
+                    f"Cannot use '{builtin}' as a basis gate for the reason in the prior exception."
+                    " Consider renaming the gate if needed, or omitting this basis gate if not."
+                ) from exc
 
         header = ast.Header(ast.Version("3.0"), list(self.build_includes()))
 
@@ -669,9 +682,9 @@ class QASM3Builder:
     def build_includes(self):
         """Builds a list of included files."""
         for filename in self.includes:
-            if (definitions := _KNOWN_INCLUDES.get(filename)) is None:
-                raise QASM3ExporterError(f"Unknown OpenQASM 3 include file: '{filename}'")
-            for name, gate in definitions.items():
+            # Note: unknown include files have a corresponding `include` statement generated, but do
+            # not actually define any gates; we rely on the user to pass those in `basis_gates`.
+            for name, gate in _KNOWN_INCLUDES.get(filename, {}).items():
                 self.symbols.register_gate_without_definition(name, gate)
             yield ast.Include(filename)
 

qiskit/qpy/__init__.py

@@ -774,7 +774,7 @@ In addition, new payload MAP_ITEM is defined to implement the :ref:`qpy_mapping`
 
 With the support of :class:`.~ScheduleBlock`, now :class:`~.QuantumCircuit` can be
 serialized together with :attr:`~.QuantumCircuit.calibrations`, or
-`Pulse Gates <https://docs.quantum.ibm.com/build/pulse>`_.
+`Pulse Gates <https://docs.quantum.ibm.com/guides/pulse>`_.
 In QPY version 5 and above, :ref:`qpy_circuit_calibrations` payload is
 packed after the :ref:`qpy_instructions` block.
 

qiskit/quantum_info/operators/operator.py

@@ -55,6 +55,30 @@ class Operator(LinearOp):
     .. math::
 
         \rho \mapsto M \rho M^\dagger.
+
+    For example, the following operator :math:`M = X` applied to the zero state
+    :math:`|\psi\rangle=|0\rangle (\rho = |0\rangle\langle 0|)` changes it to the
+    one state :math:`|\psi\rangle=|1\rangle (\rho = |1\rangle\langle 1|)`:
+
+    .. code-block:: python
+
+        >>> import numpy as np
+        >>> from qiskit.quantum_info import Operator
+        >>> op = Operator(np.array([[0.0, 1.0], [1.0, 0.0]]))  # Represents Pauli X operator
+
+        >>> from qiskit.quantum_info import Statevector
+        >>> sv = Statevector(np.array([1.0, 0.0]))
+        >>> sv.evolve(op)
+        Statevector([0.+0.j, 1.+0.j],
+                    dims=(2,))
+
+        >>> from qiskit.quantum_info import DensityMatrix
+        >>> dm = DensityMatrix(np.array([[1.0, 0.0], [0.0, 0.0]]))
+        >>> dm.evolve(op)
+        DensityMatrix([[0.+0.j, 0.+0.j],
+                    [0.+0.j, 1.+0.j]],
+                    dims=(2,))
+
     """
 
     def __init__(

qiskit/quantum_info/operators/symplectic/pauli.py

@@ -144,6 +144,8 @@ class Pauli(BasePauli):
 
     .. code-block:: python
 
+        from qiskit.quantum_info import Pauli
+
         P = Pauli('-iXYZ')
 
         print('P[0] =', repr(P[0]))

qiskit/quantum_info/operators/symplectic/sparse_pauli_op.py

@@ -792,6 +792,8 @@ class SparsePauliOp(LinearOp):
 
         .. code-block:: python
 
+            from qiskit.quantum_info import SparsePauliOp
+
             # via tuples and the full Pauli string
             op = SparsePauliOp.from_list([("XIIZI", 1), ("IYIIY", 2)])
 
@@ -856,6 +858,8 @@ class SparsePauliOp(LinearOp):
 
         .. code-block:: python
 
+            from qiskit.quantum_info import SparsePauliOp
+
             # via triples and local Paulis with indices
             op = SparsePauliOp.from_sparse_list([("ZX", [1, 4], 1), ("YY", [0, 3], 2)], num_qubits=5)
 
@@ -937,7 +941,7 @@ class SparsePauliOp(LinearOp):
                 array (the default).
             force_serial: if ``True``, use an unthreaded implementation, regardless of the state of
                 the `Qiskit threading-control environment variables
-                <https://docs.quantum.ibm.com/start/configure-qiskit-local#environment-variables>`__.
+                <https://docs.quantum.ibm.com/guides/configure-qiskit-local#environment-variables>`__.
                 By default, this will use threaded parallelism over the available CPUs.
 
         Returns:
@@ -1051,6 +1055,7 @@ class SparsePauliOp(LinearOp):
 
                 .. code-block:: python
 
+                    >>> from qiskit.quantum_info import SparsePauliOp
                     >>> op = SparsePauliOp.from_list([("XX", 2), ("YY", 1), ("IZ",2j), ("ZZ",1j)])
                     >>> op.group_commuting()
                     [SparsePauliOp(["IZ", "ZZ"], coeffs=[0.+2.j, 0.+1j]),

qiskit/synthesis/clifford/clifford_decompose_bm.py

@@ -41,7 +41,7 @@ def synth_clifford_bm(clifford: Clifford) -> QuantumCircuit:
            `arXiv:2003.09412 [quant-ph] <https://arxiv.org/abs/2003.09412>`_
     """
     circuit = QuantumCircuit._from_circuit_data(
-        synth_clifford_bm_inner(clifford.tableau.astype(bool))
+        synth_clifford_bm_inner(clifford.tableau.astype(bool)), add_regs=True
     )
     circuit.name = str(clifford)
     return circuit

qiskit/synthesis/clifford/clifford_decompose_greedy.py

@@ -51,7 +51,7 @@ def synth_clifford_greedy(clifford: Clifford) -> QuantumCircuit:
            `arXiv:2105.02291 [quant-ph] <https://arxiv.org/abs/2105.02291>`_
     """
     circuit = QuantumCircuit._from_circuit_data(
-        synth_clifford_greedy_inner(clifford.tableau.astype(bool))
+        synth_clifford_greedy_inner(clifford.tableau.astype(bool)), add_regs=True
     )
     circuit.name = str(clifford)
     return circuit

qiskit/synthesis/linear/cnot_synth.py

@@ -66,4 +66,4 @@ def synth_cnot_count_full_pmh(
     circuit_data = fast_pmh(normalized, section_size)
 
     # construct circuit from the data
-    return QuantumCircuit._from_circuit_data(circuit_data)
+    return QuantumCircuit._from_circuit_data(circuit_data, add_regs=True)

qiskit/synthesis/one_qubit/one_qubit_decompose.py

@@ -224,7 +224,8 @@ class OneQubitEulerDecomposer:
         return QuantumCircuit._from_circuit_data(
             euler_one_qubit_decomposer.unitary_to_circuit(
                 unitary, [self.basis], 0, None, simplify, atol
-            )
+            ),
+            add_regs=True,
         )
 
     @property

qiskit/synthesis/permutation/permutation_full.py

@@ -42,7 +42,7 @@ def synth_permutation_basic(pattern: list[int] | np.ndarray[int]) -> QuantumCirc
     Returns:
         The synthesized quantum circuit.
     """
-    return QuantumCircuit._from_circuit_data(_synth_permutation_basic(pattern))
+    return QuantumCircuit._from_circuit_data(_synth_permutation_basic(pattern), add_regs=True)
 
 
 def synth_permutation_acg(pattern: list[int] | np.ndarray[int]) -> QuantumCircuit:
@@ -75,4 +75,4 @@ def synth_permutation_acg(pattern: list[int] | np.ndarray[int]) -> QuantumCircui
            *Routing Permutations on Graphs Via Matchings.*,
            `(Full paper) <https://www.cs.tau.ac.il/~nogaa/PDFS/r.pdf>`_
     """
-    return QuantumCircuit._from_circuit_data(_synth_permutation_acg(pattern))
+    return QuantumCircuit._from_circuit_data(_synth_permutation_acg(pattern), add_regs=True)

qiskit/synthesis/permutation/permutation_lnn.py

@@ -49,4 +49,6 @@ def synth_permutation_depth_lnn_kms(pattern: list[int] | np.ndarray[int]) -> Qua
     # In the permutation synthesis code below the notation is opposite:
     # [2, 4, 3, 0, 1] means that 0 maps to 2, 1 to 3, 2 to 3, 3 to 0, and 4 to 1.
     # This is why we invert the pattern.
-    return QuantumCircuit._from_circuit_data(_synth_permutation_depth_lnn_kms(pattern))
+    return QuantumCircuit._from_circuit_data(
+        _synth_permutation_depth_lnn_kms(pattern), add_regs=True
+    )

qiskit/synthesis/two_qubit/two_qubit_decompose.py

@@ -233,7 +233,7 @@ class TwoQubitWeylDecomposition:
         circuit_data = self._inner_decomposition.circuit(
             euler_basis=euler_basis, simplify=simplify, atol=atol
         )
-        return QuantumCircuit._from_circuit_data(circuit_data)
+        return QuantumCircuit._from_circuit_data(circuit_data, add_regs=True)
 
     def actual_fidelity(self, **kwargs) -> float:
         """Calculates the actual fidelity of the decomposed circuit to the input unitary."""
@@ -671,7 +671,7 @@ class TwoQubitBasisDecomposer:
                     approximate,
                     _num_basis_uses=_num_basis_uses,
                 )
-                return QuantumCircuit._from_circuit_data(circ_data)
+                return QuantumCircuit._from_circuit_data(circ_data, add_regs=True)
             else:
                 sequence = self._inner_decomposer(
                     np.asarray(unitary, dtype=complex),

qiskit/transpiler/__init__.py

@@ -106,8 +106,9 @@ also add initial logical optimization prior to routing, you would do something l
 .. code-block:: python
 
     import numpy as np
+    from qiskit.providers.fake_provider import GenericBackendV2
     from qiskit.circuit.library import HGate, PhaseGate, RXGate, TdgGate, TGate, XGate
-    from qiskit.transpiler import PassManager
+    from qiskit.transpiler import PassManager, generate_preset_pass_manager
     from qiskit.transpiler.passes import (
         ALAPScheduleAnalysis,
         CXCancellation,
@@ -115,6 +116,7 @@ also add initial logical optimization prior to routing, you would do something l
         PadDynamicalDecoupling,
     )
 
+    backend = GenericBackendV2(num_qubits=5)
     dd_sequence = [XGate(), XGate()]
     scheduling_pm = PassManager(
         [
@@ -135,6 +137,9 @@ also add initial logical optimization prior to routing, you would do something l
         ]
     )
 
+    pass_manager = generate_preset_pass_manager(
+        optimization_level=0
+    )
 
     # Add pre-layout stage to run extra logical optimization
     pass_manager.pre_layout = logical_opt

qiskit/transpiler/instruction_durations.py

@@ -18,6 +18,7 @@ import qiskit.circuit
 from qiskit.circuit import Barrier, Delay, Instruction, ParameterExpression
 from qiskit.circuit.duration import duration_in_dt
 from qiskit.providers import Backend
+from qiskit.providers.backend import BackendV2
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.utils.units import apply_prefix
 
@@ -75,6 +76,9 @@ class InstructionDurations:
             TranspilerError: If dt and dtm is different in the backend.
         """
         # All durations in seconds in gate_length
+        if isinstance(backend, BackendV2):
+            return backend.target.durations()
+
         instruction_durations = []
         backend_properties = backend.properties()
         if hasattr(backend_properties, "_gates"):

qiskit/transpiler/passes/__init__.py

@@ -71,6 +71,7 @@ Optimizations
    Collect1qRuns
    Collect2qBlocks
    CollectMultiQBlocks
+   CollectAndCollapse
    CollectLinearFunctions
    CollectCliffords
    ConsolidateBlocks
@@ -238,6 +239,7 @@ from .optimization import HoareOptimizer
 from .optimization import TemplateOptimization
 from .optimization import InverseCancellation
 from .optimization import EchoRZXWeylDecomposition
+from .optimization import CollectAndCollapse
 from .optimization import CollectLinearFunctions
 from .optimization import CollectCliffords
 from .optimization import ResetAfterMeasureSimplification

qiskit/transpiler/passes/basis/basis_translator.py

@@ -162,7 +162,8 @@ class BasisTranslator(TransformationPass):
         # If the source basis is a subset of the target basis and we have no circuit
         # instructions on qargs that have non-global operations there is nothing to
         # translate and we can exit early.
-        if source_basis.issubset(target_basis) and not qargs_local_source_basis:
+        source_basis_names = {x[0] for x in source_basis}
+        if source_basis_names.issubset(target_basis) and not qargs_local_source_basis:
             return dag
 
         logger.info(

qiskit/transpiler/passes/calibration/rx_builder.py

@@ -45,7 +45,7 @@ class RXCalibrationBuilder(CalibrationBuilder):
        from qiskit.circuit.library import QuantumVolume
        from qiskit.circuit.library.standard_gates import RXGate
 
-       from calibration.rx_builder import RXCalibrationBuilder
+       from qiskit.transpiler.passes import RXCalibrationBuilder
 
        qv = QuantumVolume(4, 4, seed=1004)
 

qiskit/transpiler/passes/optimization/__init__.py

@@ -39,3 +39,4 @@ from .elide_permutations import ElidePermutations
 from .normalize_rx_angle import NormalizeRXAngle
 from .optimize_annotated import OptimizeAnnotated
 from .split_2q_unitaries import Split2QUnitaries
+from .collect_and_collapse import CollectAndCollapse

qiskit/transpiler/passes/optimization/consolidate_blocks.py

@@ -28,6 +28,7 @@ from qiskit.transpiler.passmanager import PassManager
 from qiskit.transpiler.passes.synthesis import unitary_synthesis
 from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES
 from qiskit._accelerate.convert_2q_block_matrix import blocks_to_matrix
+from qiskit.exceptions import QiskitError
 
 from .collect_1q_runs import Collect1qRuns
 from .collect_2q_blocks import Collect2qBlocks
@@ -125,7 +126,12 @@ class ConsolidateBlocks(TransformationPass):
                         qc.append(nd.op, [q[block_index_map[i]] for i in nd.qargs])
                     unitary = UnitaryGate(Operator(qc), check_input=False)
                 else:
-                    matrix = blocks_to_matrix(block, block_index_map)
+                    try:
+                        matrix = blocks_to_matrix(block, block_index_map)
+                    except QiskitError:
+                        # If building a matrix for the block fails we should not consolidate it
+                        # because there is nothing we can do with it.
+                        continue
                     unitary = UnitaryGate(matrix, check_input=False)
 
                 max_2q_depth = 20  # If depth > 20, there will be 1q gates to consolidate.

qiskit/transpiler/passes/optimization/elide_permutations.py

@@ -96,8 +96,8 @@ class ElidePermutations(TransformationPass):
             elif isinstance(node.op, PermutationGate):
                 starting_indices = [qubit_mapping[dag.find_bit(qarg).index] for qarg in node.qargs]
                 pattern = node.op.params[0]
-                pattern_indices = [qubit_mapping[idx] for idx in pattern]
-                for i, j in zip(starting_indices, pattern_indices):
+                updated_indices = [starting_indices[idx] for idx in pattern]
+                for i, j in zip(starting_indices, updated_indices):
                     qubit_mapping[i] = j
         input_qubit_mapping = {qubit: index for index, qubit in enumerate(dag.qubits)}
         self.property_set["original_layout"] = Layout(input_qubit_mapping)

qiskit/transpiler/passes/optimization/hoare_opt.py

@@ -203,20 +203,24 @@ class HoareOptimizer(TransformationPass):
         """
         import z3
 
-        for node in dag.topological_op_nodes():
+        # Pre-generate all DAG nodes, since we later iterate over them, while
+        # potentially modifying and removing some of them.
+        nodes = list(dag.topological_op_nodes())
+        for node in nodes:
             gate = node.op
-            ctrlqb, ctrlvar, trgtqb, trgtvar = self._seperate_ctrl_trgt(node)
+            _, ctrlvar, trgtqb, trgtvar = self._seperate_ctrl_trgt(node)
 
             ctrl_ones = z3.And(*ctrlvar)
 
-            remove_ctrl, new_dag, qb_idx = self._remove_control(gate, ctrlvar, trgtvar)
+            remove_ctrl, new_dag, _ = self._remove_control(gate, ctrlvar, trgtvar)
 
             if remove_ctrl:
-                dag.substitute_node_with_dag(node, new_dag)
-                gate = gate.base_gate
-                node.op = gate.to_mutable()
-                node.name = gate.name
-                node.qargs = tuple((ctrlqb + trgtqb)[qi] for qi in qb_idx)
+                # We are replacing a node by a new node over a smaller number of qubits.
+                # This can be done using substitute_node_with_dag, which furthermore returns
+                # a mapping from old node ids to new nodes.
+                mapped_nodes = dag.substitute_node_with_dag(node, new_dag)
+                node = next(iter(mapped_nodes.values()))
+                gate = node.op
                 _, ctrlvar, trgtqb, trgtvar = self._seperate_ctrl_trgt(node)
 
                 ctrl_ones = z3.And(*ctrlvar)

qiskit/transpiler/passes/optimization/split_2q_unitaries.py

@@ -9,8 +9,8 @@
 # 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.
+
 """Splits each two-qubit gate in the `dag` into two single-qubit gates, if possible without error."""
-from typing import Optional
 
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.circuit.quantumcircuitdata import CircuitInstruction
@@ -20,37 +20,33 @@ from qiskit.synthesis.two_qubit.two_qubit_decompose import TwoQubitWeylDecomposi
 
 
 class Split2QUnitaries(TransformationPass):
-    """Attempt to splits two-qubit gates in a :class:`.DAGCircuit` into two single-qubit gates
+    """Attempt to splits two-qubit unitaries in a :class:`.DAGCircuit` into two single-qubit gates.
 
-    This pass will analyze all the two qubit gates in the circuit and analyze the gate's unitary
-    matrix to determine if the gate 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`.
+    This pass will analyze all :class:`.UnitaryGate` instances and determine whether the
+    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`.
     """
 
-    def __init__(self, fidelity: Optional[float] = 1.0 - 1e-16):
-        """Split2QUnitaries initializer.
-
+    def __init__(self, fidelity: float = 1.0 - 1e-16):
+        """
         Args:
-            fidelity (float): Allowed tolerance for splitting two-qubit unitaries and gate decompositions
+            fidelity: Allowed tolerance for splitting two-qubit unitaries and gate decompositions.
         """
         super().__init__()
         self.requested_fidelity = fidelity
 
-    def run(self, dag: DAGCircuit):
+    def run(self, dag: DAGCircuit) -> DAGCircuit:
         """Run the Split2QUnitaries pass on `dag`."""
+
         for node in dag.topological_op_nodes():
-            # skip operations without two-qubits and for which we can not determine a potential 1q split
-            if (
-                len(node.cargs) > 0
-                or len(node.qargs) != 2
-                or node.matrix is None
-                or node.is_parameterized()
-            ):
+            # We only attempt to split UnitaryGate objects, but this could be extended in future
+            # -- however we need to ensure that we can compile the resulting single-qubit unitaries
+            # to the supported basis gate set.
+            if not (len(node.qargs) == 2 and node.op.name == "unitary"):
                 continue
 
-            decomp = TwoQubitWeylDecomposition(node.op, fidelity=self.requested_fidelity)
+            decomp = TwoQubitWeylDecomposition(node.matrix, fidelity=self.requested_fidelity)
             if (
                 decomp._inner_decomposition.specialization
                 == TwoQubitWeylDecomposition._specializations.IdEquiv

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

@@ -31,7 +31,7 @@ class ValidatePulseGates(AnalysisPass):
 
     In Qiskit SDK, we can define the pulse-level implementation of custom quantum gate
     instructions, as a `pulse gate
-    <https://docs.quantum.ibm.com/build/pulse>`__,
+    <https://docs.quantum.ibm.com/guides/pulse>`__,
     thus user gates should satisfy all waveform memory constraints imposed by the backend.
 
     This pass validates all attached calibration entries and raises ``TranspilerError`` to

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

@@ -20,7 +20,7 @@ from qiskit.circuit import Gate, ParameterExpression, Qubit
 from qiskit.circuit.delay import Delay
 from qiskit.circuit.library.standard_gates import IGate, UGate, U3Gate
 from qiskit.circuit.reset import Reset
-from qiskit.dagcircuit import DAGCircuit, DAGNode, DAGInNode, DAGOpNode
+from qiskit.dagcircuit import DAGCircuit, DAGNode, DAGInNode, DAGOpNode, DAGOutNode
 from qiskit.quantum_info.operators.predicates import matrix_equal
 from qiskit.synthesis.one_qubit import OneQubitEulerDecomposer
 from qiskit.transpiler.exceptions import TranspilerError
@@ -331,8 +331,7 @@ class PadDynamicalDecoupling(BasePadding):
         if time_interval % self._alignment != 0:
             raise TranspilerError(
                 f"Time interval {time_interval} is not divisible by alignment {self._alignment} "
-                f"between DAGNode {prev_node.name} on qargs {prev_node.qargs} and {next_node.name} "
-                f"on qargs {next_node.qargs}."
+                f"between {_format_node(prev_node)} and {_format_node(next_node)}."
             )
 
         if not self.__is_dd_qubit(dag.qubits.index(qubit)):
@@ -430,3 +429,10 @@ class PadDynamicalDecoupling(BasePadding):
             else:
                 params.append(p)
         return tuple(params)
+
+
+def _format_node(node: DAGNode) -> str:
+    """Util to format the DAGNode, DAGInNode, and DAGOutNode."""
+    if isinstance(node, (DAGInNode, DAGOutNode)):
+        return f"{node.__class__.__name__} on qarg {node.wire}"
+    return f"DAGNode {node.name} on qargs {node.qargs}"

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

@@ -27,6 +27,9 @@ class PadDelay(BasePadding):
 
     .. code-block:: python
 
+        from qiskit import QuantumCircuit
+        from qiskit.transpiler import InstructionDurations
+
         durations = InstructionDurations([("x", None, 160), ("cx", None, 800)])
 
         qc = QuantumCircuit(2)