qiskit 1.3.2__cp39-abi3-win32.whl → 1.4.0__cp39-abi3-win32.whl

qiskit/VERSION.txt

@@ -1 +1 @@
-1.3.2
+1.4.0

qiskit/__init__.py

@@ -110,6 +110,7 @@ sys.modules["qiskit._accelerate.filter_op_nodes"] = _accelerate.filter_op_nodes
 sys.modules["qiskit._accelerate.twirling"] = _accelerate.twirling
 sys.modules["qiskit._accelerate.high_level_synthesis"] = _accelerate.high_level_synthesis
 sys.modules["qiskit._accelerate.remove_identity_equiv"] = _accelerate.remove_identity_equiv
+sys.modules["qiskit._accelerate.circuit_duration"] = _accelerate.circuit_duration
 
 from qiskit.exceptions import QiskitError, MissingOptionalLibraryError
 

qiskit/circuit/__init__.py

@@ -294,6 +294,7 @@ main related classes are:
 * :class:`Parameter`, the atom of compile-time expressions
 * :class:`ParameterExpression`, a symbolic calculation on parameters
 * :class:`ParameterVector`, a convenience collection of many :class:`Parameter`\ s
+* :class:`ParameterVectorElement`, a subclass of :class:`Parameter` used by :class:`ParameterVector`
 
 The :mod:`qiskit.circuit` module also exposes some calculation classes that work with circuits to
 assist compilation workflows.  These include:
@@ -667,12 +668,14 @@ execution.  You can do this assignment using :meth:`QuantumCircuit.assign_parame
 
 You may want to use many parameters that are related to each other.  To make this easier (and to
 avoid you needing to come up with many names), you can use the convenience constructor
-:class:`ParameterVector`.  The elements of the vector are all valid :class:`Parameter` instances.
+:class:`ParameterVector`.  The elements of the vector are all valid :class:`Parameter` instances, of
+a special subclass :class:`ParameterVectorElement`.
 
 .. autosummary::
     :toctree: ../stubs/
 
     ParameterVector
+    ParameterVectorElement
 
 .. _circuit-control-flow-repr:
 
@@ -1289,7 +1292,7 @@ from .measure import Measure
 from .reset import Reset
 from .store import Store
 from .parameter import Parameter
-from .parametervector import ParameterVector
+from .parametervector import ParameterVector, ParameterVectorElement
 from .parameterexpression import ParameterExpression
 from .quantumcircuitdata import CircuitInstruction
 from .equivalence import EquivalenceLibrary

qiskit/circuit/bit.py

@@ -14,6 +14,7 @@
 Quantum bit and Classical bit objects.
 """
 import copy
+import warnings
 
 from qiskit.circuit.exceptions import CircuitError
 
@@ -57,6 +58,17 @@ class Bit:
             self._hash = hash((self._register, self._index))
             self._repr = f"{self.__class__.__name__}({self._register}, {self._index})"
 
+    def __init_subclass__(cls):
+        # In Qiskit 2.0, `Bit` and `Register` will move to Rust space, and the allowable types of
+        # them will be fixed, similar to if the classes had been marked as `final`.
+        if cls.__module__.split(".", 2)[0] != __name__.split(".", 2)[0]:
+            warnings.warn(
+                "subclassing 'Bit' is not supported, and may not be possible in Qiskit 2.0",
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+        return cls
+
     def __repr__(self):
         """Return the official string representing the bit."""
         if (self._register, self._index) == (None, None):

qiskit/circuit/classicalfunction/__init__.py

@@ -20,6 +20,10 @@ ClassicalFunction compiler (:mod:`qiskit.circuit.classicalfunction`)
 Overview
 ========
 
+.. warning::
+    
+    This module is deprecated as of Qiskit 1.4.0. It will be removed in the Qiskit 2.0 release.
+
 The classical function compiler provides the necessary tools to map a classical
 potentially irreversible functions into quantum circuits.  Below is a simple example of
 how to synthesize a simple boolean function defined using Python into a
@@ -111,7 +115,7 @@ Exceptions
    ClassicalFunctionCompilerTypeError
 
 """
-
+from qiskit.utils.deprecation import deprecate_func
 from .classicalfunction import ClassicalFunction
 from .exceptions import (
     ClassicalFunctionParseError,
@@ -121,6 +125,14 @@ from .exceptions import (
 from .boolean_expression import BooleanExpression
 
 
+@deprecate_func(
+    since="1.4",
+    removal_timeline="in Qiskit 2.0",
+    additional_msg="Use `PhaseOracle` instead, which can be turned into a "
+    "bit-flip oracle by applying Hadamard gates on the target "
+    "qubit before and after the instruction, and conditioning."
+    "the instruction on the target qubit.",
+)
 def classical_function(func):
     """
     Parses and type checks the callable ``func`` to compile it into an ``ClassicalFunction``

qiskit/circuit/classicalfunction/boolean_expression.py

@@ -15,15 +15,24 @@
 from os.path import basename, isfile
 from typing import Callable, Optional
 
+from qiskit.utils.deprecation import deprecate_func
 from qiskit.circuit import QuantumCircuit
 from qiskit.utils.optionals import HAS_TWEEDLEDUM
 from .classical_element import ClassicalElement
 
 
-@HAS_TWEEDLEDUM.require_in_instance
 class BooleanExpression(ClassicalElement):
     """The Boolean Expression gate."""
 
+    @HAS_TWEEDLEDUM.require_in_instance
+    @deprecate_func(
+        since="1.4",
+        removal_timeline="in Qiskit 2.0",
+        additional_msg="Use `PhaseOracle` instead, which can be turned into a "
+        "bit-flip oracle by applying Hadamard gates on the target "
+        "qubit before and after the instruction, and conditioning."
+        "the instruction on the target qubit.",
+    )
     def __init__(self, expression: str, name: str = None, var_order: list = None) -> None:
         """
         Args:

qiskit/circuit/classicalfunction/classicalfunction.py

@@ -15,6 +15,7 @@
 import ast
 from typing import Callable, Optional
 
+from qiskit.utils.deprecation import deprecate_func
 from qiskit.circuit import QuantumCircuit, QuantumRegister
 from qiskit.exceptions import QiskitError
 from qiskit.utils.optionals import HAS_TWEEDLEDUM
@@ -23,10 +24,18 @@ from .classical_function_visitor import ClassicalFunctionVisitor
 from .utils import tweedledum2qiskit
 
 
-@HAS_TWEEDLEDUM.require_in_instance
 class ClassicalFunction(ClassicalElement):
     """Represent a classical function and its logic network."""
 
+    @HAS_TWEEDLEDUM.require_in_instance
+    @deprecate_func(
+        since="1.4",
+        removal_timeline="in Qiskit 2.0",
+        additional_msg="Use `PhaseOracle` instead, which can be turned into a "
+        "bit-flip oracle by applying Hadamard gates on the target "
+        "qubit before and after the instruction, and conditioning."
+        "the instruction on the target qubit.",
+    )
     def __init__(self, source, name=None):
         """Creates a ``ClassicalFunction`` from Python source code in ``source``.
 

qiskit/circuit/classicalfunction/exceptions.py

@@ -10,7 +10,13 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""Exceptions for ClassicalFunction compiler"""
+"""Exceptions for ClassicalFunction compiler
+
+.. warning::
+    
+    This module is deprecated as of qiskit 1.4.0 version. It will be removed in the Qiskit 2.0 release.
+
+"""
 
 from qiskit.exceptions import QiskitError
 

qiskit/circuit/delay.py

@@ -81,6 +81,11 @@ class Delay(Instruction):
         """
         return self.__array__(dtype=complex)
 
+    def __eq__(self, other):
+        return (
+            isinstance(other, Delay) and self.unit == other.unit and self._compare_parameters(other)
+        )
+
     def __repr__(self):
         """Return the official string representing the delay."""
         return f"{self.__class__.__name__}(duration={self.params[0]}[unit={self.unit}])"

qiskit/circuit/library/generalized_gates/mcmt.py

@@ -49,7 +49,7 @@ class MCMT(QuantumCircuit):
     :class:`~qiskit.circuit.library.MCMTVChain`.
     """
 
-    @deprecate_func(since="1.3", additional_msg="Use MCMTGate instead.", pending=True)
+    @deprecate_func(since="1.4", additional_msg="Use MCMTGate instead.")
     def __init__(
         self,
         gate: Gate | Callable[[QuantumCircuit, circuit.Qubit, circuit.Qubit], circuit.Instruction],
@@ -76,7 +76,7 @@ class MCMT(QuantumCircuit):
             warnings.warn(
                 "Passing a callable to MCMT is pending deprecation since Qiskit 1.3. Pass a "
                 "gate instance or the gate name instead, e.g. pass 'h' instead of QuantumCircuit.h.",
-                category=PendingDeprecationWarning,
+                category=DeprecationWarning,
                 stacklevel=2,
             )
             gate = gate.__name__
@@ -84,7 +84,7 @@ class MCMT(QuantumCircuit):
             warnings.warn(
                 "Passing a QuantumCircuit is pending deprecation since Qiskit 1.3. Pass a gate "
                 "or turn the circuit into a gate using the ``to_gate`` method, instead.",
-                category=PendingDeprecationWarning,
+                category=DeprecationWarning,
                 stacklevel=2,
             )
             gate = gate.to_gate()
@@ -158,9 +158,8 @@ class MCMTVChain(MCMT):
     """
 
     @deprecate_func(
-        since="1.3",
+        since="1.4",
         additional_msg="Use MCMTGate with the V-chain synthesis plugin instead.",
-        pending=True,
     )
     def __init__(
         self,
@@ -277,7 +276,7 @@ class MCMTGate(ControlledGate):
             warnings.warn(
                 "Passing a controlled gate to MCMT is pending deprecation since Qiskit 1.3. Pass a "
                 "single-qubit gate instance or the gate name instead, e.g. pass 'h' instead of 'ch'.",
-                category=PendingDeprecationWarning,
+                category=DeprecationWarning,
                 stacklevel=2,
             )
             base_gate = gate.base_gate

qiskit/circuit/library/phase_oracle.py

@@ -63,31 +63,38 @@ class PhaseOracle(QuantumCircuit):
             var_order(list): A list with the order in which variables will be created.
                (default: by appearance)
         """
-        from qiskit.circuit.classicalfunction.boolean_expression import BooleanExpression
-        from qiskit.circuit.classicalfunction.classical_element import ClassicalElement
+        # ignore deprecation warning for BooleanExpression; implementation is changing in 2.0
+        import warnings
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            from qiskit.circuit.classicalfunction.boolean_expression import BooleanExpression
+            from qiskit.circuit.classicalfunction.classical_element import ClassicalElement
 
-        if not isinstance(expression, ClassicalElement):
-            expression = BooleanExpression(expression, var_order=var_order)
+            if not isinstance(expression, ClassicalElement):
+                expression = BooleanExpression(expression, var_order=var_order)
 
-        self.boolean_expression = expression
+            self.boolean_expression = expression
 
-        if synthesizer is None:
+            if synthesizer is None:
 
-            def synthesizer(boolean_expression):
-                from tweedledum.synthesis import pkrm_synth  # pylint: disable=import-error
-                from qiskit.circuit.classicalfunction.utils import tweedledum2qiskit
+                def synthesizer(boolean_expression):
+                    from tweedledum.synthesis import pkrm_synth  # pylint: disable=import-error
+                    from qiskit.circuit.classicalfunction.utils import tweedledum2qiskit
 
-                truth_table = boolean_expression._tweedledum_bool_expression.truth_table(
-                    output_bit=0
-                )
-                tweedledum_circuit = pkrm_synth(truth_table, {"pkrm_synth": {"phase_esop": True}})
-                return tweedledum2qiskit(tweedledum_circuit)
+                    truth_table = boolean_expression._tweedledum_bool_expression.truth_table(
+                        output_bit=0
+                    )
+                    tweedledum_circuit = pkrm_synth(
+                        truth_table, {"pkrm_synth": {"phase_esop": True}}
+                    )
+                    return tweedledum2qiskit(tweedledum_circuit)
 
-        oracle = expression.synth(synthesizer=synthesizer)
+            oracle = expression.synth(synthesizer=synthesizer)
 
-        super().__init__(oracle.num_qubits, name="Phase Oracle")
+            super().__init__(oracle.num_qubits, name="Phase Oracle")
 
-        self.compose(oracle, inplace=True, copy=False)
+            self.compose(oracle, inplace=True, copy=False)
 
     def evaluate_bitstring(self, bitstring: str) -> bool:
         """Evaluate the oracle on a bitstring.

qiskit/circuit/library/standard_gates/rz.py

@@ -37,17 +37,17 @@ class RZGate(Gate):
     .. code-block:: text
 
              ┌───────┐
-        q_0: ┤ Rz(λ) ├
+        q_0: ┤ Rz(φ) ├
              └───────┘
 
     **Matrix Representation:**
 
     .. math::
 
-        RZ(\lambda) = \exp\left(-i\frac{\lambda}{2}Z\right) =
+        RZ(\phi) = \exp\left(-i\frac{\phi}{2}Z\right) =
             \begin{pmatrix}
-                e^{-i\frac{\lambda}{2}} & 0 \\
-                0 & e^{i\frac{\lambda}{2}}
+                e^{-i\frac{\phi}{2}} & 0 \\
+                0 & e^{i\frac{\phi}{2}}
             \end{pmatrix}
 
     .. seealso::
@@ -57,7 +57,7 @@ class RZGate(Gate):
 
             .. math::
 
-                U1(\lambda) = e^{i{\lambda}/2}RZ(\lambda)
+                U1(\theta=\phi) = e^{i{\phi}/2}RZ(\phi)
 
         Reference for virtual Z gate implementation:
         `1612.00858 <https://arxiv.org/abs/1612.00858>`_
@@ -186,10 +186,10 @@ class CRZGate(ControlledGate):
     .. math::
 
         CRZ(\theta)\ q_0, q_1 =
-            I \otimes |0\rangle\langle 0| + RZ(\theta) \otimes |1\rangle\langle 1| =
+            I \otimes |0\rangle\langle 0| + RZ(\phi=\theta) \otimes |1\rangle\langle 1| =
             \begin{pmatrix}
                 1 & 0 & 0 & 0 \\
-                0 & e^{-i\frac{\lambda}{2}} & 0 & 0 \\
+                0 & e^{-i\frac{\theta}{2}} & 0 & 0 \\
                 0 & 0 & 1 & 0 \\
                 0 & 0 & 0 & e^{i\frac{\theta}{2}}
             \end{pmatrix}

qiskit/circuit/library/standard_gates/xx_minus_yy.py

@@ -63,36 +63,6 @@ class XXMinusYYGate(Gate):
                 0 & 0 & 1 & 0 \\
                 -i\sin\left(\rotationangle\right)e^{i\beta} & 0 & 0 & \cos\left(\rotationangle\right)
             \end{pmatrix}
-
-    .. note::
-
-        In Qiskit's convention, higher qubit indices are more significant
-        (little endian convention). In the above example we apply the gate
-        on (q_0, q_1) which results in adding the (optional) phase defined
-        by :math:`\beta` on q_1. Instead, if we apply it on (q_1, q_0), the
-        phase is added on q_0. If :math:`\beta` is set to its default value
-        of :math:`0`, the gate is equivalent in big and little endian.
-
-        .. code-block:: text
-
-                 ┌───────────────┐
-            q_0: ┤1              ├
-                 │  (XX-YY)(θ,β) │
-            q_1: ┤0              ├
-                 └───────────────┘
-
-        .. math::
-
-            \newcommand{\rotationangle}{\frac{\theta}{2}}
-
-            R_{XX-YY}(\theta, \beta) q_1, q_0 =
-            RZ_0(\beta) \cdot \exp\left(-i \frac{\theta}{2} \frac{XX-YY}{2}\right) \cdot RZ_0(-\beta) =
-            \begin{pmatrix}
-                \cos\left(\rotationangle\right) & 0 & 0 & -i\sin\left(\rotationangle\right)e^{i\beta} \\
-                0 & 1 & 0 & 0 \\
-                0 & 0 & 1 & 0 \\
-                -i\sin\left(\rotationangle\right)e^{-i\beta} & 0 & 0 & \cos\left(\rotationangle\right)
-            \end{pmatrix}
     """
 
     _standard_gate = StandardGate.XXMinusYYGate

qiskit/circuit/parametervector.py

@@ -18,7 +18,12 @@ from .parameter import Parameter
 
 
 class ParameterVectorElement(Parameter):
-    """An element of a ParameterVector."""
+    """An element of a :class:`ParameterVector`.
+
+    .. note::
+        There is very little reason to ever construct this class directly.  Objects of this type are
+        automatically constructed efficiently as part of creating a :class:`ParameterVector`.
+    """
 
     ___slots__ = ("_vector", "_index")
 
@@ -48,7 +53,18 @@ class ParameterVectorElement(Parameter):
 
 
 class ParameterVector:
-    """ParameterVector class to quickly generate lists of parameters."""
+    """A container of many related :class:`Parameter` objects.
+
+    This class is faster to construct than constructing many :class:`Parameter` objects
+    individually, and the individual names of the parameters will all share a common stem (the name
+    of the vector).  For a vector called ``v`` with length 3, the individual elements will have
+    names ``v[0]``, ``v[1]`` and ``v[2]``.
+
+    The elements of a vector are sorted by the name of the vector, then the numeric value of their
+    index.
+
+    This class fulfill the :class:`collections.abc.Sequence` interface.
+    """
 
     __slots__ = ("_name", "_params", "_root_uuid")
 
@@ -62,16 +78,20 @@ class ParameterVector:
 
     @property
     def name(self):
-        """Returns the name of the ParameterVector."""
+        """The name of the :class:`ParameterVector`."""
         return self._name
 
     @property
     def params(self):
-        """Returns the list of parameters in the ParameterVector."""
+        """A list of the contained :class:`ParameterVectorElement` instances.
+
+        It is not safe to mutate this list."""
         return self._params
 
     def index(self, value):
-        """Returns first index of value."""
+        """Find the index of a :class:`ParameterVectorElement` within the list.
+
+        It is typically much faster to use the :attr:`ParameterVectorElement.index` property."""
         return self._params.index(value)
 
     def __getitem__(self, key):

qiskit/circuit/quantumcircuit.py

@@ -40,6 +40,7 @@ from typing import (
 import numpy as np
 from qiskit._accelerate.circuit import CircuitData
 from qiskit._accelerate.circuit import StandardGate
+from qiskit._accelerate.circuit_duration import compute_estimated_duration
 from qiskit.exceptions import QiskitError
 from qiskit.utils.multiprocessing import is_main_process
 from qiskit.circuit.instruction import Instruction
@@ -156,6 +157,8 @@ class QuantumCircuit:
     :attr:`data`              List of individual :class:`CircuitInstruction`\\ s that make up the
                               circuit.
     :attr:`duration`          Total duration of the circuit, added by scheduling transpiler passes.
+                              This attribute is deprecated and :meth:`.estimate_duration` should
+                              be used instead.
 
     :attr:`layout`            Hardware layout and routing information added by the transpiler.
     :attr:`num_ancillas`      The number of ancilla qubits in the circuit.
@@ -903,8 +906,9 @@ class QuantumCircuit:
 
     If a :class:`QuantumCircuit` has been scheduled as part of a transpilation pipeline, the timing
     information for individual qubits can be accessed.  The whole-circuit timing information is
-    available through the :attr:`duration`, :attr:`unit` and :attr:`op_start_times` attributes.
+    available through the :meth:`estimate_duration` method and :attr:`op_start_times` attribute.
 
+    .. automethod:: estimate_duration
     .. automethod:: qubit_duration
     .. automethod:: qubit_start_time
     .. automethod:: qubit_stop_time
@@ -6646,7 +6650,69 @@ class QuantumCircuit:
             if len(qubits) == len([done for done in dones.values() if done]):  # all done
                 return max(stop for stop in stops.values())
 
-        return 0  # If there are no instructions over bits
+        if len(stops) > 0:  # not all but some qubits has instructions
+            return max(stops.values())
+        else:
+            return 0  # If there are no instructions over bits
+
+    def estimate_duration(self, target, unit: str = "s") -> int | float:
+        """Estimate the duration of a scheduled circuit
+
+        This method computes the estimate of the circuit duration by finding
+        the longest duration path in the circuit based on the durations
+        provided by a given target. This method only works for simple circuits
+        that have no control flow or other classical feed-forward operations.
+
+        Args:
+            target (Target): The :class:`.Target` instance that contains durations for
+                the instructions if the target is missing duration data for any of the
+                instructions in the circuit an :class:`.QiskitError` will be raised. This
+                should be the same target object used as the target for transpilation.
+            unit: The unit to return the duration in. This defaults to "s" for seconds
+                but this can be a supported SI prefix for seconds returns. For example
+                setting this to "n" will return in unit of nanoseconds. Supported values
+                of this type are "f", "p", "n", "u", "µ", "m", "k", "M", "G", "T", and
+                "P". Additionally, a value of "dt" is also accepted to output an integer
+                in units of "dt". For this to function "dt" must be specified in the
+                ``target``.
+
+        Returns:
+            The estimated duration for the execution of a single shot of the circuit in
+            the specified unit.
+
+        Raises:
+            QiskitError: If the circuit is not scheduled or contains other
+                details that prevent computing an estimated duration from
+                (such as parameterized delay).
+        """
+        from qiskit.converters import circuit_to_dag
+
+        dur = compute_estimated_duration(circuit_to_dag(self), target)
+        if unit == "s":
+            return dur
+        if unit == "dt":
+            from qiskit.circuit.duration import duration_in_dt  # pylint: disable=cyclic-import
+
+            return duration_in_dt(dur, target.dt)
+
+        prefix_dict = {
+            "f": 1e-15,
+            "p": 1e-12,
+            "n": 1e-9,
+            "u": 1e-6,
+            "µ": 1e-6,
+            "m": 1e-3,
+            "k": 1e3,
+            "M": 1e6,
+            "G": 1e9,
+            "T": 1e12,
+            "P": 1e15,
+        }
+        if unit not in prefix_dict:
+            raise QiskitError(
+                f"Specified unit: {unit} is not a valid/supported SI prefix, 's', or 'dt'"
+            )
+        return dur / prefix_dict[unit]
 
 
 class _OuterCircuitScopeInterface(CircuitScopeInterface):

qiskit/circuit/register.py

@@ -17,7 +17,9 @@ Base register reference object.
 """
 
 from __future__ import annotations
+
 import itertools
+import warnings
 import numpy as np
 
 from qiskit.circuit.exceptions import CircuitError
@@ -125,6 +127,17 @@ class Register:
             # until first access.
             self._bit_indices = None
 
+    def __init_subclass__(cls):
+        # In Qiskit 2.0, `Bit` and `Register` will move to Rust space, and the allowable types of
+        # them will be fixed, similar to if the classes had been marked as `final`.
+        if cls.__module__.split(".", 2)[0] != __name__.split(".", 2)[0]:
+            warnings.warn(
+                "subclassing 'Register' is not supported, and may not be possible in Qiskit 2.0",
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+        return cls
+
     @property
     def name(self):
         """Get the register name."""

qiskit/compiler/assembler.py

@@ -261,14 +261,22 @@ def _assemble(
 
     # assemble either circuits or schedules
     if all(isinstance(exp, QuantumCircuit) for exp in experiments):
-        run_config = _parse_circuit_args(
-            parameter_binds,
-            backend,
-            meas_level,
-            meas_return,
-            parametric_pulses,
-            **run_config_common_dict,
-        )
+        with warnings.catch_warnings():
+            # Internally calls deprecated BasicSimulator.configuration()`
+            warnings.filterwarnings(
+                "ignore",
+                category=DeprecationWarning,
+                message=r".+\.basic_provider\.basic_simulator\.BasicSimulator\.configuration.+",
+                module="qiskit",
+            )
+            run_config = _parse_circuit_args(
+                parameter_binds,
+                backend,
+                meas_level,
+                meas_return,
+                parametric_pulses,
+                **run_config_common_dict,
+            )
 
         # If circuits are parameterized, bind parameters and remove from run_config
         bound_experiments, run_config = _expand_parameters(

qiskit/compiler/transpiler.py

@@ -191,7 +191,7 @@ def transpile(  # pylint: disable=too-many-return-statements
             This can also be the external plugin name to use for the ``routing`` stage.
             You can see a list of installed plugins by using :func:`~.list_stage_plugins` with
             ``"routing"`` for the ``stage_name`` argument.
-        translation_method: Name of translation pass ('unroller', 'translator', 'synthesis')
+        translation_method: Name of translation pass (``"translator"`` or ``"synthesis"``)
             This can also be the external plugin name to use for the ``translation`` stage.
             You can see a list of installed plugins by using :func:`~.list_stage_plugins` with
             ``"translation"`` for the ``stage_name`` argument.

qiskit/dagcircuit/dagdependency_v2.py

@@ -13,6 +13,7 @@
 """_DAGDependencyV2 class for representing non-commutativity in a circuit.
 """
 
+import itertools
 import math
 from collections import OrderedDict, defaultdict, namedtuple
 from typing import Dict, List, Generator, Any
@@ -344,7 +345,6 @@ class _DAGDependencyV2:
             op=operation,
             qargs=qargs,
             cargs=cargs,
-            dag=self,
         )
         new_node._node_id = self._multi_graph.add_node(new_node)
         self._update_edges()
@@ -459,7 +459,9 @@ class _DAGDependencyV2:
         """
 
         def _key(x):
-            return x.sort_key
+            return ",".join(
+                f"{self.find_bit(q).index:04d}" for q in itertools.chain(x.qargs, x.cargs)
+            )
 
         if key is None:
             key = _key