From 8c74a49dcdd3ea01f5fa9c1cf59a4f6b2d4bb39d Mon Sep 17 00:00:00 2001
From: aeddins-ibm <60495383+aeddins-ibm@users.noreply.github.com>
Date: Thu, 15 Aug 2024 03:42:41 -0400
Subject: [PATCH 01/85] Fix setter so that `SparsePauliOp.paulis.phase` stays
 zero (#12884)

* absorb `phase` into `coeffs` in `paulis()` setter

* do not mutate input array

* add test that paulis setter absorbs phase

* lint

* If input paulis have phase, mutate and warn

* add release note

* release-note formatting

* add test with `simplify()`

* remove phase-warning from paulis setter

* lint

* remove unused import

* update reno
---
 .../operators/symplectic/sparse_pauli_op.py   |  2 ++
 ...rsepauliop-phase-bug-2b24f4b775ca564f.yaml |  8 ++++++++
 .../symplectic/test_sparse_pauli_op.py        | 19 +++++++++++++++++++
 3 files changed, 29 insertions(+)
 create mode 100644 releasenotes/notes/fix-sparsepauliop-phase-bug-2b24f4b775ca564f.yaml

diff --git a/qiskit/quantum_info/operators/symplectic/sparse_pauli_op.py b/qiskit/quantum_info/operators/symplectic/sparse_pauli_op.py
index 10d76f8719af..4621019a9d81 100644
--- a/qiskit/quantum_info/operators/symplectic/sparse_pauli_op.py
+++ b/qiskit/quantum_info/operators/symplectic/sparse_pauli_op.py
@@ -256,6 +256,8 @@ def paulis(self, value):
             raise ValueError(
                 f"incorrect number of operators: expected {len(self.paulis)}, got {len(value)}"
             )
+        self.coeffs *= (-1j) ** value.phase
+        value.phase = 0
         self._pauli_list = value
 
     @property
diff --git a/releasenotes/notes/fix-sparsepauliop-phase-bug-2b24f4b775ca564f.yaml b/releasenotes/notes/fix-sparsepauliop-phase-bug-2b24f4b775ca564f.yaml
new file mode 100644
index 000000000000..ff1cf96dd711
--- /dev/null
+++ b/releasenotes/notes/fix-sparsepauliop-phase-bug-2b24f4b775ca564f.yaml
@@ -0,0 +1,8 @@
+---
+fixes:
+  - |
+    Fixed a bug when :attr:`.SparsePauliOp.paulis` is set to be a :class:`.PauliList` with nonzero 
+    phase, where subsequent calls to several :class:`.SparsePauliOp` methods would produce 
+    incorrect results. Now when :attr:`.SparsePauliOp.paulis` is set to a :class:`.PauliList` with 
+    nonzero phase, the phase is absorbed into :attr:`.SparsePauliOp.coeffs`, and the phase of the 
+    input :class:`.PauliList` is set to zero.
diff --git a/test/python/quantum_info/operators/symplectic/test_sparse_pauli_op.py b/test/python/quantum_info/operators/symplectic/test_sparse_pauli_op.py
index 4964b0c6a609..dedd84279a8d 100644
--- a/test/python/quantum_info/operators/symplectic/test_sparse_pauli_op.py
+++ b/test/python/quantum_info/operators/symplectic/test_sparse_pauli_op.py
@@ -1097,6 +1097,25 @@ def test_paulis_setter_rejects_bad_inputs(self):
         with self.assertRaisesRegex(ValueError, "incorrect number of operators"):
             op.paulis = PauliList([Pauli("XY"), Pauli("ZX"), Pauli("YZ")])
 
+    def test_paulis_setter_absorbs_phase(self):
+        """Test that the setter for `paulis` absorbs `paulis.phase` to `self.coeffs`."""
+        coeffs_init = np.array([1, 1j])
+        op = SparsePauliOp(["XY", "ZX"], coeffs=coeffs_init)
+        paulis_new = PauliList(["-1jXY", "1jZX"])
+        op.paulis = paulis_new
+        # Paulis attribute should have no phase:
+        self.assertEqual(op.paulis, PauliList(["XY", "ZX"]))
+        # Coeffs attribute should now include that phase:
+        self.assertTrue(np.allclose(op.coeffs, coeffs_init * np.array([-1j, 1j])))
+        # The phase of the input array is now zero:
+        self.assertTrue(np.allclose(paulis_new.phase, np.array([0, 0])))
+
+    def test_paulis_setter_absorbs_phase_2(self):
+        """Test that `paulis` setter followed by `simplify()` handle phase OK."""
+        spo = SparsePauliOp(["X", "X"])
+        spo.paulis = ["X", "-X"]
+        self.assertEqual(spo.simplify(), SparsePauliOp(["I"], coeffs=[0.0 + 0.0j]))
+
     def test_apply_layout_with_transpile(self):
         """Test the apply_layout method with a transpiler layout."""
         psi = EfficientSU2(4, reps=4, entanglement="circular")

From 713ab38cccb7e55a40a87372a2590a5a4430fa8f Mon Sep 17 00:00:00 2001
From: Luciano Bello <bel@zurich.ibm.com>
Date: Thu, 15 Aug 2024 19:34:50 +0200
Subject: [PATCH 02/85] Internally importing `qiskit.providers.backend.Backend`
 should not raise `DeprecationWarning` (#12906)

* better module deprecation

* _pulse_library

* __getattr__

* copy qiskit.qobj.PulseQobjInstruction and qiskit.qobj.PulseLibraryItem for internal generic_backend_v2 usage

* lint

* Aer models

* skip

* more generic catch

* specific imports
---
 qiskit/compiler/transpiler.py                 |   2 +-
 .../basic_provider/basic_simulator.py         |   2 +-
 .../fake_provider/fake_openpulse_2q.py        |   6 +-
 .../fake_provider/fake_openpulse_3q.py        |   5 +-
 .../fake_provider/fake_pulse_backend.py       |   3 +-
 .../fake_provider/fake_qasm_backend.py        |   3 +-
 .../fake_provider/generic_backend_v2.py       | 452 +++++++++++++++++-
 qiskit/providers/models/__init__.py           |  68 ++-
 .../passes/synthesis/unitary_synthesis.py     |   2 +-
 test/benchmarks/pulse/load_pulse_defaults.py  |   2 +-
 test/python/providers/faulty_backends.py      |   2 +-
 test/python/providers/test_backendstatus.py   |   2 +-
 test/python/providers/test_fake_backends.py   |   2 +-
 .../python/transpiler/test_pulse_gate_pass.py |   2 +-
 test/utils/base.py                            |   2 +-
 15 files changed, 499 insertions(+), 56 deletions(-)

diff --git a/qiskit/compiler/transpiler.py b/qiskit/compiler/transpiler.py
index 929089c4ac41..5e2dcf8a1560 100644
--- a/qiskit/compiler/transpiler.py
+++ b/qiskit/compiler/transpiler.py
@@ -23,7 +23,7 @@
 from qiskit.dagcircuit import DAGCircuit
 from qiskit.providers.backend import Backend
 from qiskit.providers.backend_compat import BackendV2Converter
-from qiskit.providers.models import BackendProperties
+from qiskit.providers.models.backendproperties import BackendProperties
 from qiskit.pulse import Schedule, InstructionScheduleMap
 from qiskit.transpiler import Layout, CouplingMap, PropertySet
 from qiskit.transpiler.basepasses import BasePass
diff --git a/qiskit/providers/basic_provider/basic_simulator.py b/qiskit/providers/basic_provider/basic_simulator.py
index 32666c57f184..fd535d9f7278 100644
--- a/qiskit/providers/basic_provider/basic_simulator.py
+++ b/qiskit/providers/basic_provider/basic_simulator.py
@@ -43,7 +43,7 @@
 from qiskit.circuit.library.standard_gates import get_standard_gate_name_mapping, GlobalPhaseGate
 from qiskit.providers import Provider
 from qiskit.providers.backend import BackendV2
-from qiskit.providers.models import BackendConfiguration
+from qiskit.providers.models.backendconfiguration import BackendConfiguration
 from qiskit.providers.options import Options
 from qiskit.qobj import QasmQobj, QasmQobjConfig, QasmQobjExperiment
 from qiskit.result import Result
diff --git a/qiskit/providers/fake_provider/fake_openpulse_2q.py b/qiskit/providers/fake_provider/fake_openpulse_2q.py
index c76f4e048828..036c0bc6c1b7 100644
--- a/qiskit/providers/fake_provider/fake_openpulse_2q.py
+++ b/qiskit/providers/fake_provider/fake_openpulse_2q.py
@@ -16,14 +16,14 @@
 import datetime
 import warnings
 
-from qiskit.providers.models import (
+from qiskit.providers.models.backendconfiguration import (
     GateConfig,
     PulseBackendConfiguration,
-    PulseDefaults,
-    Command,
     UchannelLO,
 )
+
 from qiskit.providers.models.backendproperties import Nduv, Gate, BackendProperties
+from qiskit.providers.models.pulsedefaults import PulseDefaults, Command
 from qiskit.qobj import PulseQobjInstruction
 
 from .fake_backend import FakeBackend
diff --git a/qiskit/providers/fake_provider/fake_openpulse_3q.py b/qiskit/providers/fake_provider/fake_openpulse_3q.py
index 36b66847dad4..424cad006ed8 100644
--- a/qiskit/providers/fake_provider/fake_openpulse_3q.py
+++ b/qiskit/providers/fake_provider/fake_openpulse_3q.py
@@ -15,13 +15,12 @@
 """
 import warnings
 
-from qiskit.providers.models import (
+from qiskit.providers.models.backendconfiguration import (
     GateConfig,
     PulseBackendConfiguration,
-    PulseDefaults,
-    Command,
     UchannelLO,
 )
+from qiskit.providers.models.pulsedefaults import PulseDefaults, Command
 from qiskit.qobj import PulseQobjInstruction
 
 from .fake_backend import FakeBackend
diff --git a/qiskit/providers/fake_provider/fake_pulse_backend.py b/qiskit/providers/fake_provider/fake_pulse_backend.py
index fdb02f7d4350..bf772d339bc7 100644
--- a/qiskit/providers/fake_provider/fake_pulse_backend.py
+++ b/qiskit/providers/fake_provider/fake_pulse_backend.py
@@ -15,7 +15,8 @@
 """
 
 from qiskit.exceptions import QiskitError
-from qiskit.providers.models import PulseBackendConfiguration, PulseDefaults
+from qiskit.providers.models.backendconfiguration import PulseBackendConfiguration
+from qiskit.providers.models.pulsedefaults import PulseDefaults
 
 from .fake_qasm_backend import FakeQasmBackend
 from .utils.json_decoder import decode_pulse_defaults
diff --git a/qiskit/providers/fake_provider/fake_qasm_backend.py b/qiskit/providers/fake_provider/fake_qasm_backend.py
index 7ad7222f7907..a570ac401601 100644
--- a/qiskit/providers/fake_provider/fake_qasm_backend.py
+++ b/qiskit/providers/fake_provider/fake_qasm_backend.py
@@ -19,7 +19,8 @@
 import warnings
 
 from qiskit.exceptions import QiskitError
-from qiskit.providers.models import BackendProperties, QasmBackendConfiguration
+from qiskit.providers.models.backendproperties import BackendProperties
+from qiskit.providers.models.backendconfiguration import QasmBackendConfiguration
 
 from .utils.json_decoder import (
     decode_backend_configuration,
diff --git a/qiskit/providers/fake_provider/generic_backend_v2.py b/qiskit/providers/fake_provider/generic_backend_v2.py
index 6374a0b0b60a..770c8762152e 100644
--- a/qiskit/providers/fake_provider/generic_backend_v2.py
+++ b/qiskit/providers/fake_provider/generic_backend_v2.py
@@ -16,6 +16,7 @@
 import warnings
 
 from collections.abc import Iterable
+from typing import List, Dict, Any, Union
 import numpy as np
 
 from qiskit import pulse
@@ -35,12 +36,12 @@
 from qiskit.providers import Options
 from qiskit.providers.basic_provider import BasicSimulator
 from qiskit.providers.backend import BackendV2
-from qiskit.providers.models import (
-    PulseDefaults,
-    Command,
-)
-from qiskit.qobj import PulseQobjInstruction, PulseLibraryItem
 from qiskit.utils import optionals as _optionals
+from qiskit.providers.models.pulsedefaults import Command
+from qiskit.qobj.converters.pulse_instruction import QobjToInstructionConverter
+from qiskit.pulse.calibration_entries import PulseQobjDef
+from qiskit.providers.models.pulsedefaults import MeasurementKernel, Discriminator
+from qiskit.qobj.pulse_qobj import QobjMeasurementOption
 
 # Noise default values/ranges for duration and error of supported
 # instructions. There are two possible formats:
@@ -74,17 +75,432 @@
     "frequency": (5e9, 5.5e9),
 }
 
-# The number of samples determines the pulse durations of the corresponding
-# instructions. This default defines pulses with durations in multiples of
-# 16 dt for consistency with the pulse granularity of real IBM devices, but
-# keeps the number smaller than what would be realistic for
-# manageability. If needed, more realistic durations could be added in the
-# future (order of 160dt for 1q gates, 1760dt for 2q gates and measure).
-_PULSE_LIBRARY = [
-    PulseLibraryItem(name="pulse_1", samples=np.linspace(0, 1.0, 16, dtype=np.complex128)),  # 16dt
-    PulseLibraryItem(name="pulse_2", samples=np.linspace(0, 1.0, 32, dtype=np.complex128)),  # 32dt
-    PulseLibraryItem(name="pulse_3", samples=np.linspace(0, 1.0, 64, dtype=np.complex128)),  # 64dt
-]
+
+class PulseDefaults:
+    """Internal - Description of default settings for Pulse systems. These are instructions
+    or settings that
+    may be good starting points for the Pulse user. The user may modify these defaults for custom
+    scheduling.
+    """
+
+    # Copy from the deprecated from qiskit.providers.models.pulsedefaults.PulseDefaults
+
+    _data = {}
+
+    def __init__(
+        self,
+        qubit_freq_est: List[float],
+        meas_freq_est: List[float],
+        buffer: int,
+        pulse_library: List[PulseLibraryItem],
+        cmd_def: List[Command],
+        meas_kernel: MeasurementKernel = None,
+        discriminator: Discriminator = None,
+        **kwargs: Dict[str, Any],
+    ):
+        """
+        Validate and reformat transport layer inputs to initialize.
+        Args:
+            qubit_freq_est: Estimated qubit frequencies in GHz.
+            meas_freq_est: Estimated measurement cavity frequencies in GHz.
+            buffer: Default buffer time (in units of dt) between pulses.
+            pulse_library: Pulse name and sample definitions.
+            cmd_def: Operation name and definition in terms of Commands.
+            meas_kernel: The measurement kernels
+            discriminator: The discriminators
+            **kwargs: Other attributes for the super class.
+        """
+        self._data = {}
+        self.buffer = buffer
+        self.qubit_freq_est = [freq * 1e9 for freq in qubit_freq_est]
+        """Qubit frequencies in Hertz."""
+        self.meas_freq_est = [freq * 1e9 for freq in meas_freq_est]
+        """Measurement frequencies in Hertz."""
+        self.pulse_library = pulse_library
+        self.cmd_def = cmd_def
+        self.instruction_schedule_map = InstructionScheduleMap()
+        self.converter = QobjToInstructionConverter(pulse_library)
+
+        for inst in cmd_def:
+            entry = PulseQobjDef(converter=self.converter, name=inst.name)
+            entry.define(inst.sequence, user_provided=False)
+            self.instruction_schedule_map._add(
+                instruction_name=inst.name,
+                qubits=tuple(inst.qubits),
+                entry=entry,
+            )
+
+        if meas_kernel is not None:
+            self.meas_kernel = meas_kernel
+        if discriminator is not None:
+            self.discriminator = discriminator
+
+        self._data.update(kwargs)
+
+    def __getattr__(self, name):
+        try:
+            return self._data[name]
+        except KeyError as ex:
+            raise AttributeError(f"Attribute {name} is not defined") from ex
+
+    def to_dict(self):
+        """Return a dictionary format representation of the PulseDefaults.
+        Returns:
+            dict: The dictionary form of the PulseDefaults.
+        """
+        out_dict = {
+            "qubit_freq_est": self.qubit_freq_est,
+            "meas_freq_est": self.qubit_freq_est,
+            "buffer": self.buffer,
+            "pulse_library": [x.to_dict() for x in self.pulse_library],
+            "cmd_def": [x.to_dict() for x in self.cmd_def],
+        }
+        if hasattr(self, "meas_kernel"):
+            out_dict["meas_kernel"] = self.meas_kernel.to_dict()
+        if hasattr(self, "discriminator"):
+            out_dict["discriminator"] = self.discriminator.to_dict()
+        for key, value in self.__dict__.items():
+            if key not in [
+                "qubit_freq_est",
+                "meas_freq_est",
+                "buffer",
+                "pulse_library",
+                "cmd_def",
+                "meas_kernel",
+                "discriminator",
+                "converter",
+                "instruction_schedule_map",
+            ]:
+                out_dict[key] = value
+        out_dict.update(self._data)
+
+        out_dict["qubit_freq_est"] = [freq * 1e-9 for freq in self.qubit_freq_est]
+        out_dict["meas_freq_est"] = [freq * 1e-9 for freq in self.meas_freq_est]
+        return out_dict
+
+    @classmethod
+    def from_dict(cls, data):
+        """Create a new PulseDefaults object from a dictionary.
+
+        Args:
+            data (dict): A dictionary representing the PulseDefaults
+                         to create. It will be in the same format as output by
+                         :meth:`to_dict`.
+        Returns:
+            PulseDefaults: The PulseDefaults from the input dictionary.
+        """
+        schema = {
+            "pulse_library": PulseLibraryItem,  # The class PulseLibraryItem is deprecated
+            "cmd_def": Command,
+            "meas_kernel": MeasurementKernel,
+            "discriminator": Discriminator,
+        }
+
+        # Pulse defaults data is nested dictionary.
+        # To avoid deepcopy and avoid mutating the source object, create new dict here.
+        in_data = {}
+        for key, value in data.items():
+            if key in schema:
+                with warnings.catch_warnings():
+                    # The class PulseLibraryItem is deprecated
+                    warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+                    if isinstance(value, list):
+                        in_data[key] = list(map(schema[key].from_dict, value))
+                    else:
+                        in_data[key] = schema[key].from_dict(value)
+            else:
+                in_data[key] = value
+
+        return cls(**in_data)
+
+    def __str__(self):
+        qubit_freqs = [freq / 1e9 for freq in self.qubit_freq_est]
+        meas_freqs = [freq / 1e9 for freq in self.meas_freq_est]
+        qfreq = f"Qubit Frequencies [GHz]\n{qubit_freqs}"
+        mfreq = f"Measurement Frequencies [GHz]\n{meas_freqs} "
+        return f"<{self.__class__.__name__}({str(self.instruction_schedule_map)}{qfreq}\n{mfreq})>"
+
+
+def _to_complex(value: Union[List[float], complex]) -> complex:
+    """Convert the input value to type ``complex``.
+    Args:
+        value: Value to be converted.
+    Returns:
+        Input value in ``complex``.
+    Raises:
+        TypeError: If the input value is not in the expected format.
+    """
+    if isinstance(value, list) and len(value) == 2:
+        return complex(value[0], value[1])
+    elif isinstance(value, complex):
+        return value
+
+    raise TypeError(f"{value} is not in a valid complex number format.")
+
+
+class PulseLibraryItem:
+    """INTERNAL - An item in a pulse library."""
+
+    # Copy from the deprecated from qiskit.qobj.PulseLibraryItem
+    def __init__(self, name, samples):
+        """Instantiate a pulse library item.
+
+        Args:
+            name (str): A name for the pulse.
+            samples (list[complex]): A list of complex values defining pulse
+                shape.
+        """
+        self.name = name
+        if isinstance(samples[0], list):
+            self.samples = np.array([complex(sample[0], sample[1]) for sample in samples])
+        else:
+            self.samples = samples
+
+    def to_dict(self):
+        """Return a dictionary format representation of the pulse library item.
+
+        Returns:
+            dict: The dictionary form of the PulseLibraryItem.
+        """
+        return {"name": self.name, "samples": self.samples}
+
+    @classmethod
+    def from_dict(cls, data):
+        """Create a new PulseLibraryItem object from a dictionary.
+
+        Args:
+            data (dict): A dictionary for the experiment config
+
+        Returns:
+            PulseLibraryItem: The object from the input dictionary.
+        """
+        return cls(**data)
+
+    def __repr__(self):
+        return f"PulseLibraryItem({self.name}, {repr(self.samples)})"
+
+    def __str__(self):
+        return f"Pulse Library Item:\n\tname: {self.name}\n\tsamples: {self.samples}"
+
+    def __eq__(self, other):
+        if isinstance(other, PulseLibraryItem):
+            if self.to_dict() == other.to_dict():
+                return True
+        return False
+
+
+class PulseQobjInstruction:
+    """Internal - A class representing a single instruction in a PulseQobj Experiment."""
+
+    # Copy from the deprecated from qiskit.qobj.PulseQobjInstruction
+
+    _COMMON_ATTRS = [
+        "ch",
+        "conditional",
+        "val",
+        "phase",
+        "frequency",
+        "duration",
+        "qubits",
+        "memory_slot",
+        "register_slot",
+        "label",
+        "type",
+        "pulse_shape",
+        "parameters",
+    ]
+
+    def __init__(
+        self,
+        name,
+        t0,
+        ch=None,
+        conditional=None,
+        val=None,
+        phase=None,
+        duration=None,
+        qubits=None,
+        memory_slot=None,
+        register_slot=None,
+        kernels=None,
+        discriminators=None,
+        label=None,
+        type=None,  # pylint: disable=invalid-name,redefined-builtin
+        pulse_shape=None,
+        parameters=None,
+        frequency=None,
+    ):
+        """Instantiate a new PulseQobjInstruction object.
+
+        Args:
+            name (str): The name of the instruction
+            t0 (int): Pulse start time in integer **dt** units.
+            ch (str): The channel to apply the pulse instruction.
+            conditional (int): The register to use for a conditional for this
+                instruction
+            val (complex): Complex value to apply, bounded by an absolute value
+                of 1.
+            phase (float): if a ``fc`` instruction, the frame change phase in
+                radians.
+            frequency (float): if a ``sf`` instruction, the frequency in Hz.
+            duration (int): The duration of the pulse in **dt** units.
+            qubits (list): A list of ``int`` representing the qubits the
+                instruction operates on
+            memory_slot (list): If a ``measure`` instruction this is a list
+                of ``int`` containing the list of memory slots to store the
+                measurement results in (must be the same length as qubits).
+                If a ``bfunc`` instruction this is a single ``int`` of the
+                memory slot to store the boolean function result in.
+            register_slot (list): If a ``measure`` instruction this is a list
+                of ``int`` containing the list of register slots in which to
+                store the measurement results (must be the same length as
+                qubits). If a ``bfunc`` instruction this is a single ``int``
+                of the register slot in which to store the result.
+            kernels (list): List of :class:`QobjMeasurementOption` objects
+                defining the measurement kernels and set of parameters if the
+                measurement level is 1 or 2. Only used for ``acquire``
+                instructions.
+            discriminators (list): A list of :class:`QobjMeasurementOption`
+                used to set the discriminators to be used if the measurement
+                level is 2. Only used for ``acquire`` instructions.
+            label (str): Label of instruction
+            type (str): Type of instruction
+            pulse_shape (str): The shape of the parametric pulse
+            parameters (dict): The parameters for a parametric pulse
+        """
+        self.name = name
+        self.t0 = t0
+        if ch is not None:
+            self.ch = ch
+        if conditional is not None:
+            self.conditional = conditional
+        if val is not None:
+            self.val = val
+        if phase is not None:
+            self.phase = phase
+        if frequency is not None:
+            self.frequency = frequency
+        if duration is not None:
+            self.duration = duration
+        if qubits is not None:
+            self.qubits = qubits
+        if memory_slot is not None:
+            self.memory_slot = memory_slot
+        if register_slot is not None:
+            self.register_slot = register_slot
+        if kernels is not None:
+            self.kernels = kernels
+        if discriminators is not None:
+            self.discriminators = discriminators
+        if label is not None:
+            self.label = label
+        if type is not None:
+            self.type = type
+        if pulse_shape is not None:
+            self.pulse_shape = pulse_shape
+        if parameters is not None:
+            self.parameters = parameters
+
+    def to_dict(self):
+        """Return a dictionary format representation of the Instruction.
+
+        Returns:
+            dict: The dictionary form of the PulseQobjInstruction.
+        """
+        out_dict = {"name": self.name, "t0": self.t0}
+        for attr in self._COMMON_ATTRS:
+            if hasattr(self, attr):
+                out_dict[attr] = getattr(self, attr)
+        if hasattr(self, "kernels"):
+            out_dict["kernels"] = [x.to_dict() for x in self.kernels]
+        if hasattr(self, "discriminators"):
+            out_dict["discriminators"] = [x.to_dict() for x in self.discriminators]
+        return out_dict
+
+    def __repr__(self):
+        out = f'PulseQobjInstruction(name="{self.name}", t0={self.t0}'
+        for attr in self._COMMON_ATTRS:
+            attr_val = getattr(self, attr, None)
+            if attr_val is not None:
+                if isinstance(attr_val, str):
+                    out += f', {attr}="{attr_val}"'
+                else:
+                    out += f", {attr}={attr_val}"
+        out += ")"
+        return out
+
+    def __str__(self):
+        out = f"Instruction: {self.name}\n"
+        out += f"\t\tt0: {self.t0}\n"
+        for attr in self._COMMON_ATTRS:
+            if hasattr(self, attr):
+                out += f"\t\t{attr}: {getattr(self, attr)}\n"
+        return out
+
+    @classmethod
+    def from_dict(cls, data):
+        """Create a new PulseQobjExperimentConfig object from a dictionary.
+
+        Args:
+            data (dict): A dictionary for the experiment config
+
+        Returns:
+            PulseQobjInstruction: The object from the input dictionary.
+        """
+        schema = {
+            "discriminators": QobjMeasurementOption,
+            "kernels": QobjMeasurementOption,
+        }
+        skip = ["t0", "name"]
+
+        # Pulse instruction data is nested dictionary.
+        # To avoid deepcopy and avoid mutating the source object, create new dict here.
+        in_data = {}
+        for key, value in data.items():
+            if key in skip:
+                continue
+            if key == "parameters":
+                # This is flat dictionary of parametric pulse parameters
+                formatted_value = value.copy()
+                if "amp" in formatted_value:
+                    formatted_value["amp"] = _to_complex(formatted_value["amp"])
+                in_data[key] = formatted_value
+                continue
+            if key in schema:
+                if isinstance(value, list):
+                    in_data[key] = list(map(schema[key].from_dict, value))
+                else:
+                    in_data[key] = schema[key].from_dict(value)
+            else:
+                in_data[key] = value
+
+        return cls(data["name"], data["t0"], **in_data)
+
+    def __eq__(self, other):
+        if isinstance(other, PulseQobjInstruction):
+            if self.to_dict() == other.to_dict():
+                return True
+        return False
+
+
+def _pulse_library():
+    # The number of samples determines the pulse durations of the corresponding
+    # instructions. This default defines pulses with durations in multiples of
+    # 16 dt for consistency with the pulse granularity of real IBM devices, but
+    # keeps the number smaller than what would be realistic for
+    # manageability. If needed, more realistic durations could be added in the
+    # future (order of 160dt for 1q gates, 1760dt for 2q gates and measure).
+    return [
+        PulseLibraryItem(
+            name="pulse_1", samples=np.linspace(0, 1.0, 16, dtype=np.complex128)
+        ),  # 16dt
+        PulseLibraryItem(
+            name="pulse_2", samples=np.linspace(0, 1.0, 32, dtype=np.complex128)
+        ),  # 32dt
+        PulseLibraryItem(
+            name="pulse_3", samples=np.linspace(0, 1.0, 64, dtype=np.complex128)
+        ),  # 64dt
+    ]
 
 
 class GenericBackendV2(BackendV2):
@@ -262,7 +678,7 @@ def _get_calibration_sequence(
         acting on qargs.
         """
 
-        pulse_library = _PULSE_LIBRARY
+        pulse_library = _pulse_library()
         # Note that the calibration pulses are different for
         # 1q gates vs 2q gates vs measurement instructions.
         if inst == "measure":
@@ -352,7 +768,7 @@ def _generate_calibration_defaults(self) -> PulseDefaults:
             qubit_freq_est=qubit_freq_est,
             meas_freq_est=meas_freq_est,
             buffer=0,
-            pulse_library=_PULSE_LIBRARY,
+            pulse_library=_pulse_library(),
             cmd_def=cmd_def,
         )
 
diff --git a/qiskit/providers/models/__init__.py b/qiskit/providers/models/__init__.py
index d9e63e3eb75c..d7f8307abb04 100644
--- a/qiskit/providers/models/__init__.py
+++ b/qiskit/providers/models/__init__.py
@@ -38,26 +38,52 @@
    GateProperties
    Nduv
 """
+# pylint: disable=undefined-all-variable
+__all__ = [
+    "BackendConfiguration",
+    "PulseBackendConfiguration",
+    "QasmBackendConfiguration",
+    "UchannelLO",
+    "GateConfig",
+    "BackendProperties",
+    "GateProperties",
+    "Nduv",
+    "BackendStatus",
+    "JobStatus",
+    "PulseDefaults",
+    "Command",
+]
+
+import importlib
 import warnings
 
-from .backendconfiguration import (
-    BackendConfiguration,
-    PulseBackendConfiguration,
-    QasmBackendConfiguration,
-    UchannelLO,
-    GateConfig,
-)
-from .backendproperties import BackendProperties, GateProperties, Nduv
-from .backendstatus import BackendStatus
-from .jobstatus import JobStatus
-from .pulsedefaults import PulseDefaults, Command
-
-
-warnings.warn(
-    "qiskit.providers.models is deprecated since Qiskit 1.2 and will be removed in Qiskit 2.0. "
-    "With the removal of Qobj, there is no need for these schema-conformant objects. If you still need "
-    "to use them, it could be because you are using a BackendV1, which is also deprecated in favor "
-    "of BackendV2.",
-    DeprecationWarning,
-    2,
-)
+
+_NAME_MAP = {
+    # public object name mapped to containing module
+    "BackendConfiguration": "qiskit.providers.models.backendconfiguration",
+    "PulseBackendConfiguration": "qiskit.providers.models.backendconfiguration",
+    "QasmBackendConfiguration": "qiskit.providers.models.backendconfiguration",
+    "UchannelLO": "qiskit.providers.models.backendconfiguration",
+    "GateConfig": "qiskit.providers.models.backendconfiguration",
+    "BackendProperties": "qiskit.providers.models.backendproperties",
+    "GateProperties": "qiskit.providers.models.backendproperties",
+    "Nduv": "qiskit.providers.models.backendproperties",
+    "BackendStatus": "qiskit.providers.models.backendstatus",
+    "JobStatus": "qiskit.providers.models.jobstatus",
+    "PulseDefaults": "qiskit.providers.models.pulsedefaults",
+    "Command": "qiskit.providers.models.pulsedefaults",
+}
+
+
+def __getattr__(name):
+    if (module_name := _NAME_MAP.get(name)) is not None:
+        warnings.warn(
+            "qiskit.providers.models is deprecated since Qiskit 1.2 and will be "
+            "removed in Qiskit 2.0. With the removal of Qobj, there is no need for these "
+            "schema-conformant objects. If you still need to use them, it could be because "
+            "you are using a BackendV1, which is also deprecated in favor of BackendV2.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return getattr(importlib.import_module(module_name), name)
+    raise AttributeError(f"module 'qiskit.providers.models' has no attribute '{name}'")
diff --git a/qiskit/transpiler/passes/synthesis/unitary_synthesis.py b/qiskit/transpiler/passes/synthesis/unitary_synthesis.py
index 1ce2f2800c09..4054a158d12a 100644
--- a/qiskit/transpiler/passes/synthesis/unitary_synthesis.py
+++ b/qiskit/transpiler/passes/synthesis/unitary_synthesis.py
@@ -54,7 +54,7 @@
 from qiskit.converters import circuit_to_dag, dag_to_circuit
 from qiskit.dagcircuit.dagcircuit import DAGCircuit, DAGOpNode
 from qiskit.exceptions import QiskitError
-from qiskit.providers.models import BackendProperties
+from qiskit.providers.models.backendproperties import BackendProperties
 from qiskit.quantum_info import Operator
 from qiskit.synthesis.one_qubit import one_qubit_decompose
 from qiskit.synthesis.two_qubit.xx_decompose import XXDecomposer, XXEmbodiments
diff --git a/test/benchmarks/pulse/load_pulse_defaults.py b/test/benchmarks/pulse/load_pulse_defaults.py
index 1b7fa5cc1719..770ac1563b2b 100644
--- a/test/benchmarks/pulse/load_pulse_defaults.py
+++ b/test/benchmarks/pulse/load_pulse_defaults.py
@@ -15,7 +15,7 @@
 
 import numpy as np
 
-from qiskit.providers.models import PulseDefaults
+from qiskit.providers.models.pulsedefaults import PulseDefaults
 from qiskit.compiler import schedule
 from qiskit.circuit import QuantumCircuit, Gate
 
diff --git a/test/python/providers/faulty_backends.py b/test/python/providers/faulty_backends.py
index f57cf1b594c3..ec8ba8fed594 100644
--- a/test/python/providers/faulty_backends.py
+++ b/test/python/providers/faulty_backends.py
@@ -12,7 +12,7 @@
 
 """Faulty fake backends for testing"""
 
-from qiskit.providers.models import BackendProperties
+from qiskit.providers.models.backendproperties import BackendProperties
 from qiskit.providers.fake_provider import Fake7QPulseV1
 
 
diff --git a/test/python/providers/test_backendstatus.py b/test/python/providers/test_backendstatus.py
index 2cfa31791de3..c0cfb7f792a3 100644
--- a/test/python/providers/test_backendstatus.py
+++ b/test/python/providers/test_backendstatus.py
@@ -14,7 +14,7 @@
 """
 
 from qiskit.providers.fake_provider import Fake5QV1
-from qiskit.providers.models import BackendStatus
+from qiskit.providers.models.backendstatus import BackendStatus
 from test import QiskitTestCase  # pylint: disable=wrong-import-order
 
 
diff --git a/test/python/providers/test_fake_backends.py b/test/python/providers/test_fake_backends.py
index 6d8716359bcc..3df3e7d5893f 100644
--- a/test/python/providers/test_fake_backends.py
+++ b/test/python/providers/test_fake_backends.py
@@ -37,8 +37,8 @@
 )
 from qiskit.providers.backend_compat import BackendV2Converter, convert_to_target
 from qiskit.providers.models.backendproperties import BackendProperties
+from qiskit.providers.models.backendconfiguration import GateConfig
 from qiskit.providers.backend import BackendV2
-from qiskit.providers.models import GateConfig
 from qiskit.utils import optionals
 from qiskit.circuit.library import (
     SXGate,
diff --git a/test/python/transpiler/test_pulse_gate_pass.py b/test/python/transpiler/test_pulse_gate_pass.py
index 07d6172264d4..1dd42d662860 100644
--- a/test/python/transpiler/test_pulse_gate_pass.py
+++ b/test/python/transpiler/test_pulse_gate_pass.py
@@ -16,7 +16,7 @@
 
 from qiskit import pulse, circuit, transpile
 from qiskit.providers.fake_provider import Fake27QPulseV1, GenericBackendV2
-from qiskit.providers.models import GateConfig
+from qiskit.providers.models.backendconfiguration import GateConfig
 from qiskit.quantum_info.random import random_unitary
 from test import QiskitTestCase  # pylint: disable=wrong-import-order
 
diff --git a/test/utils/base.py b/test/utils/base.py
index 78d5aceb58f2..e1b2180aac4e 100644
--- a/test/utils/base.py
+++ b/test/utils/base.py
@@ -134,7 +134,7 @@ def setUpClass(cls):
         warnings.filterwarnings(
             "ignore",  # If "default", it floods the CI output
             category=DeprecationWarning,
-            message=r"The class ``qiskit\.providers\.models\..*`",
+            message=r".*qiskit\.providers\.models.*",
             module=r"qiskit_aer(\.[a-zA-Z0-9_]+)*",
         )
 

From 76eb568c14f79ab9dad17d61c49380a5c7ef5e85 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 16 Aug 2024 15:46:41 +0000
Subject: [PATCH 03/85] Bump bytemuck from 1.16.3 to 1.17.0 (#12967)

Bumps [bytemuck](https://github.com/Lokathor/bytemuck) from 1.16.3 to 1.17.0.
- [Changelog](https://github.com/Lokathor/bytemuck/blob/main/changelog.md)
- [Commits](https://github.com/Lokathor/bytemuck/compare/v1.16.3...v1.17.0)

---
updated-dependencies:
- dependency-name: bytemuck
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 0a590fc1fd9f..8ee13b9ff509 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -102,9 +102,9 @@ dependencies = [
 
 [[package]]
 name = "bytemuck"
-version = "1.16.3"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "102087e286b4677862ea56cf8fc58bb2cdfa8725c40ffb80fe3a008eb7f2fc83"
+checksum = "6fd4c6dcc3b0aea2f5c0b4b82c2b15fe39ddbc76041a310848f4706edf76bb31"
 dependencies = [
  "bytemuck_derive",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 13ea3ead5584..f6141f787fdf 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,7 +14,7 @@ license = "Apache-2.0"
 #
 # Each crate can add on specific features freely as it inherits.
 [workspace.dependencies]
-bytemuck = "1.16"
+bytemuck = "1.17"
 indexmap.version = "2.4.0"
 hashbrown.version = "0.14.0"
 num-bigint = "0.4"

From 06392c523fdc514d2592ffc489e7a3515049eba3 Mon Sep 17 00:00:00 2001
From: Alexander Ivrii <alexi@il.ibm.com>
Date: Mon, 19 Aug 2024 16:38:57 +0300
Subject: [PATCH 04/85] adding copy argument to __array__ (#12979)

---
 qiskit/circuit/library/basis_change/qft.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/qiskit/circuit/library/basis_change/qft.py b/qiskit/circuit/library/basis_change/qft.py
index 2ec6dd69cb79..15668ec51e11 100644
--- a/qiskit/circuit/library/basis_change/qft.py
+++ b/qiskit/circuit/library/basis_change/qft.py
@@ -315,8 +315,10 @@ def __init__(
         """
         super().__init__(name="qft", num_qubits=num_qubits, params=[])
 
-    def __array__(self, dtype=complex):
+    def __array__(self, dtype=complex, copy=None):
         """Return a numpy array for the QFTGate."""
+        if copy is False:
+            raise ValueError("unable to avoid copy while creating an array as requested")
         n = self.num_qubits
         nums = np.arange(2**n)
         outer = np.outer(nums, nums)

From 3981a84e74a206e0f85323a8bc97d1853c8da46b Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 19 Aug 2024 16:10:40 +0000
Subject: [PATCH 05/85] Bump pulp from 0.18.21 to 0.18.22 (#12981)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [pulp](https://github.com/sarah-ek/pulp) from 0.18.21 to 0.18.22.
- [Commits](https://github.com/sarah-ek/pulp/commits)

---
updated-dependencies:
- dependency-name: pulp
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>
---
 Cargo.lock                   | 4 ++--
 crates/accelerate/Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 8ee13b9ff509..63e36f18645c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1052,9 +1052,9 @@ dependencies = [
 
 [[package]]
 name = "pulp"
-version = "0.18.21"
+version = "0.18.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ec8d02258294f59e4e223b41ad7e81c874aa6b15bc4ced9ba3965826da0eed5"
+checksum = "a0a01a0dc67cf4558d279f0c25b0962bd08fc6dec0137699eae304103e882fe6"
 dependencies = [
  "bytemuck",
  "libm",
diff --git a/crates/accelerate/Cargo.toml b/crates/accelerate/Cargo.toml
index 854c1ed05706..c93e81b14dee 100644
--- a/crates/accelerate/Cargo.toml
+++ b/crates/accelerate/Cargo.toml
@@ -54,5 +54,5 @@ version = "0.2.0"
 features = ["ndarray"]
 
 [dependencies.pulp]
-version = "0.18.21"
+version = "0.18.22"
 features = ["macro"]

From 66fb6fee64ca9113417bd51f904a66509be7a9d8 Mon Sep 17 00:00:00 2001
From: ebaeumer <48065247+ebaeumer@users.noreply.github.com>
Date: Mon, 19 Aug 2024 18:41:25 +0200
Subject: [PATCH 06/85] Example code for Store instruction (#12982)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Example code for Store function

* update shortened line

* Update qiskit/circuit/__init__.py

---------

Co-authored-by: Luciano Bello <bel@zurich.ibm.com>
Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>
---
 qiskit/circuit/__init__.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/qiskit/circuit/__init__.py b/qiskit/circuit/__init__.py
index 65a88519a0de..1ab084ef2072 100644
--- a/qiskit/circuit/__init__.py
+++ b/qiskit/circuit/__init__.py
@@ -579,6 +579,16 @@
 :class:`Qubit` nor :class:`Clbit` operands, but has an explicit :attr:`~Store.lvalue` and
 :attr:`~Store.rvalue`.
 
+For example, to determine the parity of a bitstring ``cr`` and store it in another register ``creg``,
+the :class:`Store` instruction can be used in the following way::
+
+    parity = expr.lift(cr[0])
+    for i in range(1,n):
+        parity = expr.bit_xor(cr[i], parity)
+    qc.store(creg[0], parity)
+
+
+
 .. autoclass:: Store
     :show-inheritance:
     :members:

From 393fb595178567d11a534a0d9da699b0fa15d565 Mon Sep 17 00:00:00 2001
From: jschuhmac <74537145+jschuhmac@users.noreply.github.com>
Date: Mon, 19 Aug 2024 19:08:02 +0200
Subject: [PATCH 07/85] Add code example in Operator docstring. (#12985)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>
---
 qiskit/quantum_info/operators/operator.py | 24 +++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/qiskit/quantum_info/operators/operator.py b/qiskit/quantum_info/operators/operator.py
index a4e93f364809..42593626f2cc 100644
--- a/qiskit/quantum_info/operators/operator.py
+++ b/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__(

From 59630272672e4593e2bd5570680e47961d398923 Mon Sep 17 00:00:00 2001
From: Julien Gacon <jules.gacon@gmail.com>
Date: Mon, 19 Aug 2024 19:39:35 +0200
Subject: [PATCH 08/85] fix stateprep's normalize (#12988)

---
 .../library/data_preparation/state_preparation.py      |  2 +-
 .../fix-stateprep-normalize-a8057c339ba619bd.yaml      |  6 ++++++
 test/python/circuit/library/test_state_preparation.py  | 10 ++++++++++
 3 files changed, 17 insertions(+), 1 deletion(-)
 create mode 100644 releasenotes/notes/fix-stateprep-normalize-a8057c339ba619bd.yaml

diff --git a/qiskit/circuit/library/data_preparation/state_preparation.py b/qiskit/circuit/library/data_preparation/state_preparation.py
index 26c37334cfe4..df69f9eab8c5 100644
--- a/qiskit/circuit/library/data_preparation/state_preparation.py
+++ b/qiskit/circuit/library/data_preparation/state_preparation.py
@@ -173,7 +173,7 @@ def _define_synthesis_isom(self):
         q = QuantumRegister(self.num_qubits, "q")
         initialize_circuit = QuantumCircuit(q, name="init_def")
 
-        isom = Isometry(self._params_arg, 0, 0)
+        isom = Isometry(self.params, 0, 0)
         initialize_circuit.append(isom, q[:])
 
         # invert the circuit to create the desired vector from zero (assuming
diff --git a/releasenotes/notes/fix-stateprep-normalize-a8057c339ba619bd.yaml b/releasenotes/notes/fix-stateprep-normalize-a8057c339ba619bd.yaml
new file mode 100644
index 000000000000..0175f8c1c026
--- /dev/null
+++ b/releasenotes/notes/fix-stateprep-normalize-a8057c339ba619bd.yaml
@@ -0,0 +1,6 @@
+---
+fixes:
+  - |
+    Fixed a bug in :class:`.StatePreparation` where the ``normalize`` 
+    argument was ignored for input arrays.
+    Fixed `#12984 <https://github.com/Qiskit/qiskit/issues/12984>`__.
diff --git a/test/python/circuit/library/test_state_preparation.py b/test/python/circuit/library/test_state_preparation.py
index adad848a2777..b5446ed37e9c 100644
--- a/test/python/circuit/library/test_state_preparation.py
+++ b/test/python/circuit/library/test_state_preparation.py
@@ -113,6 +113,16 @@ def test_repeats(self):
         qc.append(StatePreparation("01").repeat(2), [0, 1])
         self.assertEqual(qc.decompose().count_ops()["state_preparation"], 2)
 
+    def test_normalize(self):
+        """Test the normalization.
+
+        Regression test of #12984.
+        """
+        qc = QuantumCircuit(1)
+        qc.compose(StatePreparation([1, 1], normalize=True), range(1), inplace=True)
+
+        self.assertTrue(Statevector(qc).equiv(np.array([1, 1]) / np.sqrt(2)))
+
 
 if __name__ == "__main__":
     unittest.main()

From 5c8edd404060eb5186fe55f3874e35617253d55e Mon Sep 17 00:00:00 2001
From: jschuhmac <74537145+jschuhmac@users.noreply.github.com>
Date: Tue, 20 Aug 2024 10:56:12 +0200
Subject: [PATCH 09/85] Parsing of `seed_transpiler` in
 `generate_preset_pass_manager` (#12980)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Raise ValueError if seed_transpiler is negative

* Fix code formatting

* Implement suggested changes

* Update releasenotes/notes/fix-negative-seed-pm-2813a62a020da115.yaml

Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>

* Update qiskit/transpiler/preset_passmanagers/generate_preset_pass_manager.py

Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>

---------

Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>
---
 .../generate_preset_pass_manager.py                  |  9 +++++++++
 .../notes/fix-negative-seed-pm-2813a62a020da115.yaml |  4 ++++
 test/python/transpiler/test_preset_passmanagers.py   | 12 ++++++++++++
 3 files changed, 25 insertions(+)
 create mode 100644 releasenotes/notes/fix-negative-seed-pm-2813a62a020da115.yaml

diff --git a/qiskit/transpiler/preset_passmanagers/generate_preset_pass_manager.py b/qiskit/transpiler/preset_passmanagers/generate_preset_pass_manager.py
index 353ad8c50b15..830618845352 100644
--- a/qiskit/transpiler/preset_passmanagers/generate_preset_pass_manager.py
+++ b/qiskit/transpiler/preset_passmanagers/generate_preset_pass_manager.py
@@ -358,6 +358,7 @@ def generate_preset_pass_manager(
     # Parse non-target dependent pm options
     initial_layout = _parse_initial_layout(initial_layout)
     approximation_degree = _parse_approximation_degree(approximation_degree)
+    seed_transpiler = _parse_seed_transpiler(seed_transpiler)
 
     pm_options = {
         "target": target,
@@ -532,3 +533,11 @@ def _parse_approximation_degree(approximation_degree):
     if approximation_degree < 0.0 or approximation_degree > 1.0:
         raise TranspilerError("Approximation degree must be in [0.0, 1.0]")
     return approximation_degree
+
+
+def _parse_seed_transpiler(seed_transpiler):
+    if seed_transpiler is None:
+        return None
+    if not isinstance(seed_transpiler, int) or seed_transpiler < 0:
+        raise ValueError("Expected non-negative integer as seed for transpiler.")
+    return seed_transpiler
diff --git a/releasenotes/notes/fix-negative-seed-pm-2813a62a020da115.yaml b/releasenotes/notes/fix-negative-seed-pm-2813a62a020da115.yaml
new file mode 100644
index 000000000000..352f068537e8
--- /dev/null
+++ b/releasenotes/notes/fix-negative-seed-pm-2813a62a020da115.yaml
@@ -0,0 +1,4 @@
+---
+fixes:
+  - |
+    Fixed the behavior of :meth:`.generate_preset_pass_manager` to raise a `ValueError` exception if not provided with a non-negative integer `seed_transpiler` argument.
diff --git a/test/python/transpiler/test_preset_passmanagers.py b/test/python/transpiler/test_preset_passmanagers.py
index aa689b4c4fee..dd760b2264ce 100644
--- a/test/python/transpiler/test_preset_passmanagers.py
+++ b/test/python/transpiler/test_preset_passmanagers.py
@@ -1529,6 +1529,18 @@ def test_generate_preset_pass_manager_with_list_initial_layout(self, optimizatio
         self.assertIsInstance(pm_object, PassManager)
         self.assertEqual(tqc_list, tqc_obj)
 
+    def test_parse_seed_transpiler_raises_value_error(self):
+        """Test that seed for transpiler is non-negative integer."""
+        with self.assertRaisesRegex(
+            ValueError, "Expected non-negative integer as seed for transpiler."
+        ):
+            generate_preset_pass_manager(optimization_level=1, seed_transpiler=-1)
+
+        with self.assertRaisesRegex(
+            ValueError, "Expected non-negative integer as seed for transpiler."
+        ):
+            generate_preset_pass_manager(seed_transpiler=0.1)
+
 
 @ddt
 class TestIntegrationControlFlow(QiskitTestCase):

From a11e76ca7d775824b0790cc1804846e089ed973b Mon Sep 17 00:00:00 2001
From: Joseph Loftin <65878716+jlofti@users.noreply.github.com>
Date: Tue, 20 Aug 2024 13:54:23 +0200
Subject: [PATCH 10/85] Port `synth_cz_depth_line_mr` to Rust (#12949)

* First pass, pre cleanup

Signed-off-by: jlofti <65878716+jlofti@users.noreply.github.com>

* optimizations and cleanup

Signed-off-by: jlofti <65878716+jlofti@users.noreply.github.com>

* more cleanup

Signed-off-by: jlofti <65878716+jlofti@users.noreply.github.com>

* broke out function

Signed-off-by: jlofti <65878716+jlofti@users.noreply.github.com>

* reformat

Signed-off-by: jlofti <65878716+jlofti@users.noreply.github.com>

* comments for append_cx

Signed-off-by: jlofti <65878716+jlofti@users.noreply.github.com>

* correct usize usage

Signed-off-by: jlofti <65878716+jlofti@users.noreply.github.com>

* added _inner to function name

Signed-off-by: jlofti <65878716+jlofti@users.noreply.github.com>

* changed directory structure

Signed-off-by: jlofti <65878716+jlofti@users.noreply.github.com>

* port _append_reverse_permutation_lnn_kms

Signed-off-by: jlofti <65878716+jlofti@users.noreply.github.com>

* concise function, added sdg comment, all to usize

Signed-off-by: jlofti <65878716+jlofti@users.noreply.github.com>

* port synth_permutation_reverse_lnn_kms to rust

Signed-off-by: jlofti <65878716+jlofti@users.noreply.github.com>

* cleanup

Signed-off-by: jlofti <65878716+jlofti@users.noreply.github.com>

* readded

Signed-off-by: jlofti <65878716+jlofti@users.noreply.github.com>

* release notes and simplified comment

Signed-off-by: jlofti <65878716+jlofti@users.noreply.github.com>

* Update releasenotes/notes/port-synth-cz-depth-line-mr-to-rust-1376d5a41948112a.yaml

Co-authored-by: Alexander Ivrii <alexi@il.ibm.com>

* promoted to docstring and added new docstrings

Signed-off-by: jlofti <65878716+jlofti@users.noreply.github.com>

* Update crates/accelerate/src/synthesis/linear_phase/cz_depth_lnn.rs

Co-authored-by: Julien Gacon <gaconju@gmail.com>

---------

Signed-off-by: jlofti <65878716+jlofti@users.noreply.github.com>
Co-authored-by: Alexander Ivrii <alexi@il.ibm.com>
Co-authored-by: Julien Gacon <gaconju@gmail.com>
---
 .../synthesis/linear_phase/cz_depth_lnn.rs    | 171 ++++++++++++++++++
 .../src/synthesis/linear_phase/mod.rs         |  46 +++++
 crates/accelerate/src/synthesis/mod.rs        |   5 +
 .../src/synthesis/permutation/mod.rs          |  73 ++++++++
 qiskit/__init__.py                            |   1 +
 qiskit/synthesis/linear_phase/cz_depth_lnn.py | 148 +--------------
 .../permutation/permutation_reverse_lnn.py    |   9 +-
 ...epth-line-mr-to-rust-1376d5a41948112a.yaml |   6 +
 8 files changed, 312 insertions(+), 147 deletions(-)
 create mode 100644 crates/accelerate/src/synthesis/linear_phase/cz_depth_lnn.rs
 create mode 100644 crates/accelerate/src/synthesis/linear_phase/mod.rs
 create mode 100644 releasenotes/notes/port-synth-cz-depth-line-mr-to-rust-1376d5a41948112a.yaml

diff --git a/crates/accelerate/src/synthesis/linear_phase/cz_depth_lnn.rs b/crates/accelerate/src/synthesis/linear_phase/cz_depth_lnn.rs
new file mode 100644
index 000000000000..df01c1ed6fa8
--- /dev/null
+++ b/crates/accelerate/src/synthesis/linear_phase/cz_depth_lnn.rs
@@ -0,0 +1,171 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// 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.
+
+use std::iter::once;
+
+use hashbrown::HashMap;
+use itertools::Itertools;
+use ndarray::{Array1, ArrayView2};
+
+use qiskit_circuit::{
+    operations::{Param, StandardGate},
+    Qubit,
+};
+use smallvec::{smallvec, SmallVec};
+
+use crate::synthesis::permutation::{_append_cx_stage1, _append_cx_stage2};
+
+// A sequence of Lnn gates
+// Represents the return type for Lnn Synthesis algorithms
+pub(crate) type LnnGatesVec = Vec<(StandardGate, SmallVec<[Param; 3]>, SmallVec<[Qubit; 2]>)>;
+
+/// A pattern denoted by Pj in [1] for odd number of qubits:
+/// [n-2, n-4, n-4, ..., 3, 3, 1, 1, 0, 0, 2, 2, ..., n-3, n-3]
+fn _odd_pattern1(n: usize) -> Vec<usize> {
+    once(n - 2)
+        .chain((0..((n - 3) / 2)).flat_map(|i| [(n - 2 * i - 4); 2]))
+        .chain((0..((n - 1) / 2)).flat_map(|i| [2 * i; 2]))
+        .collect()
+}
+
+/// A pattern denoted by Pk in [1] for odd number of qubits:
+/// [2, 2, 4, 4, ..., n-1, n-1, n-2, n-2, n-4, n-4, ..., 5, 5, 3, 3, 1]
+fn _odd_pattern2(n: usize) -> Vec<usize> {
+    (0..((n - 1) / 2))
+        .flat_map(|i| [(2 * i + 2); 2])
+        .chain((0..((n - 3) / 2)).flat_map(|i| [n - 2 * i - 2; 2]))
+        .chain(once(1))
+        .collect()
+}
+
+/// A pattern denoted by Pj in [1] for even number of qubits:
+/// [n-1, n-3, n-3, n-5, n-5, ..., 1, 1, 0, 0, 2, 2, ..., n-4, n-4, n-2]
+fn _even_pattern1(n: usize) -> Vec<usize> {
+    once(n - 1)
+        .chain((0..((n - 2) / 2)).flat_map(|i| [n - 2 * i - 3; 2]))
+        .chain((0..((n - 2) / 2)).flat_map(|i| [2 * i; 2]))
+        .chain(once(n - 2))
+        .collect()
+}
+
+/// A pattern denoted by Pk in [1] for even number of qubits:
+/// [2, 2, 4, 4, ..., n-2, n-2, n-1, n-1, ..., 3, 3, 1, 1]
+fn _even_pattern2(n: usize) -> Vec<usize> {
+    (0..((n - 2) / 2))
+        .flat_map(|i| [2 * (i + 1); 2])
+        .chain((0..(n / 2)).flat_map(|i| [(n - 2 * i - 1); 2]))
+        .collect()
+}
+
+/// Creating the patterns for the phase layers.
+fn _create_patterns(n: usize) -> HashMap<(usize, usize), (usize, usize)> {
+    let (pat1, pat2) = if n % 2 == 0 {
+        (_even_pattern1(n), _even_pattern2(n))
+    } else {
+        (_odd_pattern1(n), _odd_pattern2(n))
+    };
+
+    let ind = if n % 2 == 0 {
+        (2 * n - 4) / 2
+    } else {
+        (2 * n - 4) / 2 - 1
+    };
+
+    HashMap::from_iter((0..n).map(|i| ((0, i), (i, i))).chain(
+        (0..(n / 2)).cartesian_product(0..n).map(|(layer, i)| {
+            (
+                (layer + 1, i),
+                (pat1[ind - (2 * layer) + i], pat2[(2 * layer) + i]),
+            )
+        }),
+    ))
+}
+
+/// Appends correct phase gate during CZ synthesis
+fn _append_phase_gate(pat_val: usize, gates: &mut LnnGatesVec, qubit: usize) {
+    // Add phase gates: s, sdg or z
+    let gate_id = pat_val % 4;
+    if gate_id != 0 {
+        let gate = match gate_id {
+            1 => StandardGate::SdgGate,
+            2 => StandardGate::ZGate,
+            3 => StandardGate::SGate,
+            _ => unreachable!(), // unreachable as we have modulo 4
+        };
+        gates.push((gate, smallvec![], smallvec![Qubit(qubit as u32)]));
+    }
+}
+
+/// Synthesis of a CZ circuit for linear nearest neighbor (LNN) connectivity,
+/// based on Maslov and Roetteler.
+pub(super) fn synth_cz_depth_line_mr_inner(matrix: ArrayView2<bool>) -> (usize, LnnGatesVec) {
+    let num_qubits = matrix.raw_dim()[0];
+    let pats = _create_patterns(num_qubits);
+
+    // s_gates[i] = 0, 1, 2 or 3 for a gate id, sdg, z or s on qubit i respectively
+    let mut s_gates = Array1::<usize>::zeros(num_qubits);
+
+    let mut patlist: Vec<(usize, usize)> = Vec::new();
+
+    let mut gates = LnnGatesVec::new();
+
+    for i in 0..num_qubits {
+        for j in (i + 1)..num_qubits {
+            if matrix[[i, j]] {
+                // CZ(i,j) gate
+                s_gates[[i]] += 2; // qc.z[i]
+                s_gates[[j]] += 2; // qc.z[j]
+                patlist.push((i, j - 1));
+                patlist.push((i, j));
+                patlist.push((i + 1, j - 1));
+                patlist.push((i + 1, j));
+            }
+        }
+    }
+
+    for i in 0..((num_qubits + 1) / 2) {
+        for j in 0..num_qubits {
+            let pat_val = pats[&(i, j)];
+            if patlist.contains(&pat_val) {
+                // patcnt should be 0 or 1, which checks if a Sdg gate should be added
+                let patcnt = patlist.iter().filter(|val| **val == pat_val).count();
+                s_gates[[j]] += patcnt; // qc.sdg[j]
+            }
+
+            _append_phase_gate(s_gates[[j]], &mut gates, j)
+        }
+
+        _append_cx_stage1(&mut gates, num_qubits);
+        _append_cx_stage2(&mut gates, num_qubits);
+        s_gates = Array1::<usize>::zeros(num_qubits);
+    }
+
+    if num_qubits % 2 == 0 {
+        let i = num_qubits / 2;
+
+        for j in 0..num_qubits {
+            let pat_val = pats[&(i, j)];
+            if patlist.contains(&pat_val) && pat_val.0 != pat_val.1 {
+                // patcnt should be 0 or 1, which checks if a Sdg gate should be added
+                let patcnt = patlist.iter().filter(|val| **val == pat_val).count();
+
+                s_gates[[j]] += patcnt; // qc.sdg[j]
+            }
+
+            _append_phase_gate(s_gates[[j]], &mut gates, j)
+        }
+
+        _append_cx_stage1(&mut gates, num_qubits);
+    }
+
+    (num_qubits, gates)
+}
diff --git a/crates/accelerate/src/synthesis/linear_phase/mod.rs b/crates/accelerate/src/synthesis/linear_phase/mod.rs
new file mode 100644
index 000000000000..fd95985e1025
--- /dev/null
+++ b/crates/accelerate/src/synthesis/linear_phase/mod.rs
@@ -0,0 +1,46 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// 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.
+
+use numpy::PyReadonlyArray2;
+use pyo3::{
+    prelude::*,
+    pyfunction,
+    types::{PyModule, PyModuleMethods},
+    wrap_pyfunction, Bound, PyResult,
+};
+use qiskit_circuit::{circuit_data::CircuitData, operations::Param};
+
+pub(crate) mod cz_depth_lnn;
+
+/// Synthesis of a CZ circuit for linear nearest neighbor (LNN) connectivity,
+/// based on Maslov and Roetteler.
+///
+///  Note that this method *reverts* the order of qubits in the circuit,
+///  and returns a circuit containing :class:`.CXGate`\s and phase gates
+/// (:class:`.SGate`, :class:`.SdgGate` or :class:`.ZGate`).
+///
+/// References:
+///     1. Dmitri Maslov, Martin Roetteler,
+///        *Shorter stabilizer circuits via Bruhat decomposition and quantum circuit transformations*,
+///        `arXiv:1705.09176 <https://arxiv.org/abs/1705.09176>`_.
+#[pyfunction]
+#[pyo3(signature = (mat))]
+fn synth_cz_depth_line_mr(py: Python, mat: PyReadonlyArray2<bool>) -> PyResult<CircuitData> {
+    let view = mat.as_array();
+    let (num_qubits, lnn_gates) = cz_depth_lnn::synth_cz_depth_line_mr_inner(view);
+    CircuitData::from_standard_gates(py, num_qubits as u32, lnn_gates, Param::Float(0.0))
+}
+
+pub fn linear_phase(m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_wrapped(wrap_pyfunction!(synth_cz_depth_line_mr))?;
+    Ok(())
+}
diff --git a/crates/accelerate/src/synthesis/mod.rs b/crates/accelerate/src/synthesis/mod.rs
index fae05c6739cc..6e22281e2250 100644
--- a/crates/accelerate/src/synthesis/mod.rs
+++ b/crates/accelerate/src/synthesis/mod.rs
@@ -12,6 +12,7 @@
 
 mod clifford;
 pub mod linear;
+pub mod linear_phase;
 mod permutation;
 
 use pyo3::prelude::*;
@@ -21,6 +22,10 @@ pub fn synthesis(m: &Bound<PyModule>) -> PyResult<()> {
     linear::linear(&linear_mod)?;
     m.add_submodule(&linear_mod)?;
 
+    let linear_phase_mod = PyModule::new_bound(m.py(), "linear_phase")?;
+    linear_phase::linear_phase(&linear_phase_mod)?;
+    m.add_submodule(&linear_phase_mod)?;
+
     let permutation_mod = PyModule::new_bound(m.py(), "permutation")?;
     permutation::permutation(&permutation_mod)?;
     m.add_submodule(&permutation_mod)?;
diff --git a/crates/accelerate/src/synthesis/permutation/mod.rs b/crates/accelerate/src/synthesis/permutation/mod.rs
index 55dc3efe4a87..2f84776cb5fd 100644
--- a/crates/accelerate/src/synthesis/permutation/mod.rs
+++ b/crates/accelerate/src/synthesis/permutation/mod.rs
@@ -20,6 +20,8 @@ use qiskit_circuit::circuit_data::CircuitData;
 use qiskit_circuit::operations::{Param, StandardGate};
 use qiskit_circuit::Qubit;
 
+use super::linear_phase::cz_depth_lnn::LnnGatesVec;
+
 mod utils;
 
 /// Checks whether an array of size N is a permutation of 0, 1, ..., N - 1.
@@ -114,11 +116,82 @@ pub fn _synth_permutation_depth_lnn_kms(
     )
 }
 
+/// A single layer of CX gates.
+pub(crate) fn _append_cx_stage1(gates: &mut LnnGatesVec, n: usize) {
+    for i in 0..(n / 2) {
+        gates.push((
+            StandardGate::CXGate,
+            smallvec![],
+            smallvec![Qubit((2 * i) as u32), Qubit((2 * i + 1) as u32)],
+        ))
+    }
+
+    for i in 0..((n + 1) / 2 - 1) {
+        gates.push((
+            StandardGate::CXGate,
+            smallvec![],
+            smallvec![Qubit((2 * i + 2) as u32), Qubit((2 * i + 1) as u32)],
+        ))
+    }
+}
+
+/// A single layer of CX gates.
+pub(crate) fn _append_cx_stage2(gates: &mut LnnGatesVec, n: usize) {
+    for i in 0..(n / 2) {
+        gates.push((
+            StandardGate::CXGate,
+            smallvec![],
+            smallvec![Qubit((2 * i + 1) as u32), Qubit((2 * i) as u32)],
+        ))
+    }
+
+    for i in 0..((n + 1) / 2 - 1) {
+        gates.push((
+            StandardGate::CXGate,
+            smallvec![],
+            smallvec![Qubit((2 * i + 1) as u32), Qubit((2 * i + 2) as u32)],
+        ))
+    }
+}
+
+/// Append reverse permutation to a QuantumCircuit for linear nearest-neighbor architectures
+/// using Kutin, Moulton, Smithline method.
+fn _append_reverse_permutation_lnn_kms(gates: &mut LnnGatesVec, num_qubits: usize) {
+    (0..(num_qubits + 1) / 2).for_each(|_| {
+        _append_cx_stage1(gates, num_qubits);
+        _append_cx_stage2(gates, num_qubits);
+    });
+
+    if num_qubits % 2 == 0 {
+        _append_cx_stage1(gates, num_qubits);
+    }
+}
+
+/// Synthesize reverse permutation for linear nearest-neighbor architectures using
+/// Kutin, Moulton, Smithline method.
+///
+/// Synthesis algorithm for reverse permutation from [1], section 5.
+/// This algorithm synthesizes the reverse permutation on :math:`n` qubits over
+/// a linear nearest-neighbor architecture using CX gates with depth :math:`2 * n + 2`.
+///
+/// References:
+///     1. Kutin, S., Moulton, D. P., Smithline, L.,
+///        *Computation at a distance*, Chicago J. Theor. Comput. Sci., vol. 2007, (2007),
+///        `arXiv:quant-ph/0701194 <https://arxiv.org/abs/quant-ph/0701194>`_
+#[pyfunction]
+#[pyo3(signature = (num_qubits))]
+fn synth_permutation_reverse_lnn_kms(py: Python, num_qubits: usize) -> PyResult<CircuitData> {
+    let mut gates = LnnGatesVec::new();
+    _append_reverse_permutation_lnn_kms(&mut gates, num_qubits);
+    CircuitData::from_standard_gates(py, num_qubits as u32, gates, Param::Float(0.0))
+}
+
 pub fn permutation(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(_validate_permutation, m)?)?;
     m.add_function(wrap_pyfunction!(_inverse_pattern, m)?)?;
     m.add_function(wrap_pyfunction!(_synth_permutation_basic, m)?)?;
     m.add_function(wrap_pyfunction!(_synth_permutation_acg, m)?)?;
     m.add_function(wrap_pyfunction!(_synth_permutation_depth_lnn_kms, m)?)?;
+    m.add_function(wrap_pyfunction!(synth_permutation_reverse_lnn_kms, m)?)?;
     Ok(())
 }
diff --git a/qiskit/__init__.py b/qiskit/__init__.py
index 6091bfa90346..6a8df393307e 100644
--- a/qiskit/__init__.py
+++ b/qiskit/__init__.py
@@ -85,6 +85,7 @@
 sys.modules["qiskit._accelerate.synthesis.permutation"] = _accelerate.synthesis.permutation
 sys.modules["qiskit._accelerate.synthesis.linear"] = _accelerate.synthesis.linear
 sys.modules["qiskit._accelerate.synthesis.clifford"] = _accelerate.synthesis.clifford
+sys.modules["qiskit._accelerate.synthesis.linear_phase"] = _accelerate.synthesis.linear_phase
 
 from qiskit.exceptions import QiskitError, MissingOptionalLibraryError
 
diff --git a/qiskit/synthesis/linear_phase/cz_depth_lnn.py b/qiskit/synthesis/linear_phase/cz_depth_lnn.py
index 7a195f0caf96..419aec806f2e 100644
--- a/qiskit/synthesis/linear_phase/cz_depth_lnn.py
+++ b/qiskit/synthesis/linear_phase/cz_depth_lnn.py
@@ -24,98 +24,10 @@
 
 import numpy as np
 from qiskit.circuit import QuantumCircuit
-from qiskit.synthesis.permutation.permutation_reverse_lnn import (
-    _append_cx_stage1,
-    _append_cx_stage2,
-)
-
-
-def _odd_pattern1(n):
-    """A pattern denoted by Pj in [1] for odd number of qubits:
-    [n-2, n-4, n-4, ..., 3, 3, 1, 1, 0, 0, 2, 2, ..., n-3, n-3]
-    """
-    pat = []
-    pat.append(n - 2)
-    for i in range((n - 3) // 2):
-        pat.append(n - 2 * i - 4)
-        pat.append(n - 2 * i - 4)
-    for i in range((n - 1) // 2):
-        pat.append(2 * i)
-        pat.append(2 * i)
-    return pat
-
-
-def _odd_pattern2(n):
-    """A pattern denoted by Pk in [1] for odd number of qubits:
-    [2, 2, 4, 4, ..., n-1, n-1, n-2, n-2, n-4, n-4, ..., 5, 5, 3, 3, 1]
-    """
-    pat = []
-    for i in range((n - 1) // 2):
-        pat.append(2 * i + 2)
-        pat.append(2 * i + 2)
-    for i in range((n - 3) // 2):
-        pat.append(n - 2 * i - 2)
-        pat.append(n - 2 * i - 2)
-    pat.append(1)
-    return pat
-
-
-def _even_pattern1(n):
-    """A pattern denoted by Pj in [1] for even number of qubits:
-    [n-1, n-3, n-3, n-5, n-5, ..., 1, 1, 0, 0, 2, 2, ..., n-4, n-4, n-2]
-    """
-    pat = []
-    pat.append(n - 1)
-    for i in range((n - 2) // 2):
-        pat.append(n - 2 * i - 3)
-        pat.append(n - 2 * i - 3)
-    for i in range((n - 2) // 2):
-        pat.append(2 * i)
-        pat.append(2 * i)
-    pat.append(n - 2)
-    return pat
 
-
-def _even_pattern2(n):
-    """A pattern denoted by Pk in [1] for even number of qubits:
-    [2, 2, 4, 4, ..., n-2, n-2, n-1, n-1, ..., 3, 3, 1, 1]
-    """
-    pat = []
-    for i in range((n - 2) // 2):
-        pat.append(2 * (i + 1))
-        pat.append(2 * (i + 1))
-    for i in range(n // 2):
-        pat.append(n - 2 * i - 1)
-        pat.append(n - 2 * i - 1)
-    return pat
-
-
-def _create_patterns(n):
-    """Creating the patterns for the phase layers."""
-    if (n % 2) == 0:
-        pat1 = _even_pattern1(n)
-        pat2 = _even_pattern2(n)
-    else:
-        pat1 = _odd_pattern1(n)
-        pat2 = _odd_pattern2(n)
-    pats = {}
-
-    layer = 0
-    for i in range(n):
-        pats[(0, i)] = (i, i)
-
-    if (n % 2) == 0:
-        ind1 = (2 * n - 4) // 2
-    else:
-        ind1 = (2 * n - 4) // 2 - 1
-    ind2 = 0
-    while layer < (n // 2):
-        for i in range(n):
-            pats[(layer + 1, i)] = (pat1[ind1 + i], pat2[ind2 + i])
-        layer += 1
-        ind1 -= 2
-        ind2 += 2
-    return pats
+from qiskit._accelerate.synthesis.linear_phase import (
+    synth_cz_depth_line_mr as synth_cz_depth_line_mr_inner,
+)
 
 
 def synth_cz_depth_line_mr(mat: np.ndarray) -> QuantumCircuit:
@@ -139,56 +51,6 @@ def synth_cz_depth_line_mr(mat: np.ndarray) -> QuantumCircuit:
            *Shorter stabilizer circuits via Bruhat decomposition and quantum circuit transformations*,
            `arXiv:1705.09176 <https://arxiv.org/abs/1705.09176>`_.
     """
-    num_qubits = mat.shape[0]
-    pats = _create_patterns(num_qubits)
-    patlist = []
-    # s_gates[i] = 0, 1, 2 or 3 for a gate id, sdg, z or s on qubit i respectively
-    s_gates = np.zeros(num_qubits)
-
-    qc = QuantumCircuit(num_qubits)
-    for i in range(num_qubits):
-        for j in range(i + 1, num_qubits):
-            if mat[i][j]:  # CZ(i,j) gate
-                s_gates[i] += 2  # qc.z[i]
-                s_gates[j] += 2  # qc.z[j]
-                patlist.append((i, j - 1))
-                patlist.append((i, j))
-                patlist.append((i + 1, j - 1))
-                patlist.append((i + 1, j))
-
-    for i in range((num_qubits + 1) // 2):
-        for j in range(num_qubits):
-            if pats[(i, j)] in patlist:
-                patcnt = patlist.count(pats[(i, j)])
-                for _ in range(patcnt):
-                    s_gates[j] += 1  # qc.sdg[j]
-        # Add phase gates: s, sdg or z
-        for j in range(num_qubits):
-            if s_gates[j] % 4 == 1:
-                qc.sdg(j)
-            elif s_gates[j] % 4 == 2:
-                qc.z(j)
-            elif s_gates[j] % 4 == 3:
-                qc.s(j)
-        qc = _append_cx_stage1(qc, num_qubits)
-        qc = _append_cx_stage2(qc, num_qubits)
-        s_gates = np.zeros(num_qubits)
-
-    if (num_qubits % 2) == 0:
-        i = num_qubits // 2
-        for j in range(num_qubits):
-            if pats[(i, j)] in patlist and pats[(i, j)][0] != pats[(i, j)][1]:
-                patcnt = patlist.count(pats[(i, j)])
-                for _ in range(patcnt):
-                    s_gates[j] += 1  # qc.sdg[j]
-        # Add phase gates: s, sdg or z
-        for j in range(num_qubits):
-            if s_gates[j] % 4 == 1:
-                qc.sdg(j)
-            elif s_gates[j] % 4 == 2:
-                qc.z(j)
-            elif s_gates[j] % 4 == 3:
-                qc.s(j)
-        qc = _append_cx_stage1(qc, num_qubits)
 
-    return qc
+    # Call Rust implementaton
+    return QuantumCircuit._from_circuit_data(synth_cz_depth_line_mr_inner(mat.astype(bool)))
diff --git a/qiskit/synthesis/permutation/permutation_reverse_lnn.py b/qiskit/synthesis/permutation/permutation_reverse_lnn.py
index 26287a06177e..f214fd7ce294 100644
--- a/qiskit/synthesis/permutation/permutation_reverse_lnn.py
+++ b/qiskit/synthesis/permutation/permutation_reverse_lnn.py
@@ -14,6 +14,9 @@
 """
 
 from qiskit.circuit import QuantumCircuit
+from qiskit._accelerate.synthesis.permutation import (
+    synth_permutation_reverse_lnn_kms as synth_permutation_reverse_lnn_kms_inner,
+)
 
 
 def _append_cx_stage1(qc, n):
@@ -84,7 +87,5 @@ def synth_permutation_reverse_lnn_kms(num_qubits: int) -> QuantumCircuit:
            `arXiv:quant-ph/0701194 <https://arxiv.org/abs/quant-ph/0701194>`_
     """
 
-    qc = QuantumCircuit(num_qubits)
-    _append_reverse_permutation_lnn_kms(qc, num_qubits)
-
-    return qc
+    # Call Rust implementation
+    return QuantumCircuit._from_circuit_data(synth_permutation_reverse_lnn_kms_inner(num_qubits))
diff --git a/releasenotes/notes/port-synth-cz-depth-line-mr-to-rust-1376d5a41948112a.yaml b/releasenotes/notes/port-synth-cz-depth-line-mr-to-rust-1376d5a41948112a.yaml
new file mode 100644
index 000000000000..ee4c6933a269
--- /dev/null
+++ b/releasenotes/notes/port-synth-cz-depth-line-mr-to-rust-1376d5a41948112a.yaml
@@ -0,0 +1,6 @@
+---
+features_synthesis:
+  - |
+    Port :func: `.synth_cz_depth_line_mr` to Rust. This function synthesizes a CZ circuit for linear nearest neighbor (LNN) connectivity, based on the Maslov and Roetteler method. On a 350x350 binary matrix, the Rust implementation yields a speedup of about 30 times.
+  - |
+    Port :func: `.synth_permutation_reverse_lnn_kms` to Rust, which synthesizes a reverse permutation for linear nearest-neighbor architecture using the Kutin, Moulton, Smithline method.

From d430e586f71d03e21fea7df6c5dbe4f73680ac1e Mon Sep 17 00:00:00 2001
From: QuantumDan <danielbultrini@gmail.com>
Date: Tue, 20 Aug 2024 14:28:54 +0200
Subject: [PATCH 11/85] Deprecates `StochasticSwap` and suggests the use of
 `SabreSwap` (#12983)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* first attempt to fix issue 12552

* first attempt to fix issue 12552

* fixed issue 12552 and unittest

* formatted and completed 12552

* formatted and completed 12552 documentation

* fixed unit tests 12552

* Update qiskit/transpiler/passes/routing/stochastic_swap.py

Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>

* linted

* passed all tests, including compiler test

* final linting and unittest passing - hopefully

* Update qiskit/transpiler/passes/routing/stochastic_swap.py

Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>

* Update releasenotes/notes/deprecate-StochasticSwap-451f46b273602b7b.yaml

Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>

* added test

* Apply suggestions from code review

---------

Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>
---
 .../passes/routing/stochastic_swap.py         |   8 +
 ...ecate-StochasticSwap-451f46b273602b7b.yaml |  46 +++
 test/python/compiler/test_transpiler.py       | 203 ++++++++++++-
 test/python/transpiler/test_mappers.py        |  14 +-
 .../transpiler/test_preset_passmanagers.py    |   5 +-
 test/python/transpiler/test_sabre_layout.py   |  26 +-
 test/python/transpiler/test_stage_plugin.py   |  27 +-
 .../python/transpiler/test_stochastic_swap.py | 287 ++++++++++--------
 8 files changed, 469 insertions(+), 147 deletions(-)
 create mode 100644 releasenotes/notes/deprecate-StochasticSwap-451f46b273602b7b.yaml

diff --git a/qiskit/transpiler/passes/routing/stochastic_swap.py b/qiskit/transpiler/passes/routing/stochastic_swap.py
index 3732802b770e..8cb628501017 100644
--- a/qiskit/transpiler/passes/routing/stochastic_swap.py
+++ b/qiskit/transpiler/passes/routing/stochastic_swap.py
@@ -38,6 +38,7 @@
 from qiskit._accelerate import stochastic_swap as stochastic_swap_rs
 from qiskit._accelerate import nlayout
 from qiskit.transpiler.passes.layout import disjoint_utils
+from qiskit.utils import deprecate_func
 
 from .utils import get_swap_map_dag
 
@@ -59,6 +60,12 @@ class StochasticSwap(TransformationPass):
            the circuit.
     """
 
+    @deprecate_func(
+        since="1.3",
+        removal_timeline="in the 2.0 release",
+        additional_msg="The `StochasticSwap` transpilation pass is a suboptimal "
+        "routing algorithm and has been superseded by the :class:`.SabreSwap` pass.",
+    )
     def __init__(self, coupling_map, trials=20, seed=None, fake_run=False, initial_layout=None):
         """StochasticSwap initializer.
 
@@ -76,6 +83,7 @@ def __init__(self, coupling_map, trials=20, seed=None, fake_run=False, initial_l
             initial_layout (Layout): starting layout at beginning of pass.
         """
         super().__init__()
+
         if isinstance(coupling_map, Target):
             self.target = coupling_map
             self.coupling_map = self.target.build_coupling_map()
diff --git a/releasenotes/notes/deprecate-StochasticSwap-451f46b273602b7b.yaml b/releasenotes/notes/deprecate-StochasticSwap-451f46b273602b7b.yaml
new file mode 100644
index 000000000000..24ade535f294
--- /dev/null
+++ b/releasenotes/notes/deprecate-StochasticSwap-451f46b273602b7b.yaml
@@ -0,0 +1,46 @@
+---
+deprecations_transpiler:
+  - |
+    Deprecated ``StochasticSwap`` which has been superseded by :class:`.SabreSwap`. 
+    If the class is called from the transpile function, the change would be, for example:: 
+
+      tqc = transpile(
+        circuit,
+        routing_method="stochastic",
+        layout_method="dense",
+        seed_transpiler=12342,
+        target=GenericBackendV2(
+            num_qubits=27,
+            coupling_map=MUMBAI_CMAP,
+        ).target,
+        ) 
+    
+    to::
+
+      tqc = transpile(
+        circuit,
+        routing_method="sabre",
+        layout_method="sabre",
+        seed_transpiler=12342,
+        target=GenericBackendV2(
+            num_qubits=27,
+            coupling_map=MUMBAI_CMAP,
+        ).target,
+        )   
+
+    While for a pass mananager change::
+
+      qr = QuantumRegister(4, "q")
+      qc = QuantumCircuit(qr)
+      passmanager = PassManager(StochasticSwap(coupling, 20, 13))
+      new_qc = passmanager.run(qc)
+
+    to::
+
+      qr = QuantumRegister(5, "q")
+      qc = QuantumCircuit(qr) 
+      passmanager = PassManager(SabreSwap(target, "basic"))
+      new_qc = passmanager.run(qc)
+      
+
+
diff --git a/test/python/compiler/test_transpiler.py b/test/python/compiler/test_transpiler.py
index a348ad8b749d..c3a930aed1f2 100644
--- a/test/python/compiler/test_transpiler.py
+++ b/test/python/compiler/test_transpiler.py
@@ -928,7 +928,10 @@ def test_move_measurements(self):
         circ = QuantumCircuit.from_qasm_file(os.path.join(qasm_dir, "move_measurements.qasm"))
 
         lay = [0, 1, 15, 2, 14, 3, 13, 4, 12, 5, 11, 6]
-        out = transpile(circ, initial_layout=lay, coupling_map=cmap, routing_method="stochastic")
+        with self.assertWarns(DeprecationWarning):
+            out = transpile(
+                circ, initial_layout=lay, coupling_map=cmap, routing_method="stochastic"
+            )
         out_dag = circuit_to_dag(out)
         meas_nodes = out_dag.named_nodes("measure")
         for meas_node in meas_nodes:
@@ -3498,7 +3501,7 @@ def _visit_block(circuit, qubit_mapping=None):
             )[0]
         self.assertIn(qubit_map[op_node.qargs[0]], components[2])
 
-    @data("sabre", "stochastic", "basic", "lookahead")
+    @data("sabre", "basic", "lookahead")
     def test_basic_connected_circuit_dense_layout(self, routing_method):
         """Test basic connected circuit on disjoint backend"""
         qc = QuantumCircuit(5)
@@ -3522,8 +3525,34 @@ def test_basic_connected_circuit_dense_layout(self, routing_method):
                 continue
             self.assertIn(qubits, self.backend.target[op_name])
 
+    @data("stochastic")
+    def test_basic_connected_circuit_dense_layout_stochastic(self, routing_method):
+        """Test basic connected circuit on disjoint backend for deprecated stochastic swap"""
+        # TODO: Remove when StochasticSwap is removed
+        qc = QuantumCircuit(5)
+        qc.h(0)
+        qc.cx(0, 1)
+        qc.cx(0, 2)
+        qc.cx(0, 3)
+        qc.cx(0, 4)
+        qc.measure_all()
+        with self.assertWarns(DeprecationWarning):
+            tqc = transpile(
+                qc,
+                self.backend,
+                layout_method="dense",
+                routing_method=routing_method,
+                seed_transpiler=42,
+            )
+        for inst in tqc.data:
+            qubits = tuple(tqc.find_bit(x).index for x in inst.qubits)
+            op_name = inst.operation.name
+            if op_name == "barrier":
+                continue
+            self.assertIn(qubits, self.backend.target[op_name])
+
     # Lookahead swap skipped for performance
-    @data("sabre", "stochastic", "basic")
+    @data("sabre", "basic")
     def test_triple_circuit_dense_layout(self, routing_method):
         """Test a split circuit with one circuit component per chip."""
         qc = QuantumCircuit(30)
@@ -3572,7 +3601,58 @@ def test_triple_circuit_dense_layout(self, routing_method):
                 continue
             self.assertIn(qubits, self.backend.target[op_name])
 
-    @data("sabre", "stochastic", "basic", "lookahead")
+    @data("stochastic")
+    def test_triple_circuit_dense_layout_stochastic(self, routing_method):
+        """Test a split circuit with one circuit component per chip for deprecated StochasticSwap."""
+        # TODO: Remove when StochasticSwap is removed
+        qc = QuantumCircuit(30)
+        qc.h(0)
+        qc.h(10)
+        qc.h(20)
+        qc.cx(0, 1)
+        qc.cx(0, 2)
+        qc.cx(0, 3)
+        qc.cx(0, 4)
+        qc.cx(0, 5)
+        qc.cx(0, 6)
+        qc.cx(0, 7)
+        qc.cx(0, 8)
+        qc.cx(0, 9)
+        qc.ecr(10, 11)
+        qc.ecr(10, 12)
+        qc.ecr(10, 13)
+        qc.ecr(10, 14)
+        qc.ecr(10, 15)
+        qc.ecr(10, 16)
+        qc.ecr(10, 17)
+        qc.ecr(10, 18)
+        qc.ecr(10, 19)
+        qc.cy(20, 21)
+        qc.cy(20, 22)
+        qc.cy(20, 23)
+        qc.cy(20, 24)
+        qc.cy(20, 25)
+        qc.cy(20, 26)
+        qc.cy(20, 27)
+        qc.cy(20, 28)
+        qc.cy(20, 29)
+        qc.measure_all()
+        with self.assertWarns(DeprecationWarning):
+            tqc = transpile(
+                qc,
+                self.backend,
+                layout_method="dense",
+                routing_method=routing_method,
+                seed_transpiler=42,
+            )
+        for inst in tqc.data:
+            qubits = tuple(tqc.find_bit(x).index for x in inst.qubits)
+            op_name = inst.operation.name
+            if op_name == "barrier":
+                continue
+            self.assertIn(qubits, self.backend.target[op_name])
+
+    @data("sabre", "basic", "lookahead")
     def test_triple_circuit_invalid_layout(self, routing_method):
         """Test a split circuit with one circuit component per chip."""
         qc = QuantumCircuit(30)
@@ -3616,8 +3696,54 @@ def test_triple_circuit_invalid_layout(self, routing_method):
                 seed_transpiler=42,
             )
 
-    # Lookahead swap skipped for performance reasons
-    @data("sabre", "stochastic", "basic")
+    @data("stochastic")
+    def test_triple_circuit_invalid_layout_stochastic(self, routing_method):
+        """Test a split circuit with one circuit component per chip for deprecated ``StochasticSwap``"""
+        # TODO: Remove when StochasticSwap is removed
+        qc = QuantumCircuit(30)
+        qc.h(0)
+        qc.h(10)
+        qc.h(20)
+        qc.cx(0, 1)
+        qc.cx(0, 2)
+        qc.cx(0, 3)
+        qc.cx(0, 4)
+        qc.cx(0, 5)
+        qc.cx(0, 6)
+        qc.cx(0, 7)
+        qc.cx(0, 8)
+        qc.cx(0, 9)
+        qc.ecr(10, 11)
+        qc.ecr(10, 12)
+        qc.ecr(10, 13)
+        qc.ecr(10, 14)
+        qc.ecr(10, 15)
+        qc.ecr(10, 16)
+        qc.ecr(10, 17)
+        qc.ecr(10, 18)
+        qc.ecr(10, 19)
+        qc.cy(20, 21)
+        qc.cy(20, 22)
+        qc.cy(20, 23)
+        qc.cy(20, 24)
+        qc.cy(20, 25)
+        qc.cy(20, 26)
+        qc.cy(20, 27)
+        qc.cy(20, 28)
+        qc.cy(20, 29)
+        qc.measure_all()
+        with self.assertWarns(DeprecationWarning):
+            with self.assertRaises(TranspilerError):
+                transpile(
+                    qc,
+                    self.backend,
+                    layout_method="trivial",
+                    routing_method=routing_method,
+                    seed_transpiler=42,
+                )
+
+    # Lookahead swap skipped for performance reasons, stochastic moved to new test due to deprecation
+    @data("sabre", "basic")
     def test_six_component_circuit_dense_layout(self, routing_method):
         """Test input circuit with more than 1 component per backend component."""
         qc = QuantumCircuit(42)
@@ -3678,6 +3804,71 @@ def test_six_component_circuit_dense_layout(self, routing_method):
                 continue
             self.assertIn(qubits, self.backend.target[op_name])
 
+    # Lookahead swap skipped for performance reasons
+    @data("stochastic")
+    def test_six_component_circuit_dense_layout_stochastic(self, routing_method):
+        """Test input circuit with more than 1 component per backend component
+        for deprecated ``StochasticSwap``."""
+        # TODO: Remove when StochasticSwap is removed
+        qc = QuantumCircuit(42)
+        qc.h(0)
+        qc.h(10)
+        qc.h(20)
+        qc.cx(0, 1)
+        qc.cx(0, 2)
+        qc.cx(0, 3)
+        qc.cx(0, 4)
+        qc.cx(0, 5)
+        qc.cx(0, 6)
+        qc.cx(0, 7)
+        qc.cx(0, 8)
+        qc.cx(0, 9)
+        qc.ecr(10, 11)
+        qc.ecr(10, 12)
+        qc.ecr(10, 13)
+        qc.ecr(10, 14)
+        qc.ecr(10, 15)
+        qc.ecr(10, 16)
+        qc.ecr(10, 17)
+        qc.ecr(10, 18)
+        qc.ecr(10, 19)
+        qc.cy(20, 21)
+        qc.cy(20, 22)
+        qc.cy(20, 23)
+        qc.cy(20, 24)
+        qc.cy(20, 25)
+        qc.cy(20, 26)
+        qc.cy(20, 27)
+        qc.cy(20, 28)
+        qc.cy(20, 29)
+        qc.h(30)
+        qc.cx(30, 31)
+        qc.cx(30, 32)
+        qc.cx(30, 33)
+        qc.h(34)
+        qc.cx(34, 35)
+        qc.cx(34, 36)
+        qc.cx(34, 37)
+        qc.h(38)
+        qc.cx(38, 39)
+        qc.cx(39, 40)
+        qc.cx(39, 41)
+        qc.measure_all()
+        with self.assertWarns(DeprecationWarning):
+            tqc = transpile(
+                qc,
+                self.backend,
+                layout_method="dense",
+                routing_method=routing_method,
+                seed_transpiler=42,
+            )
+        for inst in tqc.data:
+            qubits = tuple(tqc.find_bit(x).index for x in inst.qubits)
+            op_name = inst.operation.name
+            if op_name == "barrier":
+                continue
+            self.assertIn(qubits, self.backend.target[op_name])
+
     @data(0, 1, 2, 3)
     def test_transpile_target_with_qubits_without_ops(self, opt_level):
         """Test qubits without operations aren't ever used."""
diff --git a/test/python/transpiler/test_mappers.py b/test/python/transpiler/test_mappers.py
index dc4767b19517..c3b0644c2473 100644
--- a/test/python/transpiler/test_mappers.py
+++ b/test/python/transpiler/test_mappers.py
@@ -71,12 +71,13 @@ def test_a_common_test(self):
 import unittest
 import os
 import sys
+import warnings
 
 from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit, transpile
 from qiskit.providers.basic_provider import BasicSimulator
 from qiskit.qasm2 import dump
 from qiskit.transpiler import PassManager
-from qiskit.transpiler.passes import BasicSwap, LookaheadSwap, StochasticSwap, SabreSwap
+from qiskit.transpiler.passes import BasicSwap, LookaheadSwap, SabreSwap, StochasticSwap
 from qiskit.transpiler.passes import SetLayout
 from qiskit.transpiler import CouplingMap, Layout
 from test import QiskitTestCase  # pylint: disable=wrong-import-order
@@ -104,8 +105,15 @@ def create_passmanager(self, coupling_map, initial_layout=None):
         if initial_layout:
             passmanager.append(SetLayout(Layout(initial_layout)))
 
-        # pylint: disable=not-callable
-        passmanager.append(self.pass_class(CouplingMap(coupling_map), **self.additional_args))
+        with warnings.catch_warnings():
+            # TODO: remove this filter when StochasticSwap is removed
+            warnings.filterwarnings(
+                "ignore",
+                category=DeprecationWarning,
+                message=r".*StochasticSwap.*",
+            )
+            # pylint: disable=not-callable
+            passmanager.append(self.pass_class(CouplingMap(coupling_map), **self.additional_args))
         return passmanager
 
     def create_backend(self):
diff --git a/test/python/transpiler/test_preset_passmanagers.py b/test/python/transpiler/test_preset_passmanagers.py
index dd760b2264ce..b762d84032bb 100644
--- a/test/python/transpiler/test_preset_passmanagers.py
+++ b/test/python/transpiler/test_preset_passmanagers.py
@@ -497,7 +497,7 @@ def test_level1_runs_vf2post_layout_when_routing_required(self):
         self.assertNotIn("SabreSwap", self.passes)
 
     def test_level1_runs_vf2post_layout_when_routing_method_set_and_required(self):
-        """Test that if we run routing as part of sabre layout VF2PostLayout runs."""
+        """Test that if we run routing as part of sabre layout then VF2PostLayout runs."""
         target = GenericBackendV2(num_qubits=7, coupling_map=LAGOS_CMAP, seed=42)
         qc = QuantumCircuit(5)
         qc.h(0)
@@ -507,7 +507,7 @@ def test_level1_runs_vf2post_layout_when_routing_method_set_and_required(self):
         qc.cy(0, 4)
         qc.measure_all()
         _ = transpile(
-            qc, target, optimization_level=1, routing_method="stochastic", callback=self.callback
+            qc, target, optimization_level=1, routing_method="sabre", callback=self.callback
         )
         # Expected call path for layout and routing is:
         # 1. TrivialLayout (no perfect match)
@@ -518,7 +518,6 @@ def test_level1_runs_vf2post_layout_when_routing_method_set_and_required(self):
         self.assertIn("VF2Layout", self.passes)
         self.assertIn("SabreLayout", self.passes)
         self.assertIn("VF2PostLayout", self.passes)
-        self.assertIn("StochasticSwap", self.passes)
 
     def test_level1_not_runs_vf2post_layout_when_layout_method_set(self):
         """Test that if we don't run VF2PostLayout with custom layout_method."""
diff --git a/test/python/transpiler/test_sabre_layout.py b/test/python/transpiler/test_sabre_layout.py
index 5ab8fe5c10b2..a5ebef43540f 100644
--- a/test/python/transpiler/test_sabre_layout.py
+++ b/test/python/transpiler/test_sabre_layout.py
@@ -259,14 +259,15 @@ def test_layout_many_search_trials(self):
             coupling_map=MUMBAI_CMAP,
             seed=42,
         )
-        res = transpile(
-            qc,
-            backend,
-            layout_method="sabre",
-            routing_method="stochastic",
-            seed_transpiler=12345,
-            optimization_level=1,
-        )
+        with self.assertWarns(DeprecationWarning):
+            res = transpile(
+                qc,
+                backend,
+                layout_method="sabre",
+                routing_method="stochastic",
+                seed_transpiler=12345,
+                optimization_level=1,
+            )
         self.assertIsInstance(res, QuantumCircuit)
         layout = res._layout.initial_layout
         self.assertEqual(
@@ -306,10 +307,11 @@ def test_support_var_with_explicit_routing_pass(self):
         qc.cx(4, 0)
 
         cm = CouplingMap.from_line(8)
-        pass_ = SabreLayout(
-            cm, seed=0, routing_pass=StochasticSwap(cm, trials=1, seed=0, fake_run=True)
-        )
-        _ = pass_(qc)
+        with self.assertWarns(DeprecationWarning):
+            pass_ = SabreLayout(
+                cm, seed=0, routing_pass=StochasticSwap(cm, trials=1, seed=0, fake_run=True)
+            )
+            _ = pass_(qc)
         layout = pass_.property_set["layout"]
         self.assertEqual([layout[q] for q in qc.qubits], [2, 3, 4, 1, 5])
 
diff --git a/test/python/transpiler/test_stage_plugin.py b/test/python/transpiler/test_stage_plugin.py
index 1c0adc9776a0..f278096b8419 100644
--- a/test/python/transpiler/test_stage_plugin.py
+++ b/test/python/transpiler/test_stage_plugin.py
@@ -102,7 +102,7 @@ class TestBuiltinPlugins(QiskitTestCase):
 
     @combine(
         optimization_level=list(range(4)),
-        routing_method=["basic", "lookahead", "sabre", "stochastic"],
+        routing_method=["basic", "lookahead", "sabre"],
     )
     def test_routing_plugins(self, optimization_level, routing_method):
         """Test all routing plugins (excluding error)."""
@@ -123,6 +123,31 @@ def test_routing_plugins(self, optimization_level, routing_method):
         counts = backend.run(tqc, shots=1000).result().get_counts()
         self.assertDictAlmostEqual(counts, {"0000": 500, "1111": 500}, delta=100)
 
+    @combine(
+        optimization_level=list(range(4)),
+        routing_method=["stochastic"],
+    )
+    def test_routing_plugin_stochastic(self, optimization_level, routing_method):
+        """Test stoc routing plugins (excluding error)."""
+        # Note remove once StochasticSwap gets removed
+        qc = QuantumCircuit(4)
+        qc.h(0)
+        qc.cx(0, 1)
+        qc.cx(0, 2)
+        qc.cx(0, 3)
+        qc.measure_all()
+        with self.assertWarns(DeprecationWarning):
+            tqc = transpile(
+                qc,
+                basis_gates=["cx", "sx", "x", "rz"],
+                coupling_map=CouplingMap.from_line(4),
+                optimization_level=optimization_level,
+                routing_method=routing_method,
+            )
+        backend = BasicSimulator()
+        counts = backend.run(tqc, shots=1000).result().get_counts()
+        self.assertDictAlmostEqual(counts, {"0000": 500, "1111": 500}, delta=100)
+
     @combine(
         optimization_level=list(range(4)),
     )
diff --git a/test/python/transpiler/test_stochastic_swap.py b/test/python/transpiler/test_stochastic_swap.py
index 4843bac8baf5..ee5d8a1dad31 100644
--- a/test/python/transpiler/test_stochastic_swap.py
+++ b/test/python/transpiler/test_stochastic_swap.py
@@ -60,8 +60,9 @@ def test_trivial_case(self):
         circuit.cx(qr[0], qr[2])
 
         dag = circuit_to_dag(circuit)
-        pass_ = StochasticSwap(coupling, 20, 13)
-        after = pass_.run(dag)
+        with self.assertWarns(DeprecationWarning):
+            pass_ = StochasticSwap(coupling, 20, 13)
+            after = pass_.run(dag)
 
         self.assertEqual(dag, after)
 
@@ -83,8 +84,9 @@ def test_trivial_in_same_layer(self):
         circuit.cx(qr[0], qr[1])
 
         dag = circuit_to_dag(circuit)
-        pass_ = StochasticSwap(coupling, 20, 13)
-        after = pass_.run(dag)
+        with self.assertWarns(DeprecationWarning):
+            pass_ = StochasticSwap(coupling, 20, 13)
+            after = pass_.run(dag)
 
         self.assertEqual(dag, after)
 
@@ -109,8 +111,9 @@ def test_permute_wires_1(self):
         circuit.cx(qr[1], qr[2])
         dag = circuit_to_dag(circuit)
 
-        pass_ = StochasticSwap(coupling, 20, 11)
-        after = pass_.run(dag)
+        with self.assertWarns(DeprecationWarning):
+            pass_ = StochasticSwap(coupling, 20, 11)
+            after = pass_.run(dag)
 
         expected = QuantumCircuit(qr)
         expected.swap(qr[0], qr[2])
@@ -140,8 +143,9 @@ def test_permute_wires_2(self):
         circuit.h(qr[0])
         dag = circuit_to_dag(circuit)
 
-        pass_ = StochasticSwap(coupling, 20, 11)
-        after = pass_.run(dag)
+        with self.assertWarns(DeprecationWarning):
+            pass_ = StochasticSwap(coupling, 20, 11)
+            after = pass_.run(dag)
 
         expected = QuantumCircuit(qr)
         expected.swap(qr[1], qr[2])
@@ -176,8 +180,9 @@ def test_permute_wires_3(self):
         circuit.cx(qr[3], qr[0])
         dag = circuit_to_dag(circuit)
 
-        pass_ = StochasticSwap(coupling, 20, 13)
-        after = pass_.run(dag)
+        with self.assertWarns(DeprecationWarning):
+            pass_ = StochasticSwap(coupling, 20, 13)
+            after = pass_.run(dag)
 
         expected = QuantumCircuit(qr)
         expected.swap(qr[0], qr[1])
@@ -215,8 +220,9 @@ def test_permute_wires_4(self):
         circuit.cx(qr[3], qr[0])
         dag = circuit_to_dag(circuit)
 
-        pass_ = StochasticSwap(coupling, 20, 13)
-        after = pass_.run(dag)
+        with self.assertWarns(DeprecationWarning):
+            pass_ = StochasticSwap(coupling, 20, 13)
+            after = pass_.run(dag)
 
         expected = QuantumCircuit(qr)
         expected.h(qr[3])
@@ -254,8 +260,9 @@ def test_permute_wires_5(self):
         circuit.h(qr[3])
         dag = circuit_to_dag(circuit)
 
-        pass_ = StochasticSwap(coupling, 20, 13)
-        after = pass_.run(dag)
+        with self.assertWarns(DeprecationWarning):
+            pass_ = StochasticSwap(coupling, 20, 13)
+            after = pass_.run(dag)
 
         expected = QuantumCircuit(qr)
         expected.swap(qr[0], qr[1])
@@ -283,8 +290,9 @@ def test_all_single_qubit(self):
         circ.measure(qr[3], cr[3])
         dag = circuit_to_dag(circ)
 
-        pass_ = StochasticSwap(coupling, 20, 13)
-        after = pass_.run(dag)
+        with self.assertWarns(DeprecationWarning):
+            pass_ = StochasticSwap(coupling, 20, 13)
+            after = pass_.run(dag)
         self.assertEqual(dag, after)
 
     def test_overoptimization_case(self):
@@ -363,8 +371,9 @@ def test_overoptimization_case(self):
         #  qr[1]: 1,
         #  qr[2]: 2,
         #  qr[3]: 3}
-        pass_ = StochasticSwap(coupling, 20, 19)
-        after = pass_.run(dag)
+        with self.assertWarns(DeprecationWarning):
+            pass_ = StochasticSwap(coupling, 20, 19)
+            after = pass_.run(dag)
 
         self.assertEqual(expected_dag, after)
 
@@ -389,8 +398,9 @@ def test_already_mapped(self):
 
         dag = circuit_to_dag(circ)
 
-        pass_ = StochasticSwap(coupling, 20, 13)
-        after = pass_.run(dag)
+        with self.assertWarns(DeprecationWarning):
+            pass_ = StochasticSwap(coupling, 20, 13)
+            after = pass_.run(dag)
         self.assertEqual(circuit_to_dag(circ), after)
 
     def test_congestion(self):
@@ -465,8 +475,9 @@ def test_congestion(self):
         expected.measure(qr[1], cr[1])
         expected_dag = circuit_to_dag(expected)
 
-        pass_ = StochasticSwap(coupling, 20, 999)
-        after = pass_.run(dag)
+        with self.assertWarns(DeprecationWarning):
+            pass_ = StochasticSwap(coupling, 20, 999)
+            after = pass_.run(dag)
         self.assertEqual(expected_dag, after)
 
     def test_only_output_cx_and_swaps_in_coupling_map(self):
@@ -483,8 +494,9 @@ def test_only_output_cx_and_swaps_in_coupling_map(self):
         circuit.measure(qr, cr)
         dag = circuit_to_dag(circuit)
 
-        pass_ = StochasticSwap(coupling, 20, 5)
-        after = pass_.run(dag)
+        with self.assertWarns(DeprecationWarning):
+            pass_ = StochasticSwap(coupling, 20, 5)
+            after = pass_.run(dag)
 
         valid_couplings = [{qr[a], qr[b]} for (a, b) in coupling.get_edges()]
 
@@ -505,7 +517,8 @@ def test_len_cm_vs_dag(self):
         circuit.measure(qr, cr)
         dag = circuit_to_dag(circuit)
 
-        pass_ = StochasticSwap(coupling)
+        with self.assertWarns(DeprecationWarning):
+            pass_ = StochasticSwap(coupling)
         with self.assertRaises(TranspilerError):
             _ = pass_.run(dag)
 
@@ -549,8 +562,9 @@ def test_single_gates_omitted(self):
 
         expected_dag = circuit_to_dag(expected)
 
-        stochastic = StochasticSwap(CouplingMap(coupling_map), seed=0)
-        after = PassManager(stochastic).run(circuit)
+        with self.assertWarns(DeprecationWarning):
+            stochastic = StochasticSwap(CouplingMap(coupling_map), seed=0)
+            after = PassManager(stochastic).run(circuit)
         after = circuit_to_dag(after)
         self.assertEqual(expected_dag, after)
 
@@ -578,9 +592,10 @@ def test_pre_if_else_route(self):
         qc.measure(qreg, creg)
 
         dag = circuit_to_dag(qc)
-        cdag = StochasticSwap(coupling, seed=82).run(dag)
-        check_map_pass = CheckMap(coupling)
-        check_map_pass.run(cdag)
+        with self.assertWarns(DeprecationWarning):
+            cdag = StochasticSwap(coupling, seed=82).run(dag)
+            check_map_pass = CheckMap(coupling)
+            check_map_pass.run(cdag)
         self.assertTrue(check_map_pass.property_set["is_swap_mapped"])
 
         expected = QuantumCircuit(qreg, creg)
@@ -618,9 +633,10 @@ def test_pre_if_else_route_post_x(self):
         qc.measure(qreg, creg)
 
         dag = circuit_to_dag(qc)
-        cdag = StochasticSwap(coupling, seed=431).run(dag)
-        check_map_pass = CheckMap(coupling)
-        check_map_pass.run(cdag)
+        with self.assertWarns(DeprecationWarning):
+            cdag = StochasticSwap(coupling, seed=431).run(dag)
+            check_map_pass = CheckMap(coupling)
+            check_map_pass.run(cdag)
         self.assertTrue(check_map_pass.property_set["is_swap_mapped"])
 
         expected = QuantumCircuit(qreg, creg)
@@ -660,9 +676,10 @@ def test_post_if_else_route(self):
         qc.measure(qreg, creg)
 
         dag = circuit_to_dag(qc)
-        cdag = StochasticSwap(coupling, seed=6508).run(dag)
-        check_map_pass = CheckMap(coupling)
-        check_map_pass.run(cdag)
+        with self.assertWarns(DeprecationWarning):
+            cdag = StochasticSwap(coupling, seed=6508).run(dag)
+            check_map_pass = CheckMap(coupling)
+            check_map_pass.run(cdag)
         self.assertTrue(check_map_pass.property_set["is_swap_mapped"])
 
         expected = QuantumCircuit(qreg, creg)
@@ -700,9 +717,10 @@ def test_pre_if_else2(self):
         qc.measure(qreg, creg)
 
         dag = circuit_to_dag(qc)
-        cdag = StochasticSwap(coupling, seed=38).run(dag)
-        check_map_pass = CheckMap(coupling)
-        check_map_pass.run(cdag)
+        with self.assertWarns(DeprecationWarning):
+            cdag = StochasticSwap(coupling, seed=38).run(dag)
+            check_map_pass = CheckMap(coupling)
+            check_map_pass.run(cdag)
         self.assertTrue(check_map_pass.property_set["is_swap_mapped"])
 
         expected = QuantumCircuit(qreg, creg)
@@ -738,9 +756,10 @@ def test_intra_if_else_route(self):
         qc.measure(qreg, creg)
 
         dag = circuit_to_dag(qc)
-        cdag = StochasticSwap(coupling, seed=8).run(dag)
-        check_map_pass = CheckMap(coupling)
-        check_map_pass.run(cdag)
+        with self.assertWarns(DeprecationWarning):
+            cdag = StochasticSwap(coupling, seed=8).run(dag)
+            check_map_pass = CheckMap(coupling)
+            check_map_pass.run(cdag)
         self.assertTrue(check_map_pass.property_set["is_swap_mapped"])
 
         expected = QuantumCircuit(qreg, creg)
@@ -781,9 +800,10 @@ def test_pre_intra_if_else(self):
         qc.measure(qreg, creg)
 
         dag = circuit_to_dag(qc)
-        cdag = StochasticSwap(coupling, seed=2, trials=20).run(dag)
-        check_map_pass = CheckMap(coupling)
-        check_map_pass.run(cdag)
+        with self.assertWarns(DeprecationWarning):
+            cdag = StochasticSwap(coupling, seed=2, trials=20).run(dag)
+            check_map_pass = CheckMap(coupling)
+            check_map_pass.run(cdag)
         self.assertTrue(check_map_pass.property_set["is_swap_mapped"])
 
         expected = QuantumCircuit(qreg, creg)
@@ -829,9 +849,10 @@ def test_pre_intra_post_if_else(self):
         qc.measure(qreg, creg)
 
         dag = circuit_to_dag(qc)
-        cdag = StochasticSwap(coupling, seed=1).run(dag)
-        check_map_pass = CheckMap(coupling)
-        check_map_pass.run(cdag)
+        with self.assertWarns(DeprecationWarning):
+            cdag = StochasticSwap(coupling, seed=1).run(dag)
+            check_map_pass = CheckMap(coupling)
+            check_map_pass.run(cdag)
         self.assertTrue(check_map_pass.property_set["is_swap_mapped"])
 
         expected = QuantumCircuit(qreg, creg)
@@ -871,9 +892,10 @@ def test_if_expr(self):
         qc.if_test(expr.logic_and(qc.clbits[0], qc.clbits[1]), body, [0, 1, 2, 3], [])
 
         dag = circuit_to_dag(qc)
-        cdag = StochasticSwap(coupling, seed=58).run(dag)
-        check_map_pass = CheckMap(coupling)
-        check_map_pass.run(cdag)
+        with self.assertWarns(DeprecationWarning):
+            cdag = StochasticSwap(coupling, seed=58).run(dag)
+            check_map_pass = CheckMap(coupling)
+            check_map_pass.run(cdag)
         self.assertTrue(check_map_pass.property_set["is_swap_mapped"])
 
     def test_if_else_expr(self):
@@ -892,9 +914,10 @@ def test_if_else_expr(self):
         qc.if_else(expr.logic_and(qc.clbits[0], qc.clbits[1]), true, false, [0, 1, 2, 3], [])
 
         dag = circuit_to_dag(qc)
-        cdag = StochasticSwap(coupling, seed=58).run(dag)
-        check_map_pass = CheckMap(coupling)
-        check_map_pass.run(cdag)
+        with self.assertWarns(DeprecationWarning):
+            cdag = StochasticSwap(coupling, seed=58).run(dag)
+            check_map_pass = CheckMap(coupling)
+            check_map_pass.run(cdag)
         self.assertTrue(check_map_pass.property_set["is_swap_mapped"])
 
     def test_standalone_vars(self):
@@ -935,8 +958,9 @@ def test_standalone_vars(self):
                 qc.cx(3, 1)
 
         cm = CouplingMap.from_line(5)
-        pm = PassManager([StochasticSwap(cm, seed=0), CheckMap(cm)])
-        _ = pm.run(qc)
+        with self.assertWarns(DeprecationWarning):
+            pm = PassManager([StochasticSwap(cm, seed=0), CheckMap(cm)])
+            _ = pm.run(qc)
         self.assertTrue(pm.property_set["is_swap_mapped"])
 
     def test_no_layout_change(self):
@@ -959,9 +983,10 @@ def test_no_layout_change(self):
         qc.measure(qreg, creg)
 
         dag = circuit_to_dag(qc)
-        cdag = StochasticSwap(coupling, seed=23).run(dag)
-        check_map_pass = CheckMap(coupling)
-        check_map_pass.run(cdag)
+        with self.assertWarns(DeprecationWarning):
+            cdag = StochasticSwap(coupling, seed=23).run(dag)
+            check_map_pass = CheckMap(coupling)
+            check_map_pass.run(cdag)
         self.assertTrue(check_map_pass.property_set["is_swap_mapped"])
 
         expected = QuantumCircuit(qreg, creg)
@@ -999,9 +1024,10 @@ def test_for_loop(self, nloops):
         qc.measure(qreg, creg)
 
         dag = circuit_to_dag(qc)
-        cdag = StochasticSwap(coupling, seed=687).run(dag)
-        check_map_pass = CheckMap(coupling)
-        check_map_pass.run(cdag)
+        with self.assertWarns(DeprecationWarning):
+            cdag = StochasticSwap(coupling, seed=687).run(dag)
+            check_map_pass = CheckMap(coupling)
+            check_map_pass.run(cdag)
         self.assertTrue(check_map_pass.property_set["is_swap_mapped"])
 
         expected = QuantumCircuit(qreg, creg)
@@ -1033,9 +1059,10 @@ def test_while_loop(self):
         qc.measure(qreg, creg)
 
         dag = circuit_to_dag(qc)
-        cdag = StochasticSwap(coupling, seed=58).run(dag)
-        check_map_pass = CheckMap(coupling)
-        check_map_pass.run(cdag)
+        with self.assertWarns(DeprecationWarning):
+            cdag = StochasticSwap(coupling, seed=58).run(dag)
+            check_map_pass = CheckMap(coupling)
+            check_map_pass.run(cdag)
         self.assertTrue(check_map_pass.property_set["is_swap_mapped"])
 
         expected = QuantumCircuit(qreg, creg)
@@ -1065,9 +1092,10 @@ def test_while_loop_expr(self):
         qc.while_loop(expr.logic_and(qc.clbits[0], qc.clbits[1]), body, [0, 1, 2, 3], [])
 
         dag = circuit_to_dag(qc)
-        cdag = StochasticSwap(coupling, seed=58).run(dag)
-        check_map_pass = CheckMap(coupling)
-        check_map_pass.run(cdag)
+        with self.assertWarns(DeprecationWarning):
+            cdag = StochasticSwap(coupling, seed=58).run(dag)
+            check_map_pass = CheckMap(coupling)
+            check_map_pass.run(cdag)
         self.assertTrue(check_map_pass.property_set["is_swap_mapped"])
 
     def test_switch_single_case(self):
@@ -1083,8 +1111,9 @@ def test_switch_single_case(self):
         qc.switch(creg, [(0, case0)], qreg[[0, 1, 2]], creg)
 
         coupling = CouplingMap.from_line(len(qreg))
-        pass_ = StochasticSwap(coupling, seed=58)
-        test = pass_(qc)
+        with self.assertWarns(DeprecationWarning):
+            pass_ = StochasticSwap(coupling, seed=58)
+            test = pass_(qc)
 
         check = CheckMap(coupling)
         check(test)
@@ -1122,8 +1151,9 @@ def test_switch_nonexhaustive(self):
         qc.switch(creg, [(0, case0), ((1, 2), case1), (3, case2)], qreg, creg)
 
         coupling = CouplingMap.from_line(len(qreg))
-        pass_ = StochasticSwap(coupling, seed=58)
-        test = pass_(qc)
+        with self.assertWarns(DeprecationWarning):
+            pass_ = StochasticSwap(coupling, seed=58)
+            test = pass_(qc)
 
         check = CheckMap(coupling)
         check(test)
@@ -1167,8 +1197,9 @@ def test_switch_exhaustive(self, labels):
         qc.switch(creg, [(labels, case0)], qreg[[0, 1, 2]], creg)
 
         coupling = CouplingMap.from_line(len(qreg))
-        pass_ = StochasticSwap(coupling, seed=58)
-        test = pass_(qc)
+        with self.assertWarns(DeprecationWarning):
+            pass_ = StochasticSwap(coupling, seed=58)
+            test = pass_(qc)
 
         check = CheckMap(coupling)
         check(test)
@@ -1205,8 +1236,9 @@ def test_switch_nonexhaustive_expr(self):
         qc.switch(expr.bit_or(creg, 5), [(0, case0), ((1, 2), case1), (3, case2)], qreg, creg)
 
         coupling = CouplingMap.from_line(len(qreg))
-        pass_ = StochasticSwap(coupling, seed=58)
-        test = pass_(qc)
+        with self.assertWarns(DeprecationWarning):
+            pass_ = StochasticSwap(coupling, seed=58)
+            test = pass_(qc)
 
         check = CheckMap(coupling)
         check(test)
@@ -1250,8 +1282,9 @@ def test_switch_exhaustive_expr(self, labels):
         qc.switch(expr.bit_or(creg, 3), [(labels, case0)], qreg[[0, 1, 2]], creg)
 
         coupling = CouplingMap.from_line(len(qreg))
-        pass_ = StochasticSwap(coupling, seed=58)
-        test = pass_(qc)
+        with self.assertWarns(DeprecationWarning):
+            pass_ = StochasticSwap(coupling, seed=58)
+            test = pass_(qc)
 
         check = CheckMap(coupling)
         check(test)
@@ -1295,9 +1328,10 @@ def test_nested_inner_cnot(self):
         qc.measure(qreg, creg)
 
         dag = circuit_to_dag(qc)
-        cdag = StochasticSwap(coupling, seed=seed).run(dag)
-        check_map_pass = CheckMap(coupling)
-        check_map_pass.run(cdag)
+        with self.assertWarns(DeprecationWarning):
+            cdag = StochasticSwap(coupling, seed=seed).run(dag)
+            check_map_pass = CheckMap(coupling)
+            check_map_pass.run(cdag)
         self.assertTrue(check_map_pass.property_set["is_swap_mapped"])
 
         expected = QuantumCircuit(qreg, creg)
@@ -1350,9 +1384,10 @@ def test_nested_outer_cnot(self):
         qc.measure(qreg, creg)
 
         dag = circuit_to_dag(qc)
-        cdag = StochasticSwap(coupling, seed=seed).run(dag)
-        check_map_pass = CheckMap(coupling)
-        check_map_pass.run(cdag)
+        with self.assertWarns(DeprecationWarning):
+            cdag = StochasticSwap(coupling, seed=seed).run(dag)
+            check_map_pass = CheckMap(coupling)
+            check_map_pass.run(cdag)
         self.assertTrue(check_map_pass.property_set["is_swap_mapped"])
 
         expected = QuantumCircuit(qreg, creg)
@@ -1386,7 +1421,8 @@ def test_disjoint_looping(self):
         loop_body = QuantumCircuit(2)
         loop_body.cx(0, 1)
         qc.for_loop((0,), None, loop_body, [0, 2], [])
-        cqc = StochasticSwap(cm, seed=0)(qc)
+        with self.assertWarns(DeprecationWarning):
+            cqc = StochasticSwap(cm, seed=0)(qc)
 
         expected = QuantumCircuit(qr)
         efor_body = QuantumCircuit(qr[[0, 1, 2]])
@@ -1408,7 +1444,8 @@ def test_disjoint_multiblock(self):
         false_body = QuantumCircuit(3, 1)
         false_body.cx(0, 2)
         qc.if_else((cr[0], 1), true_body, false_body, [0, 1, 2], [0])
-        cqc = StochasticSwap(cm, seed=353)(qc)
+        with self.assertWarns(DeprecationWarning):
+            cqc = StochasticSwap(cm, seed=353)(qc)
 
         expected = QuantumCircuit(qr, cr)
         etrue_body = QuantumCircuit(qr[[0, 1, 2]], cr[[0]])
@@ -1431,7 +1468,8 @@ def test_multiple_ops_per_layer(self):
         qc.cx(0, 2)
         with qc.for_loop((0,)):
             qc.cx(3, 5)
-        cqc = StochasticSwap(coupling, seed=0)(qc)
+        with self.assertWarns(DeprecationWarning):
+            cqc = StochasticSwap(coupling, seed=0)(qc)
         check_map_pass(cqc)
         self.assertTrue(check_map_pass.property_set["is_swap_mapped"])
 
@@ -1465,8 +1503,9 @@ def test_if_no_else_restores_layout(self):
             qc.cx(2, 0)
             qc.cx(7, 6)
         coupling = CouplingMap.from_line(8)
-        pass_ = StochasticSwap(coupling, seed=2022_10_13)
-        transpiled = pass_(qc)
+        with self.assertWarns(DeprecationWarning):
+            pass_ = StochasticSwap(coupling, seed=2022_10_13)
+            transpiled = pass_(qc)
 
         # Check the pass claims to have done things right.
         initial_layout = Layout.generate_trivial_layout(*qc.qubits)
@@ -1532,29 +1571,31 @@ def _visit_block(circuit, qubit_mapping=None):
     def test_random_circuit_no_control_flow(self, size):
         """Test that transpiled random circuits without control flow are physical circuits."""
         circuit = random_circuit(size, 3, measure=True, seed=12342)
-        tqc = transpile(
-            circuit,
-            self.backend,
-            routing_method="stochastic",
-            layout_method="dense",
-            seed_transpiler=12342,
-        )
+        with self.assertWarns(DeprecationWarning):
+            tqc = transpile(
+                circuit,
+                self.backend,
+                routing_method="stochastic",
+                layout_method="dense",
+                seed_transpiler=12342,
+            )
         self.assert_valid_circuit(tqc)
 
     @data(*range(1, 27))
     def test_random_circuit_no_control_flow_target(self, size):
         """Test that transpiled random circuits without control flow are physical circuits."""
         circuit = random_circuit(size, 3, measure=True, seed=12342)
-        tqc = transpile(
-            circuit,
-            routing_method="stochastic",
-            layout_method="dense",
-            seed_transpiler=12342,
-            target=GenericBackendV2(
-                num_qubits=27,
-                coupling_map=MUMBAI_CMAP,
-            ).target,
-        )
+        with self.assertWarns(DeprecationWarning):
+            tqc = transpile(
+                circuit,
+                routing_method="stochastic",
+                layout_method="dense",
+                seed_transpiler=12342,
+                target=GenericBackendV2(
+                    num_qubits=27,
+                    coupling_map=MUMBAI_CMAP,
+                ).target,
+            )
         self.assert_valid_circuit(tqc)
 
     @data(*range(4, 27))
@@ -1569,14 +1610,15 @@ def test_random_circuit_for_loop(self, size):
             circuit.append(for_block, [1, 0, 2])
         circuit.measure_all()
 
-        tqc = transpile(
-            circuit,
-            self.backend,
-            basis_gates=list(self.basis_gates),
-            routing_method="stochastic",
-            layout_method="dense",
-            seed_transpiler=12342,
-        )
+        with self.assertWarns(DeprecationWarning):
+            tqc = transpile(
+                circuit,
+                self.backend,
+                basis_gates=list(self.basis_gates),
+                routing_method="stochastic",
+                layout_method="dense",
+                seed_transpiler=12342,
+            )
         self.assert_valid_circuit(tqc)
 
     @data(*range(6, 27))
@@ -1598,14 +1640,15 @@ def test_random_circuit_if_else(self, size):
         with else_:
             circuit.append(else_block, [2, 5], clbit_indices[: else_block.num_clbits])
 
-        tqc = transpile(
-            circuit,
-            self.backend,
-            basis_gates=list(self.basis_gates),
-            routing_method="stochastic",
-            layout_method="dense",
-            seed_transpiler=12342,
-        )
+        with self.assertWarns(DeprecationWarning):
+            tqc = transpile(
+                circuit,
+                self.backend,
+                basis_gates=list(self.basis_gates),
+                routing_method="stochastic",
+                layout_method="dense",
+                seed_transpiler=12342,
+            )
         self.assert_valid_circuit(tqc)
 
 

From aa09a027bedeaa74f97771d1febc479d5d81d319 Mon Sep 17 00:00:00 2001
From: Shelly Garion <46566946+ShellyGarion@users.noreply.github.com>
Date: Tue, 20 Aug 2024 16:13:37 +0300
Subject: [PATCH 12/85] Fix Initialize.gates_to_uncompute method (#12976)

* add back files needed in Initialize.gates_to_uncompute()

* add a test for Initialize.gates_to_uncompute() method

* fix a comment

* add release notes

* update gates_to_uncompute such that it will call Isometry

* remove unused imports

* transfer code from StatePreparation to Initialize.gates_to_uncompute

* update code following review
---
 qiskit/circuit/library/data_preparation/initializer.py    | 7 +++++--
 .../circuit/library/data_preparation/state_preparation.py | 2 +-
 ...ix_initialize_gates_to_uncompute-d0dba6a642d07f30.yaml | 4 ++++
 test/python/circuit/test_initializer.py                   | 8 ++++++++
 4 files changed, 18 insertions(+), 3 deletions(-)
 create mode 100644 releasenotes/notes/fix_initialize_gates_to_uncompute-d0dba6a642d07f30.yaml

diff --git a/qiskit/circuit/library/data_preparation/initializer.py b/qiskit/circuit/library/data_preparation/initializer.py
index 0e38f067403c..984c7c0d310a 100644
--- a/qiskit/circuit/library/data_preparation/initializer.py
+++ b/qiskit/circuit/library/data_preparation/initializer.py
@@ -21,6 +21,7 @@
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit.instruction import Instruction
+from qiskit.circuit.library.generalized_gates import Isometry
 from .state_preparation import StatePreparation
 
 if typing.TYPE_CHECKING:
@@ -86,9 +87,11 @@ def gates_to_uncompute(self) -> QuantumCircuit:
         """Call to create a circuit with gates that take the desired vector to zero.
 
         Returns:
-            Circuit to take ``self.params`` vector to :math:`|{00\\ldots0}\\rangle`
+            QuantumCircuit: circuit to take ``self.params`` vector to :math:`|{00\\ldots0}\\rangle`
         """
-        return self._stateprep._gates_to_uncompute()
+
+        isom = Isometry(self.params, 0, 0)
+        return isom._gates_to_uncompute()
 
     @property
     def params(self):
diff --git a/qiskit/circuit/library/data_preparation/state_preparation.py b/qiskit/circuit/library/data_preparation/state_preparation.py
index df69f9eab8c5..52006a8bb378 100644
--- a/qiskit/circuit/library/data_preparation/state_preparation.py
+++ b/qiskit/circuit/library/data_preparation/state_preparation.py
@@ -174,7 +174,7 @@ def _define_synthesis_isom(self):
         initialize_circuit = QuantumCircuit(q, name="init_def")
 
         isom = Isometry(self.params, 0, 0)
-        initialize_circuit.append(isom, q[:])
+        initialize_circuit.compose(isom.definition, copy=False, inplace=True)
 
         # invert the circuit to create the desired vector from zero (assuming
         # the qubits are in the zero state)
diff --git a/releasenotes/notes/fix_initialize_gates_to_uncompute-d0dba6a642d07f30.yaml b/releasenotes/notes/fix_initialize_gates_to_uncompute-d0dba6a642d07f30.yaml
new file mode 100644
index 000000000000..3c24569455e2
--- /dev/null
+++ b/releasenotes/notes/fix_initialize_gates_to_uncompute-d0dba6a642d07f30.yaml
@@ -0,0 +1,4 @@
+---
+fixes:
+  - |
+    Fix a bug that caused the method :meth:`Initialize.gates_to_uncompute()` fail.
diff --git a/test/python/circuit/test_initializer.py b/test/python/circuit/test_initializer.py
index a37c51f48184..2507fbc6c139 100644
--- a/test/python/circuit/test_initializer.py
+++ b/test/python/circuit/test_initializer.py
@@ -465,6 +465,14 @@ def test_mutating_params(self):
         self.assertEqual(decom_circ.data[2].operation.name, "state_preparation")
         self.assertEqual(decom_circ.data[2].operation.params, ["0", "0"])
 
+    def test_gates_to_uncompute(self):
+        """Test the gates_to_uncompute() method."""
+        desired_vector = [0.5, 0.5, 0.5, 0.5]
+        initialize = Initialize(desired_vector)
+        qc = initialize.gates_to_uncompute().inverse()
+        vec = Statevector(qc)
+        self.assertTrue(vec == Statevector(desired_vector))
+
 
 class TestInstructionParam(QiskitTestCase):
     """Test conversion of numpy type parameters."""

From b90c7a706f3848310fa1c0ddaaea5994b78ecfa4 Mon Sep 17 00:00:00 2001
From: Julien Gacon <gaconju@gmail.com>
Date: Tue, 20 Aug 2024 17:54:19 +0200
Subject: [PATCH 13/85] Tiny follow up to #12983 (#12999)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* tiny follow up

* Update releasenotes/notes/deprecate-StochasticSwap-451f46b273602b7b.yaml

Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>

---------

Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>
---
 .../passes/routing/stochastic_swap.py         |  4 +-
 ...ecate-StochasticSwap-451f46b273602b7b.yaml | 58 ++++++++++---------
 2 files changed, 33 insertions(+), 29 deletions(-)

diff --git a/qiskit/transpiler/passes/routing/stochastic_swap.py b/qiskit/transpiler/passes/routing/stochastic_swap.py
index 8cb628501017..a3ebbd6cbdde 100644
--- a/qiskit/transpiler/passes/routing/stochastic_swap.py
+++ b/qiskit/transpiler/passes/routing/stochastic_swap.py
@@ -63,8 +63,8 @@ class StochasticSwap(TransformationPass):
     @deprecate_func(
         since="1.3",
         removal_timeline="in the 2.0 release",
-        additional_msg="The `StochasticSwap` transpilation pass is a suboptimal "
-        "routing algorithm and has been superseded by the :class:`.SabreSwap` pass.",
+        additional_msg="The StochasticSwap transpilation pass is a suboptimal "
+        "routing algorithm and has been superseded by the SabreSwap pass.",
     )
     def __init__(self, coupling_map, trials=20, seed=None, fake_run=False, initial_layout=None):
         """StochasticSwap initializer.
diff --git a/releasenotes/notes/deprecate-StochasticSwap-451f46b273602b7b.yaml b/releasenotes/notes/deprecate-StochasticSwap-451f46b273602b7b.yaml
index 24ade535f294..c858dd6fe6ab 100644
--- a/releasenotes/notes/deprecate-StochasticSwap-451f46b273602b7b.yaml
+++ b/releasenotes/notes/deprecate-StochasticSwap-451f46b273602b7b.yaml
@@ -1,45 +1,49 @@
 ---
 deprecations_transpiler:
   - |
-    Deprecated ``StochasticSwap`` which has been superseded by :class:`.SabreSwap`. 
+    Deprecated :class:`.StochasticSwap` which has been superseded by :class:`.SabreSwap`. 
     If the class is called from the transpile function, the change would be, for example:: 
 
+      from qiskit import transpile
+      from qiskit.circuit import QuantumCircuit
+      from qiskit.transpiler import CouplingMap
+      from qiskit.providers.fake_provider import GenericBackendV2
+
+
+      qc = QuantumCircuit(4)
+      qc.h(0)
+      qc.cx(0, range(1, 4))
+      qc.measure_all()
+
+      cmap = CouplingMap.from_heavy_hex(3)
+      backend = GenericBackendV2(num_qubits=cmap.size(), coupling_map=cmap)
+
       tqc = transpile(
-        circuit,
-        routing_method="stochastic",
-        layout_method="dense",
-        seed_transpiler=12342,
-        target=GenericBackendV2(
-            num_qubits=27,
-            coupling_map=MUMBAI_CMAP,
-        ).target,
-        ) 
+          qc,
+          routing_method="stochastic",
+          layout_method="dense",
+          seed_transpiler=12342,
+          target=backend.target
+      )
     
     to::
 
       tqc = transpile(
-        circuit,
-        routing_method="sabre",
-        layout_method="sabre",
-        seed_transpiler=12342,
-        target=GenericBackendV2(
-            num_qubits=27,
-            coupling_map=MUMBAI_CMAP,
-        ).target,
-        )   
-
-    While for a pass mananager change::
-
-      qr = QuantumRegister(4, "q")
-      qc = QuantumCircuit(qr)
+          qc,
+          routing_method="sabre",
+          layout_method="sabre",
+          seed_transpiler=12342,
+          target=backend.target
+      )
+
+    While for a pass manager, the change would be::
+
       passmanager = PassManager(StochasticSwap(coupling, 20, 13))
       new_qc = passmanager.run(qc)
 
     to::
 
-      qr = QuantumRegister(5, "q")
-      qc = QuantumCircuit(qr) 
-      passmanager = PassManager(SabreSwap(target, "basic"))
+      passmanager = PassManager(SabreSwap(backend.target, "basic"))
       new_qc = passmanager.run(qc)
       
 

From 6107799ce19996ed125cb3f01663ad394e4eadbc Mon Sep 17 00:00:00 2001
From: Shravan Patel <78003234+shravanpatel30@users.noreply.github.com>
Date: Wed, 21 Aug 2024 04:31:03 -0500
Subject: [PATCH 14/85] Extended the `from_backend` method of
 `InstructionDurations` to support both `BackendV1` and `BackendV2` (#12941)

* Extended the `from_backend` method of `InstructionDurations` to support `GenericBackendV2`

* Simplified the `from_backend` method to allow using `BackendV2`. Added a test and a releasenote.

* Made changes to the releasenote.
---
 qiskit/transpiler/instruction_durations.py                | 4 ++++
 .../notes/fix-InstructionDurations-b47a9770b424d7a0.yaml  | 5 +++++
 test/python/transpiler/test_instruction_durations.py      | 8 ++++++++
 3 files changed, 17 insertions(+)
 create mode 100644 releasenotes/notes/fix-InstructionDurations-b47a9770b424d7a0.yaml

diff --git a/qiskit/transpiler/instruction_durations.py b/qiskit/transpiler/instruction_durations.py
index 85d89bb16a18..56f8b5587c0c 100644
--- a/qiskit/transpiler/instruction_durations.py
+++ b/qiskit/transpiler/instruction_durations.py
@@ -18,6 +18,7 @@
 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 @@ def from_backend(cls, backend: Backend):
             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"):
diff --git a/releasenotes/notes/fix-InstructionDurations-b47a9770b424d7a0.yaml b/releasenotes/notes/fix-InstructionDurations-b47a9770b424d7a0.yaml
new file mode 100644
index 000000000000..ce8b789462de
--- /dev/null
+++ b/releasenotes/notes/fix-InstructionDurations-b47a9770b424d7a0.yaml
@@ -0,0 +1,5 @@
+---
+fixes:
+  - |
+    Fixed a bug where :meth:`.InstructionDurations.from_backend` did not work for :class:`.BackendV2` backends.
+    Fixed `#12760 <https://github.com/Qiskit/qiskit/issues/12760>`.
\ No newline at end of file
diff --git a/test/python/transpiler/test_instruction_durations.py b/test/python/transpiler/test_instruction_durations.py
index de68fbadf86a..c59d0ff2a6cc 100644
--- a/test/python/transpiler/test_instruction_durations.py
+++ b/test/python/transpiler/test_instruction_durations.py
@@ -16,6 +16,7 @@
 
 from qiskit.circuit import Delay, Parameter
 from qiskit.providers.fake_provider import Fake27QPulseV1
+from qiskit.providers.fake_provider import GenericBackendV2
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.transpiler.instruction_durations import InstructionDurations
 from test import QiskitTestCase  # pylint: disable=wrong-import-order
@@ -92,3 +93,10 @@ def test_fail_if_get_unbounded_duration_with_unit_conversion_when_dt_is_not_prov
         parameterized_delay = Delay(param, "s")
         with self.assertRaises(TranspilerError):
             InstructionDurations().get(parameterized_delay, 0)
+
+    def test_from_backend_with_backendv2(self):
+        """Test if `from_backend()` method allows using BackendV2"""
+        backend = GenericBackendV2(num_qubits=4, calibrate_instructions=True, seed=42)
+        inst_durations = InstructionDurations.from_backend(backend)
+        self.assertEqual(inst_durations, backend.target.durations())
+        self.assertIsInstance(inst_durations, InstructionDurations)

From 6f482400e56345fe260d2144bf86acfd563855bc Mon Sep 17 00:00:00 2001
From: Luciano Bello <bel@zurich.ibm.com>
Date: Wed, 21 Aug 2024 17:35:29 +0200
Subject: [PATCH 15/85] qiskit.pulse.library.Square_fun.rst (#13007)

---
 qiskit/pulse/library/symbolic_pulses.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/qiskit/pulse/library/symbolic_pulses.py b/qiskit/pulse/library/symbolic_pulses.py
index 33d428771b22..b7ba658da1be 100644
--- a/qiskit/pulse/library/symbolic_pulses.py
+++ b/qiskit/pulse/library/symbolic_pulses.py
@@ -1773,12 +1773,13 @@ def Square(
     is the sign function with the convention :math:`\\text{sign}\\left(0\\right)=1`.
 
     Args:
-        duration: Pulse length in terms of the sampling period `dt`.
-        amp: The magnitude of the amplitude of the square wave. Wave range is [-`amp`,`amp`].
+        duration: Pulse length in terms of the sampling period ``dt``.
+        amp: The magnitude of the amplitude of the square wave. Wave range is
+            :math:`\\left[-\\texttt{amp},\\texttt{amp}\\right]`.
         phase: The phase of the square wave (note that this is not equivalent to the angle of
             the complex amplitude).
         freq: The frequency of the square wave, in terms of 1 over sampling period.
-            If not provided defaults to a single cycle (i.e :math:'\\frac{1}{\\text{duration}}').
+            If not provided defaults to a single cycle (i.e :math:`\\frac{1}{\\text{duration}}`).
             The frequency is limited to the range :math:`\\left(0,0.5\\right]` (the Nyquist frequency).
         angle: The angle in radians of the complex phase factor uniformly
             scaling the pulse. Default value 0.

From fb81116adcbfda6314594462edcac547b0875717 Mon Sep 17 00:00:00 2001
From: Alexander Ivrii <alexi@il.ibm.com>
Date: Thu, 22 Aug 2024 10:53:50 +0300
Subject: [PATCH 16/85] Operator equality with (clean) ancillas (#12968)

* initial commit

* making the function private; also adding ignore_phase arg

* applying review suggestions
---
 .../quantum_info/operators/operator_utils.py  | 76 +++++++++++++++++++
 .../quantum_info/operators/test_operator.py   | 24 ++++++
 2 files changed, 100 insertions(+)
 create mode 100644 qiskit/quantum_info/operators/operator_utils.py

diff --git a/qiskit/quantum_info/operators/operator_utils.py b/qiskit/quantum_info/operators/operator_utils.py
new file mode 100644
index 000000000000..092252df951f
--- /dev/null
+++ b/qiskit/quantum_info/operators/operator_utils.py
@@ -0,0 +1,76 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2024.
+#
+# 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.
+
+"""
+Additional utilities for Operators.
+"""
+
+from __future__ import annotations
+
+from qiskit.quantum_info import Operator
+from qiskit.quantum_info.operators.predicates import matrix_equal
+
+
+def _equal_with_ancillas(
+    op1: Operator,
+    op2: Operator,
+    ancilla_qubits: list[int],
+    ignore_phase: bool = False,
+    rtol: float | None = None,
+    atol: float | None = None,
+) -> bool:
+    r"""Test if two Operators are equal on the subspace where ancilla qubits
+    are :math:`|0\rangle`.
+
+    Args:
+        op1 (Operator): an operator object.
+        op2 (Operator): an operator object.
+        ancilla_qubits (list[int]): a list of clean ancilla qubits.
+        ignore_phase (bool): ignore complex-phase difference between matrices.
+        rtol (float): relative tolerance value for comparison.
+        atol (float): absolute tolerance value for comparison.
+
+    Returns:
+        bool: True iff operators are equal up to clean ancilla qubits.
+    """
+    if op1.dim != op2.dim:
+        return False
+
+    if atol is None:
+        atol = op1.atol
+    if rtol is None:
+        rtol = op1.rtol
+
+    num_qubits = op1._op_shape._num_qargs_l
+    num_non_ancillas = num_qubits - len(ancilla_qubits)
+
+    # Find a permutation that moves all ancilla qubits to the back
+    pattern = []
+    ancillas = []
+    for q in range(num_qubits):
+        if q not in ancilla_qubits:
+            pattern.append(q)
+        else:
+            ancillas.append(q)
+    pattern = pattern + ancillas
+
+    # Apply this permutation to both operators
+    permuted1 = op1.apply_permutation(pattern)
+    permuted2 = op2.apply_permutation(pattern)
+
+    # Restrict to the subspace where ancillas are 0
+    restricted1 = permuted1.data[: 2**num_non_ancillas, : 2**num_qubits]
+    restricted2 = permuted2.data[: 2**num_non_ancillas, : 2**num_qubits]
+
+    return matrix_equal(
+        restricted1, restricted2.data, ignore_phase=ignore_phase, rtol=rtol, atol=atol
+    )
diff --git a/test/python/quantum_info/operators/test_operator.py b/test/python/quantum_info/operators/test_operator.py
index d653d6182017..725c46576a9d 100644
--- a/test/python/quantum_info/operators/test_operator.py
+++ b/test/python/quantum_info/operators/test_operator.py
@@ -31,6 +31,7 @@
 from qiskit.transpiler.layout import Layout, TranspileLayout
 from qiskit.quantum_info.operators import Operator, ScalarOp
 from qiskit.quantum_info.operators.predicates import matrix_equal
+from qiskit.quantum_info.operators.operator_utils import _equal_with_ancillas
 from qiskit.compiler.transpiler import transpile
 from qiskit.circuit import Qubit
 from qiskit.circuit.library import Permutation, PermutationGate
@@ -1255,6 +1256,29 @@ def test_apply_permutation_dimensions(self):
         op2 = op.apply_permutation([2, 0, 1], front=True)
         self.assertEqual(op2.input_dims(), (4, 2, 3))
 
+    def test_equality_with_ancillas(self):
+        """Check correctness of the equal_with_ancillas method."""
+
+        # The two circuits below are equal provided that qubit 1 is initially |0>.
+        qc1 = QuantumCircuit(4)
+        qc1.x(0)
+        qc1.x(2)
+        qc1.cx(1, 0)
+        qc1.cx(1, 2)
+        qc1.cx(1, 3)
+        op1 = Operator(qc1)
+
+        qc2 = QuantumCircuit(4)
+        qc2.x(0)
+        qc2.x(2)
+        op2 = Operator(qc2)
+
+        self.assertNotEqual(op1, op2)
+        self.assertFalse(_equal_with_ancillas(op1, op2, []))
+        self.assertTrue(_equal_with_ancillas(op1, op2, [1]))
+        self.assertFalse(_equal_with_ancillas(op1, op2, [2]))
+        self.assertTrue(_equal_with_ancillas(op1, op2, [2, 1]))
+
 
 if __name__ == "__main__":
     unittest.main()

From 072548ff09cabfa8b9db8297926c5a609adde10b Mon Sep 17 00:00:00 2001
From: Alexander Ivrii <alexi@il.ibm.com>
Date: Thu, 22 Aug 2024 13:06:09 +0300
Subject: [PATCH 17/85] Adding MCX synthesis plugins (#12961)

* moving high-level-synthesis plugins to a separate file

* Adding the remaining MCX synthesis functions and exposting all of them as HLS synthesis plugins.

* adding entry points for MCX plugins

* adding documentation section for MCX plugins

* renaming file

* Adding pending deprecation warnings

* placeholder for MCX plugin tests

* adding flag pending=True to deprecate

* changing checks from isinstance to name-based: a CCCX gate is called mcx but is not an MCXGate

* futher exposing C3X and C4X synthesis

* updating MCX synthesis functions to avoid returning C3X and C4X gates

For better or for worse, C3X and C4X gates have name 'mcx', and
therefore are caught by mcx plugins. We need to avoid recursion
with HLS calling an MCX-synthesis plugin for a C3X-gate, which
in turns returns a C3X-gate.

* fix compose to append

* renaming synthesized circuits for c3x and for c4x back to 'mcx' to avoid qasm changes

* test qasm fixes

* randomly spotted typo

* fixing how QuantumCircuit.decompose works in the presence of gates_to_decompose

* updating MCX plugins to check isinstance

* fixing test

* pylint fixes

* properly fixing test

* additional tests

* adding new synthesis functions to synthesis docs

* release notes

* docstrings improvements followin review

* Adding refernce to Vale et al paper for the MCXPhase gate implementation

* fixes to deprecation warnings and adding deprecation for get_num_ancilla_qubits

* docstring fixes

* renaming mcphase to v24

* removing unncessary checks

* addressing the rest of review comments

* and of course updating qasm checking after we've slightly changed the decomposition

* yet another renaming

* Update qiskit/circuit/library/standard_gates/x.py

Co-authored-by: Julien Gacon <gaconju@gmail.com>

* Update qiskit/circuit/library/standard_gates/x.py

Co-authored-by: Julien Gacon <gaconju@gmail.com>

* Update releasenotes/notes/add-mcx-plugins-85e5b248692a36db.yaml

Co-authored-by: Julien Gacon <gaconju@gmail.com>

* release notes

* formatting

* fixing docs

* removing references from the first sentence of plugin descriptions

---------

Co-authored-by: Julien Gacon <gaconju@gmail.com>
---
 pyproject.toml                                |  40 +-
 qiskit/circuit/library/standard_gates/x.py    |  77 +-
 qiskit/circuit/quantumcircuit.py              |   9 +-
 qiskit/synthesis/__init__.py                  |  10 +-
 qiskit/synthesis/multi_controlled/__init__.py |   6 +-
 ...ith_ancillas_synth.py => mcx_synthesis.py} | 158 ++-
 .../passes/synthesis/high_level_synthesis.py  | 594 +----------
 .../passes/synthesis/hls_plugins.py           | 928 ++++++++++++++++++
 qiskit/transpiler/passes/synthesis/plugin.py  |   2 +-
 .../add-mcx-plugins-85e5b248692a36db.yaml     |  45 +
 test/python/circuit/test_circuit_qasm.py      |  16 +-
 test/python/qasm2/test_export.py              |  18 +-
 test/python/transpiler/test_decompose.py      |   2 +-
 .../transpiler/test_high_level_synthesis.py   | 174 +++-
 14 files changed, 1400 insertions(+), 679 deletions(-)
 rename qiskit/synthesis/multi_controlled/{mcx_with_ancillas_synth.py => mcx_synthesis.py} (66%)
 create mode 100644 qiskit/transpiler/passes/synthesis/hls_plugins.py
 create mode 100644 releasenotes/notes/add-mcx-plugins-85e5b248692a36db.yaml

diff --git a/pyproject.toml b/pyproject.toml
index b1f7b039e407..9a16fc6e0ac3 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -75,23 +75,29 @@ aqc = "qiskit.transpiler.passes.synthesis.aqc_plugin:AQCSynthesisPlugin"
 sk = "qiskit.transpiler.passes.synthesis.solovay_kitaev_synthesis:SolovayKitaevSynthesis"
 
 [project.entry-points."qiskit.synthesis"]
-"clifford.default" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisClifford"
-"clifford.ag" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:AGSynthesisClifford"
-"clifford.bm" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:BMSynthesisClifford"
-"clifford.greedy" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:GreedySynthesisClifford"
-"clifford.layers" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerSynthesisClifford"
-"clifford.lnn" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:LayerLnnSynthesisClifford"
-"linear_function.default" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:DefaultSynthesisLinearFunction"
-"linear_function.kms" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisLinearFunction"
-"linear_function.pmh" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:PMHSynthesisLinearFunction"
-"permutation.default" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation"
-"permutation.kms" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:KMSSynthesisPermutation"
-"permutation.basic" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:BasicSynthesisPermutation"
-"permutation.acg" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:ACGSynthesisPermutation"
-"qft.full" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:QFTSynthesisFull"
-"qft.line" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:QFTSynthesisLine"
-"qft.default" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:QFTSynthesisFull"
-"permutation.token_swapper" = "qiskit.transpiler.passes.synthesis.high_level_synthesis:TokenSwapperSynthesisPermutation"
+"clifford.default" = "qiskit.transpiler.passes.synthesis.hls_plugins:DefaultSynthesisClifford"
+"clifford.ag" = "qiskit.transpiler.passes.synthesis.hls_plugins:AGSynthesisClifford"
+"clifford.bm" = "qiskit.transpiler.passes.synthesis.hls_plugins:BMSynthesisClifford"
+"clifford.greedy" = "qiskit.transpiler.passes.synthesis.hls_plugins:GreedySynthesisClifford"
+"clifford.layers" = "qiskit.transpiler.passes.synthesis.hls_plugins:LayerSynthesisClifford"
+"clifford.lnn" = "qiskit.transpiler.passes.synthesis.hls_plugins:LayerLnnSynthesisClifford"
+"linear_function.default" = "qiskit.transpiler.passes.synthesis.hls_plugins:DefaultSynthesisLinearFunction"
+"linear_function.kms" = "qiskit.transpiler.passes.synthesis.hls_plugins:KMSSynthesisLinearFunction"
+"linear_function.pmh" = "qiskit.transpiler.passes.synthesis.hls_plugins:PMHSynthesisLinearFunction"
+"mcx.n_dirty_i15" = "qiskit.transpiler.passes.synthesis.hls_plugins:MCXSynthesisNDirtyI15"
+"mcx.n_clean_m15" = "qiskit.transpiler.passes.synthesis.hls_plugins:MCXSynthesisNCleanM15"
+"mcx.1_clean_b95" = "qiskit.transpiler.passes.synthesis.hls_plugins:MCXSynthesis1CleanB95"
+"mcx.gray_code" = "qiskit.transpiler.passes.synthesis.hls_plugins:MCXSynthesisGrayCode"
+"mcx.noaux_v24" = "qiskit.transpiler.passes.synthesis.hls_plugins:MCXSynthesisNoAuxV24"
+"mcx.default" = "qiskit.transpiler.passes.synthesis.hls_plugins:MCXSynthesisDefault"
+"permutation.default" = "qiskit.transpiler.passes.synthesis.hls_plugins:BasicSynthesisPermutation"
+"permutation.kms" = "qiskit.transpiler.passes.synthesis.hls_plugins:KMSSynthesisPermutation"
+"permutation.basic" = "qiskit.transpiler.passes.synthesis.hls_plugins:BasicSynthesisPermutation"
+"permutation.acg" = "qiskit.transpiler.passes.synthesis.hls_plugins:ACGSynthesisPermutation"
+"qft.full" = "qiskit.transpiler.passes.synthesis.hls_plugins:QFTSynthesisFull"
+"qft.line" = "qiskit.transpiler.passes.synthesis.hls_plugins:QFTSynthesisLine"
+"qft.default" = "qiskit.transpiler.passes.synthesis.hls_plugins:QFTSynthesisFull"
+"permutation.token_swapper" = "qiskit.transpiler.passes.synthesis.hls_plugins:TokenSwapperSynthesisPermutation"
 
 [project.entry-points."qiskit.transpiler.init"]
 default = "qiskit.transpiler.preset_passmanagers.builtin_plugins:DefaultInitPassManager"
diff --git a/qiskit/circuit/library/standard_gates/x.py b/qiskit/circuit/library/standard_gates/x.py
index 3ee5551b599d..f24c76c65d91 100644
--- a/qiskit/circuit/library/standard_gates/x.py
+++ b/qiskit/circuit/library/standard_gates/x.py
@@ -20,6 +20,7 @@
 from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit._utils import _ctrl_state_to_int, with_gate_array, with_controlled_gate_array
 from qiskit._accelerate.circuit import StandardGate
+from qiskit.utils.deprecation import deprecate_func
 
 _X_ARRAY = [[0, 1], [1, 0]]
 _SX_ARRAY = [[0.5 + 0.5j, 0.5 - 0.5j], [0.5 - 0.5j, 0.5 + 0.5j]]
@@ -1168,6 +1169,19 @@ def inverse(self, annotated: bool = False):
         return MCXGate(num_ctrl_qubits=self.num_ctrl_qubits, ctrl_state=self.ctrl_state)
 
     @staticmethod
+    @deprecate_func(
+        additional_msg=(
+            "For an MCXGate it is no longer possible to know the number of ancilla qubits "
+            "that would be eventually used by the transpiler when the gate is created. "
+            "Instead, it is recommended to use MCXGate and let HighLevelSynthesis choose "
+            "the best synthesis method depending on the number of ancilla qubits available. "
+            "However, if a specific synthesis method using a specific number of ancilla "
+            "qubits is require, one can create a custom gate by calling the corresponding "
+            "synthesis function directly."
+        ),
+        since="1.3",
+        pending=True,
+    )
     def get_num_ancilla_qubits(num_ctrl_qubits: int, mode: str = "noancilla") -> int:
         """Get the number of required ancilla qubits without instantiating the class.
 
@@ -1185,23 +1199,10 @@ def get_num_ancilla_qubits(num_ctrl_qubits: int, mode: str = "noancilla") -> int
     def _define(self):
         """This definition is based on MCPhaseGate implementation."""
         # pylint: disable=cyclic-import
-        from qiskit.circuit.quantumcircuit import QuantumCircuit
+        from qiskit.synthesis.multi_controlled import synth_mcx_noaux_v24
 
-        q = QuantumRegister(self.num_qubits, name="q")
-        qc = QuantumCircuit(q)
-        if self.num_qubits == 4:
-            qc._append(C3XGate(), q[:], [])
-            self.definition = qc
-        elif self.num_qubits == 5:
-            qc._append(C4XGate(), q[:], [])
-            self.definition = qc
-        else:
-            q_controls = list(range(self.num_ctrl_qubits))
-            q_target = self.num_ctrl_qubits
-            qc.h(q_target)
-            qc.mcp(numpy.pi, q_controls, q_target)
-            qc.h(q_target)
-            self.definition = qc
+        qc = synth_mcx_noaux_v24(self.num_ctrl_qubits)
+        self.definition = qc
 
     @property
     def num_ancilla_qubits(self):
@@ -1280,6 +1281,17 @@ def __new__(
             return gate
         return super().__new__(cls)
 
+    @deprecate_func(
+        additional_msg=(
+            "It is recommended to use MCXGate and let HighLevelSynthesis choose "
+            "the best synthesis method depending on the number of ancilla qubits available. "
+            "If this specific synthesis method is required, one can specify it using the "
+            "high-level-synthesis plugin `gray_code` for MCX gates, or, alternatively, "
+            "one can use synth_mcx_gray_code to construct the gate directly."
+        ),
+        since="1.3",
+        pending=True,
+    )
     def __init__(
         self,
         num_ctrl_qubits: int,
@@ -1305,15 +1317,9 @@ def inverse(self, annotated: bool = False):
     def _define(self):
         """Define the MCX gate using the Gray code."""
         # pylint: disable=cyclic-import
-        from qiskit.circuit.quantumcircuit import QuantumCircuit
-        from .u1 import MCU1Gate
-        from .h import HGate
+        from qiskit.synthesis.multi_controlled import synth_mcx_gray_code
 
-        q = QuantumRegister(self.num_qubits, name="q")
-        qc = QuantumCircuit(q, name=self.name)
-        qc._append(HGate(), [q[-1]], [])
-        qc._append(MCU1Gate(numpy.pi, num_ctrl_qubits=self.num_ctrl_qubits), q[:], [])
-        qc._append(HGate(), [q[-1]], [])
+        qc = synth_mcx_gray_code(self.num_ctrl_qubits)
         self.definition = qc
 
 
@@ -1330,6 +1336,17 @@ class MCXRecursive(MCXGate):
         2. Iten et al., 2015. https://arxiv.org/abs/1501.06911
     """
 
+    @deprecate_func(
+        additional_msg=(
+            "It is recommended to use MCXGate and let HighLevelSynthesis choose "
+            "the best synthesis method depending on the number of ancilla qubits available. "
+            "If this specific synthesis method is required, one can specify it using the "
+            "high-level-synthesis plugin '1_clean_b95' for MCX gates, or, alternatively, "
+            "one can use synth_mcx_1_clean to construct the gate directly."
+        ),
+        since="1.3",
+        pending=True,
+    )
     def __init__(
         self,
         num_ctrl_qubits: int,
@@ -1409,6 +1426,18 @@ def __new__(
             unit=unit,
         )
 
+    @deprecate_func(
+        additional_msg=(
+            "It is recommended to use MCXGate and let HighLevelSynthesis choose "
+            "the best synthesis method depending on the number of ancilla qubits available. "
+            "If this specific synthesis method is required, one can specify it using the "
+            "high-level-synthesis plugins `n_clean_m15` (using clean ancillas) or "
+            "`n_dirty_i15` (using dirty ancillas) for MCX gates. Alternatively, one can "
+            "use synth_mcx_n_dirty_i15 and synth_mcx_n_clean_m15 to construct the gate directly."
+        ),
+        since="1.3",
+        pending=True,
+    )
     def __init__(
         self,
         num_ctrl_qubits: int,
diff --git a/qiskit/circuit/quantumcircuit.py b/qiskit/circuit/quantumcircuit.py
index 9413141fb757..487f1e28e382 100644
--- a/qiskit/circuit/quantumcircuit.py
+++ b/qiskit/circuit/quantumcircuit.py
@@ -3212,10 +3212,17 @@ def decompose(
         from qiskit.converters.dag_to_circuit import dag_to_circuit
 
         dag = circuit_to_dag(self, copy_operations=True)
-        dag = HighLevelSynthesis().run(dag)
+
+        if gates_to_decompose is None:
+            # We should not rewrite the circuit using HLS when we have gates_to_decompose,
+            # or else HLS will rewrite all objects with available plugins (e.g., Cliffords,
+            # PermutationGates, and now also MCXGates)
+            dag = HighLevelSynthesis().run(dag)
+
         pass_ = Decompose(gates_to_decompose)
         for _ in range(reps):
             dag = pass_.run(dag)
+
         # do not copy operations, this is done in the conversion with circuit_to_dag
         return dag_to_circuit(dag, copy_operations=False)
 
diff --git a/qiskit/synthesis/__init__.py b/qiskit/synthesis/__init__.py
index f1d1e3b28359..b2a92ee7caf5 100644
--- a/qiskit/synthesis/__init__.py
+++ b/qiskit/synthesis/__init__.py
@@ -128,6 +128,10 @@
 .. autofunction:: synth_mcx_n_dirty_i15
 .. autofunction:: synth_mcx_n_clean_m15
 .. autofunction:: synth_mcx_1_clean_b95
+.. autofunction:: synth_mcx_noaux_v24
+.. autofunction:: synth_mcx_gray_code
+.. autofunction:: synth_c3x
+.. autofunction:: synth_c4x
 
 """
 
@@ -180,8 +184,12 @@
     two_qubit_cnot_decompose,
     TwoQubitWeylDecomposition,
 )
-from .multi_controlled.mcx_with_ancillas_synth import (
+from .multi_controlled import (
     synth_mcx_n_dirty_i15,
     synth_mcx_n_clean_m15,
     synth_mcx_1_clean_b95,
+    synth_mcx_noaux_v24,
+    synth_mcx_gray_code,
+    synth_c3x,
+    synth_c4x,
 )
diff --git a/qiskit/synthesis/multi_controlled/__init__.py b/qiskit/synthesis/multi_controlled/__init__.py
index 0c04823a537a..84ec17c355e4 100644
--- a/qiskit/synthesis/multi_controlled/__init__.py
+++ b/qiskit/synthesis/multi_controlled/__init__.py
@@ -12,8 +12,12 @@
 
 """Module containing multi-controlled circuits synthesis"""
 
-from .mcx_with_ancillas_synth import (
+from .mcx_synthesis import (
     synth_mcx_n_dirty_i15,
     synth_mcx_n_clean_m15,
     synth_mcx_1_clean_b95,
+    synth_mcx_gray_code,
+    synth_mcx_noaux_v24,
+    synth_c3x,
+    synth_c4x,
 )
diff --git a/qiskit/synthesis/multi_controlled/mcx_with_ancillas_synth.py b/qiskit/synthesis/multi_controlled/mcx_synthesis.py
similarity index 66%
rename from qiskit/synthesis/multi_controlled/mcx_with_ancillas_synth.py
rename to qiskit/synthesis/multi_controlled/mcx_synthesis.py
index cf2325764569..10680f0fee88 100644
--- a/qiskit/synthesis/multi_controlled/mcx_with_ancillas_synth.py
+++ b/qiskit/synthesis/multi_controlled/mcx_synthesis.py
@@ -10,20 +10,28 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""Module containing multi-controlled circuits synthesis with ancillary qubits."""
+"""Module containing multi-controlled circuits synthesis with and without ancillary qubits."""
 
 from math import ceil
+import numpy as np
+
 from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.library.standard_gates.x import C3XGate, C4XGate
+from qiskit.circuit.library.standard_gates import (
+    HGate,
+    MCU1Gate,
+    CU1Gate,
+    RC3XGate,
+    C3SXGate,
+)
 
 
 def synth_mcx_n_dirty_i15(
     num_ctrl_qubits: int,
     relative_phase: bool = False,
     action_only: bool = False,
-):
-    """
+) -> QuantumCircuit:
+    r"""
     Synthesize a multi-controlled X gate with :math:`k` controls using :math:`k - 2`
     dirty ancillary qubits producing a circuit with :math:`2 * k - 1` qubits and at most
     :math:`8 * k - 6` CX gates, by Iten et. al. [1].
@@ -59,7 +67,8 @@ def synth_mcx_n_dirty_i15(
         qc.ccx(q_controls[0], q_controls[1], q_target)
         return qc
     elif not relative_phase and num_ctrl_qubits == 3:
-        qc._append(C3XGate(), [*q_controls, q_target], [])
+        circuit = synth_c3x()
+        qc.compose(circuit, [*q_controls, q_target], inplace=True, copy=False)
         return qc
 
     num_ancillas = num_ctrl_qubits - 2
@@ -122,8 +131,8 @@ def synth_mcx_n_dirty_i15(
     return qc
 
 
-def synth_mcx_n_clean_m15(num_ctrl_qubits: int):
-    """
+def synth_mcx_n_clean_m15(num_ctrl_qubits: int) -> QuantumCircuit:
+    r"""
     Synthesize a multi-controlled X gate with :math:`k` controls using :math:`k - 2`
     clean ancillary qubits with producing a circuit with :math:`2 * k - 1` qubits
     and at most :math:`6 * k - 6` CX gates, by Maslov [1].
@@ -165,8 +174,8 @@ def synth_mcx_n_clean_m15(num_ctrl_qubits: int):
     return qc
 
 
-def synth_mcx_1_clean_b95(num_ctrl_qubits: int):
-    """
+def synth_mcx_1_clean_b95(num_ctrl_qubits: int) -> QuantumCircuit:
+    r"""
     Synthesize a multi-controlled X gate with :math:`k` controls using a single
     clean ancillary qubit producing a circuit with :math:`k + 2` qubits and at most
     :math:`16 * k - 8` CX gates, by Barenco et al. [1].
@@ -183,16 +192,10 @@ def synth_mcx_1_clean_b95(num_ctrl_qubits: int):
     """
 
     if num_ctrl_qubits == 3:
-        q = QuantumRegister(4, name="q")
-        qc = QuantumCircuit(q, name="mcx")
-        qc._append(C3XGate(), q[:], [])
-        return qc
+        return synth_c3x()
 
     elif num_ctrl_qubits == 4:
-        q = QuantumRegister(5, name="q")
-        qc = QuantumCircuit(q, name="mcx")
-        qc._append(C4XGate(), q[:], [])
-        return qc
+        return synth_c4x()
 
     num_qubits = num_ctrl_qubits + 2
     q = QuantumRegister(num_qubits, name="q")
@@ -230,3 +233,124 @@ def synth_mcx_1_clean_b95(num_ctrl_qubits: int):
     )
 
     return qc
+
+
+def synth_mcx_gray_code(num_ctrl_qubits: int) -> QuantumCircuit:
+    r"""
+    Synthesize a multi-controlled X gate with :math:`k` controls using the Gray code.
+
+    Produces a quantum circuit with :math:`k + 1` qubits. This method
+    produces exponentially many CX gates and should be used only for small
+    values of :math:`k`.
+
+    Args:
+        num_ctrl_qubits: The number of control qubits.
+
+    Returns:
+        The synthesized quantum circuit.
+    """
+    num_qubits = num_ctrl_qubits + 1
+    q = QuantumRegister(num_qubits, name="q")
+    qc = QuantumCircuit(q, name="mcx_gray")
+    qc._append(HGate(), [q[-1]], [])
+    qc._append(MCU1Gate(np.pi, num_ctrl_qubits=num_ctrl_qubits), q[:], [])
+    qc._append(HGate(), [q[-1]], [])
+    return qc
+
+
+def synth_mcx_noaux_v24(num_ctrl_qubits: int) -> QuantumCircuit:
+    r"""
+    Synthesize a multi-controlled X gate with :math:`k` controls based on
+    the implementation for MCPhaseGate.
+
+    In turn, the MCPhase gate uses the decomposition for multi-controlled
+    special unitaries described in [1].
+
+    Produces a quantum circuit with :math:`k + 1` qubits.
+    The number of CX-gates is quadratic in :math:`k`.
+
+    Args:
+        num_ctrl_qubits: The number of control qubits.
+
+    Returns:
+        The synthesized quantum circuit.
+
+    References:
+        1. Vale et. al., *Circuit Decomposition of Multicontrolled Special Unitary
+           Single-Qubit Gates*, IEEE TCAD 43(3) (2024),
+           `arXiv:2302.06377 <https://arxiv.org/abs/2302.06377>`_
+    """
+    if num_ctrl_qubits == 3:
+        return synth_c3x()
+
+    if num_ctrl_qubits == 4:
+        return synth_c4x()
+
+    num_qubits = num_ctrl_qubits + 1
+    q = QuantumRegister(num_qubits, name="q")
+    qc = QuantumCircuit(q)
+    q_controls = list(range(num_ctrl_qubits))
+    q_target = num_ctrl_qubits
+    qc.h(q_target)
+    qc.mcp(np.pi, q_controls, q_target)
+    qc.h(q_target)
+    return qc
+
+
+def synth_c3x() -> QuantumCircuit:
+    """Efficient synthesis of 3-controlled X-gate."""
+
+    q = QuantumRegister(4, name="q")
+    qc = QuantumCircuit(q, name="mcx")
+    qc.h(3)
+    qc.p(np.pi / 8, [0, 1, 2, 3])
+    qc.cx(0, 1)
+    qc.p(-np.pi / 8, 1)
+    qc.cx(0, 1)
+    qc.cx(1, 2)
+    qc.p(-np.pi / 8, 2)
+    qc.cx(0, 2)
+    qc.p(np.pi / 8, 2)
+    qc.cx(1, 2)
+    qc.p(-np.pi / 8, 2)
+    qc.cx(0, 2)
+    qc.cx(2, 3)
+    qc.p(-np.pi / 8, 3)
+    qc.cx(1, 3)
+    qc.p(np.pi / 8, 3)
+    qc.cx(2, 3)
+    qc.p(-np.pi / 8, 3)
+    qc.cx(0, 3)
+    qc.p(np.pi / 8, 3)
+    qc.cx(2, 3)
+    qc.p(-np.pi / 8, 3)
+    qc.cx(1, 3)
+    qc.p(np.pi / 8, 3)
+    qc.cx(2, 3)
+    qc.p(-np.pi / 8, 3)
+    qc.cx(0, 3)
+    qc.h(3)
+    return qc
+
+
+def synth_c4x() -> QuantumCircuit:
+    """Efficient synthesis of 4-controlled X-gate."""
+
+    q = QuantumRegister(5, name="q")
+    qc = QuantumCircuit(q, name="mcx")
+
+    rules = [
+        (HGate(), [q[4]], []),
+        (CU1Gate(np.pi / 2), [q[3], q[4]], []),
+        (HGate(), [q[4]], []),
+        (RC3XGate(), [q[0], q[1], q[2], q[3]], []),
+        (HGate(), [q[4]], []),
+        (CU1Gate(-np.pi / 2), [q[3], q[4]], []),
+        (HGate(), [q[4]], []),
+        (RC3XGate().inverse(), [q[0], q[1], q[2], q[3]], []),
+        (C3SXGate(), [q[0], q[1], q[2], q[4]], []),
+    ]
+    for instr, qargs, cargs in rules:
+        qc._append(instr, qargs, cargs)
+
+    return qc
diff --git a/qiskit/transpiler/passes/synthesis/high_level_synthesis.py b/qiskit/transpiler/passes/synthesis/high_level_synthesis.py
index 247898182cba..38c46547b12d 100644
--- a/qiskit/transpiler/passes/synthesis/high_level_synthesis.py
+++ b/qiskit/transpiler/passes/synthesis/high_level_synthesis.py
@@ -10,153 +10,8 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-
 """
-
-High Level Synthesis Plugins
------------------------------
-
-Clifford Synthesis
-''''''''''''''''''
-
-.. list-table:: Plugins for :class:`qiskit.quantum_info.Clifford` (key = ``"clifford"``)
-    :header-rows: 1
-
-    * - Plugin name
-      - Plugin class
-      - Targeted connectivity
-      - Description
-    * - ``"ag"``
-      - :class:`~.AGSynthesisClifford`
-      - all-to-all
-      - greedily optimizes CX-count
-    * - ``"bm"``
-      - :class:`~.BMSynthesisClifford`
-      - all-to-all
-      - optimal count for `n=2,3`; used in ``"default"`` for `n=2,3`
-    * - ``"greedy"``
-      - :class:`~.GreedySynthesisClifford`
-      - all-to-all
-      - greedily optimizes CX-count; used in ``"default"`` for `n>=4`
-    * - ``"layers"``
-      - :class:`~.LayerSynthesisClifford`
-      - all-to-all
-      -
-    * - ``"lnn"``
-      - :class:`~.LayerLnnSynthesisClifford`
-      - linear
-      - many CX-gates but guarantees CX-depth of at most `7*n+2`
-    * - ``"default"``
-      - :class:`~.DefaultSynthesisClifford`
-      - all-to-all
-      - usually best for optimizing CX-count (and optimal CX-count for `n=2,3`)
-
-.. autosummary::
-   :toctree: ../stubs/
-
-   AGSynthesisClifford
-   BMSynthesisClifford
-   GreedySynthesisClifford
-   LayerSynthesisClifford
-   LayerLnnSynthesisClifford
-   DefaultSynthesisClifford
-
-
-Linear Function Synthesis
-'''''''''''''''''''''''''
-
-.. list-table:: Plugins for :class:`.LinearFunction` (key = ``"linear"``)
-    :header-rows: 1
-
-    * - Plugin name
-      - Plugin class
-      - Targeted connectivity
-      - Description
-    * - ``"kms"``
-      - :class:`~.KMSSynthesisLinearFunction`
-      - linear
-      - many CX-gates but guarantees CX-depth of at most `5*n`
-    * - ``"pmh"``
-      - :class:`~.PMHSynthesisLinearFunction`
-      - all-to-all
-      - greedily optimizes CX-count; used in ``"default"``
-    * - ``"default"``
-      - :class:`~.DefaultSynthesisLinearFunction`
-      - all-to-all
-      - best for optimizing CX-count
-
-.. autosummary::
-   :toctree: ../stubs/
-
-   KMSSynthesisLinearFunction
-   PMHSynthesisLinearFunction
-   DefaultSynthesisLinearFunction
-
-
-Permutation Synthesis
-'''''''''''''''''''''
-
-.. list-table:: Plugins for :class:`.PermutationGate` (key = ``"permutation"``)
-    :header-rows: 1
-
-    * - Plugin name
-      - Plugin class
-      - Targeted connectivity
-      - Description
-    * - ``"basic"``
-      - :class:`~.BasicSynthesisPermutation`
-      - all-to-all
-      - optimal SWAP-count; used in ``"default"``
-    * - ``"acg"``
-      - :class:`~.ACGSynthesisPermutation`
-      - all-to-all
-      - guarantees SWAP-depth of at most `2`
-    * - ``"kms"``
-      - :class:`~.KMSSynthesisPermutation`
-      - linear
-      - many SWAP-gates, but guarantees SWAP-depth of at most `n`
-    * - ``"token_swapper"``
-      - :class:`~.TokenSwapperSynthesisPermutation`
-      - any
-      - greedily optimizes SWAP-count for arbitrary connectivity
-    * - ``"default"``
-      - :class:`~.BasicSynthesisPermutation`
-      - all-to-all
-      - best for optimizing SWAP-count
-
-.. autosummary::
-   :toctree: ../stubs/
-
-   BasicSynthesisPermutation
-   ACGSynthesisPermutation
-   KMSSynthesisPermutation
-   TokenSwapperSynthesisPermutation
-
-
-QFT Synthesis
-'''''''''''''
-
-.. list-table:: Plugins for :class:`.QFTGate` (key = ``"qft"``)
-    :header-rows: 1
-
-    * - Plugin name
-      - Plugin class
-      - Targeted connectivity
-    * - ``"full"``
-      - :class:`~.QFTSynthesisFull`
-      - all-to-all
-    * - ``"line"``
-      - :class:`~.QFTSynthesisLine`
-      - linear
-    * - ``"default"``
-      - :class:`~.QFTSynthesisFull`
-      - all-to-all
-
-.. autosummary::
-   :toctree: ../stubs/
-
-   QFTSynthesisFull
-   QFTSynthesisLine
+High-level-synthesis transpiler pass.
 """
 
 from __future__ import annotations
@@ -166,7 +21,6 @@
 from collections.abc import Callable
 
 import numpy as np
-import rustworkx as rx
 
 from qiskit.circuit.annotated_operation import Modifier
 from qiskit.circuit.operation import Operation
@@ -175,13 +29,11 @@
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit import ControlledGate, EquivalenceLibrary, equivalence
-from qiskit.circuit.library import LinearFunction
 from qiskit.transpiler.passes.utils import control_flow
 from qiskit.transpiler.target import Target
 from qiskit.transpiler.coupling import CouplingMap
 from qiskit.dagcircuit.dagcircuit import DAGCircuit
 from qiskit.transpiler.exceptions import TranspilerError
-from qiskit.transpiler.passes.routing.algorithms import ApproximateTokenSwapper
 
 from qiskit.circuit.annotated_operation import (
     AnnotatedOperation,
@@ -189,32 +41,8 @@
     ControlModifier,
     PowerModifier,
 )
-from qiskit.circuit.library import QFTGate
-from qiskit.synthesis.clifford import (
-    synth_clifford_full,
-    synth_clifford_layers,
-    synth_clifford_depth_lnn,
-    synth_clifford_greedy,
-    synth_clifford_ag,
-    synth_clifford_bm,
-)
-from qiskit.synthesis.linear import (
-    synth_cnot_count_full_pmh,
-    synth_cnot_depth_line_kms,
-    calc_inverse_matrix,
-)
-from qiskit.synthesis.linear.linear_circuits_utils import transpose_cx_circ
-from qiskit.synthesis.permutation import (
-    synth_permutation_basic,
-    synth_permutation_acg,
-    synth_permutation_depth_lnn_kms,
-)
-from qiskit.synthesis.qft import (
-    synth_qft_full,
-    synth_qft_line,
-)
 
-from .plugin import HighLevelSynthesisPluginManager, HighLevelSynthesisPlugin
+from .plugin import HighLevelSynthesisPluginManager
 from .qubit_tracker import QubitTracker
 
 if typing.TYPE_CHECKING:
@@ -838,424 +666,6 @@ def _instruction_supported(self, name: str, qubits: tuple[int] | None) -> bool:
         return self._target.instruction_supported(operation_name=name, qargs=qubits)
 
 
-class DefaultSynthesisClifford(HighLevelSynthesisPlugin):
-    """The default clifford synthesis plugin.
-
-    For N <= 3 qubits this is the optimal CX cost decomposition by Bravyi, Maslov.
-    For N > 3 qubits this is done using the general non-optimal greedy compilation
-    routine from reference by Bravyi, Hu, Maslov, Shaydulin.
-
-    This plugin name is :``clifford.default`` which can be used as the key on
-    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
-    """
-
-    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
-        """Run synthesis for the given Clifford."""
-        decomposition = synth_clifford_full(high_level_object)
-        return decomposition
-
-
-class AGSynthesisClifford(HighLevelSynthesisPlugin):
-    """Clifford synthesis plugin based on the Aaronson-Gottesman method.
-
-    This plugin name is :``clifford.ag`` which can be used as the key on
-    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
-    """
-
-    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
-        """Run synthesis for the given Clifford."""
-        decomposition = synth_clifford_ag(high_level_object)
-        return decomposition
-
-
-class BMSynthesisClifford(HighLevelSynthesisPlugin):
-    """Clifford synthesis plugin based on the Bravyi-Maslov method.
-
-    The method only works on Cliffords with at most 3 qubits, for which it
-    constructs the optimal CX cost decomposition.
-
-    This plugin name is :``clifford.bm`` which can be used as the key on
-    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
-    """
-
-    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
-        """Run synthesis for the given Clifford."""
-        if high_level_object.num_qubits <= 3:
-            decomposition = synth_clifford_bm(high_level_object)
-        else:
-            decomposition = None
-        return decomposition
-
-
-class GreedySynthesisClifford(HighLevelSynthesisPlugin):
-    """Clifford synthesis plugin based on the greedy synthesis
-    Bravyi-Hu-Maslov-Shaydulin method.
-
-    This plugin name is :``clifford.greedy`` which can be used as the key on
-    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
-    """
-
-    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
-        """Run synthesis for the given Clifford."""
-        decomposition = synth_clifford_greedy(high_level_object)
-        return decomposition
-
-
-class LayerSynthesisClifford(HighLevelSynthesisPlugin):
-    """Clifford synthesis plugin based on the Bravyi-Maslov method
-    to synthesize Cliffords into layers.
-
-    This plugin name is :``clifford.layers`` which can be used as the key on
-    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
-    """
-
-    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
-        """Run synthesis for the given Clifford."""
-        decomposition = synth_clifford_layers(high_level_object)
-        return decomposition
-
-
-class LayerLnnSynthesisClifford(HighLevelSynthesisPlugin):
-    """Clifford synthesis plugin based on the Bravyi-Maslov method
-    to synthesize Cliffords into layers, with each layer synthesized
-    adhering to LNN connectivity.
-
-    This plugin name is :``clifford.lnn`` which can be used as the key on
-    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
-    """
-
-    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
-        """Run synthesis for the given Clifford."""
-        decomposition = synth_clifford_depth_lnn(high_level_object)
-        return decomposition
-
-
-class DefaultSynthesisLinearFunction(HighLevelSynthesisPlugin):
-    """The default linear function synthesis plugin.
-
-    This plugin name is :``linear_function.default`` which can be used as the key on
-    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
-    """
-
-    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
-        """Run synthesis for the given LinearFunction."""
-        decomposition = synth_cnot_count_full_pmh(high_level_object.linear)
-        return decomposition
-
-
-class KMSSynthesisLinearFunction(HighLevelSynthesisPlugin):
-    """Linear function synthesis plugin based on the Kutin-Moulton-Smithline method.
-
-    This plugin name is :``linear_function.kms`` which can be used as the key on
-    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
-
-    The plugin supports the following plugin-specific options:
-
-    * use_inverted: Indicates whether to run the algorithm on the inverse matrix
-        and to invert the synthesized circuit.
-        In certain cases this provides a better decomposition than the direct approach.
-    * use_transposed: Indicates whether to run the algorithm on the transposed matrix
-        and to invert the order of CX gates in the synthesized circuit.
-        In certain cases this provides a better decomposition than the direct approach.
-
-    """
-
-    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
-        """Run synthesis for the given LinearFunction."""
-
-        if not isinstance(high_level_object, LinearFunction):
-            raise TranspilerError(
-                "PMHSynthesisLinearFunction only accepts objects of type LinearFunction"
-            )
-
-        use_inverted = options.get("use_inverted", False)
-        use_transposed = options.get("use_transposed", False)
-
-        mat = high_level_object.linear.astype(bool, copy=False)
-
-        if use_transposed:
-            mat = np.transpose(mat)
-        if use_inverted:
-            mat = calc_inverse_matrix(mat)
-
-        decomposition = synth_cnot_depth_line_kms(mat)
-
-        if use_transposed:
-            decomposition = transpose_cx_circ(decomposition)
-        if use_inverted:
-            decomposition = decomposition.inverse()
-
-        return decomposition
-
-
-class PMHSynthesisLinearFunction(HighLevelSynthesisPlugin):
-    """Linear function synthesis plugin based on the Patel-Markov-Hayes method.
-
-    This plugin name is :``linear_function.pmh`` which can be used as the key on
-    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
-
-    The plugin supports the following plugin-specific options:
-
-    * section size: The size of each section used in the Patel–Markov–Hayes algorithm [1].
-    * use_inverted: Indicates whether to run the algorithm on the inverse matrix
-        and to invert the synthesized circuit.
-        In certain cases this provides a better decomposition than the direct approach.
-    * use_transposed: Indicates whether to run the algorithm on the transposed matrix
-        and to invert the order of CX gates in the synthesized circuit.
-        In certain cases this provides a better decomposition than the direct approach.
-
-    References:
-        1. Patel, Ketan N., Igor L. Markov, and John P. Hayes,
-           *Optimal synthesis of linear reversible circuits*,
-           Quantum Information & Computation 8.3 (2008): 282-294.
-           `arXiv:quant-ph/0302002 [quant-ph] <https://arxiv.org/abs/quant-ph/0302002>`_
-    """
-
-    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
-        """Run synthesis for the given LinearFunction."""
-
-        if not isinstance(high_level_object, LinearFunction):
-            raise TranspilerError(
-                "PMHSynthesisLinearFunction only accepts objects of type LinearFunction"
-            )
-
-        section_size = options.get("section_size", 2)
-        use_inverted = options.get("use_inverted", False)
-        use_transposed = options.get("use_transposed", False)
-
-        mat = high_level_object.linear.astype(bool, copy=False)
-
-        if use_transposed:
-            mat = np.transpose(mat)
-        if use_inverted:
-            mat = calc_inverse_matrix(mat)
-
-        decomposition = synth_cnot_count_full_pmh(mat, section_size=section_size)
-
-        if use_transposed:
-            decomposition = transpose_cx_circ(decomposition)
-        if use_inverted:
-            decomposition = decomposition.inverse()
-
-        return decomposition
-
-
-class KMSSynthesisPermutation(HighLevelSynthesisPlugin):
-    """The permutation synthesis plugin based on the Kutin, Moulton, Smithline method.
-
-    This plugin name is :``permutation.kms`` which can be used as the key on
-    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
-    """
-
-    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
-        """Run synthesis for the given Permutation."""
-        decomposition = synth_permutation_depth_lnn_kms(high_level_object.pattern)
-        return decomposition
-
-
-class BasicSynthesisPermutation(HighLevelSynthesisPlugin):
-    """The permutation synthesis plugin based on sorting.
-
-    This plugin name is :``permutation.basic`` which can be used as the key on
-    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
-    """
-
-    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
-        """Run synthesis for the given Permutation."""
-        decomposition = synth_permutation_basic(high_level_object.pattern)
-        return decomposition
-
-
-class ACGSynthesisPermutation(HighLevelSynthesisPlugin):
-    """The permutation synthesis plugin based on the Alon, Chung, Graham method.
-
-    This plugin name is :``permutation.acg`` which can be used as the key on
-    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
-    """
-
-    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
-        """Run synthesis for the given Permutation."""
-        decomposition = synth_permutation_acg(high_level_object.pattern)
-        return decomposition
-
-
-class QFTSynthesisFull(HighLevelSynthesisPlugin):
-    """Synthesis plugin for QFT gates using all-to-all connectivity.
-
-    This plugin name is :``qft.full`` which can be used as the key on
-    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
-
-    The plugin supports the following additional options:
-
-    * reverse_qubits (bool): Whether to synthesize the "QFT" operation (if ``False``,
-        which is the default) or the "QFT-with-reversal" operation (if ``True``).
-        Some implementation of the ``QFTGate`` include a layer of swap gates at the end
-        of the synthesized circuit, which can in principle be dropped if the ``QFTGate``
-        itself is the last gate in the circuit.
-    * approximation_degree (int): The degree of approximation (0 for no approximation).
-        It is possible to implement the QFT approximately by ignoring
-        controlled-phase rotations with the angle beneath a threshold. This is discussed
-        in more detail in [1] or [2].
-    * insert_barriers (bool): If True, barriers are inserted as visualization improvement.
-    * inverse (bool): If True, the inverse Fourier transform is constructed.
-    * name (str): The name of the circuit.
-
-    References:
-        1. Adriano Barenco, Artur Ekert, Kalle-Antti Suominen, and Päivi Törmä,
-           *Approximate Quantum Fourier Transform and Decoherence*,
-           Physical Review A (1996).
-           `arXiv:quant-ph/9601018 [quant-ph] <https://arxiv.org/abs/quant-ph/9601018>`_
-        2. Donny Cheung,
-           *Improved Bounds for the Approximate QFT* (2004),
-           `arXiv:quant-ph/0403071 [quant-ph] <https://https://arxiv.org/abs/quant-ph/0403071>`_
-    """
-
-    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
-        """Run synthesis for the given QFTGate."""
-        if not isinstance(high_level_object, QFTGate):
-            raise TranspilerError(
-                "The synthesis plugin 'qft.full` only applies to objects of type QFTGate."
-            )
-
-        reverse_qubits = options.get("reverse_qubits", False)
-        approximation_degree = options.get("approximation_degree", 0)
-        insert_barriers = options.get("insert_barriers", False)
-        inverse = options.get("inverse", False)
-        name = options.get("name", None)
-
-        decomposition = synth_qft_full(
-            num_qubits=high_level_object.num_qubits,
-            do_swaps=not reverse_qubits,
-            approximation_degree=approximation_degree,
-            insert_barriers=insert_barriers,
-            inverse=inverse,
-            name=name,
-        )
-        return decomposition
-
-
-class QFTSynthesisLine(HighLevelSynthesisPlugin):
-    """Synthesis plugin for QFT gates using linear connectivity.
-
-    This plugin name is :``qft.line`` which can be used as the key on
-    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
-
-    The plugin supports the following additional options:
-
-    * reverse_qubits (bool): Whether to synthesize the "QFT" operation (if ``False``,
-        which is the default) or the "QFT-with-reversal" operation (if ``True``).
-        Some implementation of the ``QFTGate`` include a layer of swap gates at the end
-        of the synthesized circuit, which can in principle be dropped if the ``QFTGate``
-        itself is the last gate in the circuit.
-    * approximation_degree (int): the degree of approximation (0 for no approximation).
-        It is possible to implement the QFT approximately by ignoring
-        controlled-phase rotations with the angle beneath a threshold. This is discussed
-        in more detail in [1] or [2].
-
-    References:
-        1. Adriano Barenco, Artur Ekert, Kalle-Antti Suominen, and Päivi Törmä,
-           *Approximate Quantum Fourier Transform and Decoherence*,
-           Physical Review A (1996).
-           `arXiv:quant-ph/9601018 [quant-ph] <https://arxiv.org/abs/quant-ph/9601018>`_
-        2. Donny Cheung,
-           *Improved Bounds for the Approximate QFT* (2004),
-           `arXiv:quant-ph/0403071 [quant-ph] <https://https://arxiv.org/abs/quant-ph/0403071>`_
-    """
-
-    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
-        """Run synthesis for the given QFTGate."""
-        if not isinstance(high_level_object, QFTGate):
-            raise TranspilerError(
-                "The synthesis plugin 'qft.line` only applies to objects of type QFTGate."
-            )
-
-        reverse_qubits = options.get("reverse_qubits", False)
-        approximation_degree = options.get("approximation_degree", 0)
-
-        decomposition = synth_qft_line(
-            num_qubits=high_level_object.num_qubits,
-            do_swaps=not reverse_qubits,
-            approximation_degree=approximation_degree,
-        )
-        return decomposition
-
-
-class TokenSwapperSynthesisPermutation(HighLevelSynthesisPlugin):
-    """The permutation synthesis plugin based on the token swapper algorithm.
-
-    This plugin name is :``permutation.token_swapper`` which can be used as the key on
-    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
-
-    In more detail, this plugin is used to synthesize objects of type `PermutationGate`.
-    When synthesis succeeds, the plugin outputs a quantum circuit consisting only of swap
-    gates. When synthesis does not succeed, the plugin outputs `None`.
-
-    If either `coupling_map` or `qubits` is None, then the synthesized circuit
-    is not required to adhere to connectivity constraints, as is the case
-    when the synthesis is done before layout/routing.
-
-    On the other hand, if both `coupling_map` and `qubits` are specified, the synthesized
-    circuit is supposed to adhere to connectivity constraints. At the moment, the
-    plugin only creates swap gates between qubits in `qubits`, i.e. it does not use
-    any other qubits in the coupling map (if such synthesis is not possible, the
-    plugin  outputs `None`).
-
-    The plugin supports the following plugin-specific options:
-
-    * trials: The number of trials for the token swapper to perform the mapping. The
-      circuit with the smallest number of SWAPs is returned.
-    * seed: The argument to the token swapper specifying the seed for random trials.
-    * parallel_threshold: The argument to the token swapper specifying the number of nodes
-      in the graph beyond which the algorithm will use parallel processing.
-
-    For more details on the token swapper algorithm, see to the paper:
-    `arXiv:1902.09102 <https://arxiv.org/abs/1902.09102>`__.
-    """
-
-    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
-        """Run synthesis for the given Permutation."""
-
-        trials = options.get("trials", 5)
-        seed = options.get("seed", 0)
-        parallel_threshold = options.get("parallel_threshold", 50)
-
-        pattern = high_level_object.pattern
-        pattern_as_dict = {j: i for i, j in enumerate(pattern)}
-
-        # When the plugin is called from the HighLevelSynthesis transpiler pass,
-        # the coupling map already takes target into account.
-        if coupling_map is None or qubits is None:
-            # The abstract synthesis uses a fully connected coupling map, allowing
-            # arbitrary connections between qubits.
-            used_coupling_map = CouplingMap.from_full(len(pattern))
-        else:
-            # The concrete synthesis uses the coupling map restricted to the set of
-            # qubits over which the permutation gate is defined. If we allow using other
-            # qubits in the coupling map, replacing the node in the DAGCircuit that
-            # defines this PermutationGate by the DAG corresponding to the constructed
-            # decomposition becomes problematic. Note that we allow the reduced
-            # coupling map to be disconnected.
-            used_coupling_map = coupling_map.reduce(qubits, check_if_connected=False)
-
-        graph = used_coupling_map.graph.to_undirected()
-        swapper = ApproximateTokenSwapper(graph, seed=seed)
-
-        try:
-            swapper_result = swapper.map(
-                pattern_as_dict, trials, parallel_threshold=parallel_threshold
-            )
-        except rx.InvalidMapping:
-            swapper_result = None
-
-        if swapper_result is not None:
-            decomposition = QuantumCircuit(len(graph.node_indices()))
-            for swap in swapper_result:
-                decomposition.swap(*swap)
-            return decomposition
-
-        return None
-
-
 def _instruction_to_circuit(inst: Instruction) -> QuantumCircuit:
     circuit = QuantumCircuit(inst.num_qubits, inst.num_clbits)
     circuit.append(inst, circuit.qubits, circuit.clbits)
diff --git a/qiskit/transpiler/passes/synthesis/hls_plugins.py b/qiskit/transpiler/passes/synthesis/hls_plugins.py
new file mode 100644
index 000000000000..3dce030c1982
--- /dev/null
+++ b/qiskit/transpiler/passes/synthesis/hls_plugins.py
@@ -0,0 +1,928 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2022, 2023.
+#
+# 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.
+
+
+"""
+
+High Level Synthesis Plugins
+-----------------------------
+
+Clifford Synthesis
+''''''''''''''''''
+
+.. list-table:: Plugins for :class:`qiskit.quantum_info.Clifford` (key = ``"clifford"``)
+    :header-rows: 1
+
+    * - Plugin name
+      - Plugin class
+      - Targeted connectivity
+      - Description
+    * - ``"ag"``
+      - :class:`~.AGSynthesisClifford`
+      - all-to-all
+      - greedily optimizes CX-count
+    * - ``"bm"``
+      - :class:`~.BMSynthesisClifford`
+      - all-to-all
+      - optimal count for `n=2,3`; used in ``"default"`` for `n=2,3`
+    * - ``"greedy"``
+      - :class:`~.GreedySynthesisClifford`
+      - all-to-all
+      - greedily optimizes CX-count; used in ``"default"`` for `n>=4`
+    * - ``"layers"``
+      - :class:`~.LayerSynthesisClifford`
+      - all-to-all
+      -
+    * - ``"lnn"``
+      - :class:`~.LayerLnnSynthesisClifford`
+      - linear
+      - many CX-gates but guarantees CX-depth of at most `7*n+2`
+    * - ``"default"``
+      - :class:`~.DefaultSynthesisClifford`
+      - all-to-all
+      - usually best for optimizing CX-count (and optimal CX-count for `n=2,3`)
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   AGSynthesisClifford
+   BMSynthesisClifford
+   GreedySynthesisClifford
+   LayerSynthesisClifford
+   LayerLnnSynthesisClifford
+   DefaultSynthesisClifford
+
+
+Linear Function Synthesis
+'''''''''''''''''''''''''
+
+.. list-table:: Plugins for :class:`.LinearFunction` (key = ``"linear"``)
+    :header-rows: 1
+
+    * - Plugin name
+      - Plugin class
+      - Targeted connectivity
+      - Description
+    * - ``"kms"``
+      - :class:`~.KMSSynthesisLinearFunction`
+      - linear
+      - many CX-gates but guarantees CX-depth of at most `5*n`
+    * - ``"pmh"``
+      - :class:`~.PMHSynthesisLinearFunction`
+      - all-to-all
+      - greedily optimizes CX-count; used in ``"default"``
+    * - ``"default"``
+      - :class:`~.DefaultSynthesisLinearFunction`
+      - all-to-all
+      - best for optimizing CX-count
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   KMSSynthesisLinearFunction
+   PMHSynthesisLinearFunction
+   DefaultSynthesisLinearFunction
+
+
+Permutation Synthesis
+'''''''''''''''''''''
+
+.. list-table:: Plugins for :class:`.PermutationGate` (key = ``"permutation"``)
+    :header-rows: 1
+
+    * - Plugin name
+      - Plugin class
+      - Targeted connectivity
+      - Description
+    * - ``"basic"``
+      - :class:`~.BasicSynthesisPermutation`
+      - all-to-all
+      - optimal SWAP-count; used in ``"default"``
+    * - ``"acg"``
+      - :class:`~.ACGSynthesisPermutation`
+      - all-to-all
+      - guarantees SWAP-depth of at most `2`
+    * - ``"kms"``
+      - :class:`~.KMSSynthesisPermutation`
+      - linear
+      - many SWAP-gates, but guarantees SWAP-depth of at most `n`
+    * - ``"token_swapper"``
+      - :class:`~.TokenSwapperSynthesisPermutation`
+      - any
+      - greedily optimizes SWAP-count for arbitrary connectivity
+    * - ``"default"``
+      - :class:`~.BasicSynthesisPermutation`
+      - all-to-all
+      - best for optimizing SWAP-count
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   BasicSynthesisPermutation
+   ACGSynthesisPermutation
+   KMSSynthesisPermutation
+   TokenSwapperSynthesisPermutation
+
+
+QFT Synthesis
+'''''''''''''
+
+.. list-table:: Plugins for :class:`.QFTGate` (key = ``"qft"``)
+    :header-rows: 1
+
+    * - Plugin name
+      - Plugin class
+      - Targeted connectivity
+    * - ``"full"``
+      - :class:`~.QFTSynthesisFull`
+      - all-to-all
+    * - ``"line"``
+      - :class:`~.QFTSynthesisLine`
+      - linear
+    * - ``"default"``
+      - :class:`~.QFTSynthesisFull`
+      - all-to-all
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   QFTSynthesisFull
+   QFTSynthesisLine
+
+
+MCX Synthesis
+'''''''''''''
+
+The following table lists synthesis plugins available for an :class:`.MCXGate` gate
+with `k` control qubits. If the available number of clean/dirty auxiliary qubits is
+not sufficient, the corresponding synthesis method will return `None`.
+
+.. list-table:: Plugins for :class:`.MCXGate` (key = ``"mcx"``)
+    :header-rows: 1
+
+    * - Plugin name
+      - Plugin class
+      - Number of clean ancillas
+      - Number of dirty ancillas
+      - Description
+    * - ``"gray_code"``
+      - :class:`~.MCXSynthesisGrayCode`
+      - `0`
+      - `0`
+      - exponentially many CX gates; use only for small values of `k`
+    * - ``"noaux_v24"``
+      - :class:`~.MCXSynthesisNoAuxV24`
+      - `0`
+      - `0`
+      - quadratic number of CX gates; use instead of ``"gray_code"`` for large values of `k`
+    * - ``"n_clean_m15"``
+      - :class:`~.MCXSynthesisNCleanM15`
+      - `k-2`
+      - `0`
+      - at most `6*k-6` CX gates
+    * - ``"n_dirty_i15"``
+      - :class:`~.MCXSynthesisNDirtyI15`
+      - `0`
+      - `k-2`
+      - at most `8*k-6` CX gates
+    * - ``"1_clean_b95"``
+      - :class:`~.MCXSynthesis1CleanB95`
+      - `1`
+      - `0`
+      - at most `16*k-8` CX gates
+    * - ``"default"``
+      - :class:`~.MCXSynthesisDefault`
+      - any
+      - any
+      - chooses the best algorithm based on the ancillas available
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   MCXSynthesisGrayCode
+   MCXSynthesisNoAuxV24
+   MCXSynthesisNCleanM15
+   MCXSynthesisNDirtyI15
+   MCXSynthesis1CleanB95
+   MCXSynthesisDefault
+"""
+
+import numpy as np
+import rustworkx as rx
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.library import LinearFunction, QFTGate, MCXGate, C3XGate, C4XGate
+from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.transpiler.coupling import CouplingMap
+
+from qiskit.synthesis.clifford import (
+    synth_clifford_full,
+    synth_clifford_layers,
+    synth_clifford_depth_lnn,
+    synth_clifford_greedy,
+    synth_clifford_ag,
+    synth_clifford_bm,
+)
+from qiskit.synthesis.linear import (
+    synth_cnot_count_full_pmh,
+    synth_cnot_depth_line_kms,
+    calc_inverse_matrix,
+)
+from qiskit.synthesis.linear.linear_circuits_utils import transpose_cx_circ
+from qiskit.synthesis.permutation import (
+    synth_permutation_basic,
+    synth_permutation_acg,
+    synth_permutation_depth_lnn_kms,
+)
+from qiskit.synthesis.qft import (
+    synth_qft_full,
+    synth_qft_line,
+)
+from qiskit.synthesis.multi_controlled import (
+    synth_mcx_n_dirty_i15,
+    synth_mcx_n_clean_m15,
+    synth_mcx_1_clean_b95,
+    synth_mcx_gray_code,
+    synth_mcx_noaux_v24,
+)
+from qiskit.transpiler.passes.routing.algorithms import ApproximateTokenSwapper
+from .plugin import HighLevelSynthesisPlugin
+
+
+class DefaultSynthesisClifford(HighLevelSynthesisPlugin):
+    """The default clifford synthesis plugin.
+
+    For N <= 3 qubits this is the optimal CX cost decomposition by Bravyi, Maslov.
+    For N > 3 qubits this is done using the general non-optimal greedy compilation
+    routine from reference by Bravyi, Hu, Maslov, Shaydulin.
+
+    This plugin name is :``clifford.default`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given Clifford."""
+        decomposition = synth_clifford_full(high_level_object)
+        return decomposition
+
+
+class AGSynthesisClifford(HighLevelSynthesisPlugin):
+    """Clifford synthesis plugin based on the Aaronson-Gottesman method.
+
+    This plugin name is :``clifford.ag`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given Clifford."""
+        decomposition = synth_clifford_ag(high_level_object)
+        return decomposition
+
+
+class BMSynthesisClifford(HighLevelSynthesisPlugin):
+    """Clifford synthesis plugin based on the Bravyi-Maslov method.
+
+    The method only works on Cliffords with at most 3 qubits, for which it
+    constructs the optimal CX cost decomposition.
+
+    This plugin name is :``clifford.bm`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given Clifford."""
+        if high_level_object.num_qubits <= 3:
+            decomposition = synth_clifford_bm(high_level_object)
+        else:
+            decomposition = None
+        return decomposition
+
+
+class GreedySynthesisClifford(HighLevelSynthesisPlugin):
+    """Clifford synthesis plugin based on the greedy synthesis
+    Bravyi-Hu-Maslov-Shaydulin method.
+
+    This plugin name is :``clifford.greedy`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given Clifford."""
+        decomposition = synth_clifford_greedy(high_level_object)
+        return decomposition
+
+
+class LayerSynthesisClifford(HighLevelSynthesisPlugin):
+    """Clifford synthesis plugin based on the Bravyi-Maslov method
+    to synthesize Cliffords into layers.
+
+    This plugin name is :``clifford.layers`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given Clifford."""
+        decomposition = synth_clifford_layers(high_level_object)
+        return decomposition
+
+
+class LayerLnnSynthesisClifford(HighLevelSynthesisPlugin):
+    """Clifford synthesis plugin based on the Bravyi-Maslov method
+    to synthesize Cliffords into layers, with each layer synthesized
+    adhering to LNN connectivity.
+
+    This plugin name is :``clifford.lnn`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given Clifford."""
+        decomposition = synth_clifford_depth_lnn(high_level_object)
+        return decomposition
+
+
+class DefaultSynthesisLinearFunction(HighLevelSynthesisPlugin):
+    """The default linear function synthesis plugin.
+
+    This plugin name is :``linear_function.default`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given LinearFunction."""
+        decomposition = synth_cnot_count_full_pmh(high_level_object.linear)
+        return decomposition
+
+
+class KMSSynthesisLinearFunction(HighLevelSynthesisPlugin):
+    """Linear function synthesis plugin based on the Kutin-Moulton-Smithline method.
+
+    This plugin name is :``linear_function.kms`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    The plugin supports the following plugin-specific options:
+
+    * use_inverted: Indicates whether to run the algorithm on the inverse matrix
+        and to invert the synthesized circuit.
+        In certain cases this provides a better decomposition than the direct approach.
+    * use_transposed: Indicates whether to run the algorithm on the transposed matrix
+        and to invert the order of CX gates in the synthesized circuit.
+        In certain cases this provides a better decomposition than the direct approach.
+
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given LinearFunction."""
+
+        if not isinstance(high_level_object, LinearFunction):
+            raise TranspilerError(
+                "PMHSynthesisLinearFunction only accepts objects of type LinearFunction"
+            )
+
+        use_inverted = options.get("use_inverted", False)
+        use_transposed = options.get("use_transposed", False)
+
+        mat = high_level_object.linear.astype(bool, copy=False)
+
+        if use_transposed:
+            mat = np.transpose(mat)
+        if use_inverted:
+            mat = calc_inverse_matrix(mat)
+
+        decomposition = synth_cnot_depth_line_kms(mat)
+
+        if use_transposed:
+            decomposition = transpose_cx_circ(decomposition)
+        if use_inverted:
+            decomposition = decomposition.inverse()
+
+        return decomposition
+
+
+class PMHSynthesisLinearFunction(HighLevelSynthesisPlugin):
+    """Linear function synthesis plugin based on the Patel-Markov-Hayes method.
+
+    This plugin name is :``linear_function.pmh`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    The plugin supports the following plugin-specific options:
+
+    * section size: The size of each section used in the Patel–Markov–Hayes algorithm [1].
+    * use_inverted: Indicates whether to run the algorithm on the inverse matrix
+        and to invert the synthesized circuit.
+        In certain cases this provides a better decomposition than the direct approach.
+    * use_transposed: Indicates whether to run the algorithm on the transposed matrix
+        and to invert the order of CX gates in the synthesized circuit.
+        In certain cases this provides a better decomposition than the direct approach.
+
+    References:
+        1. Patel, Ketan N., Igor L. Markov, and John P. Hayes,
+           *Optimal synthesis of linear reversible circuits*,
+           Quantum Information & Computation 8.3 (2008): 282-294.
+           `arXiv:quant-ph/0302002 [quant-ph] <https://arxiv.org/abs/quant-ph/0302002>`_
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given LinearFunction."""
+
+        if not isinstance(high_level_object, LinearFunction):
+            raise TranspilerError(
+                "PMHSynthesisLinearFunction only accepts objects of type LinearFunction"
+            )
+
+        section_size = options.get("section_size", 2)
+        use_inverted = options.get("use_inverted", False)
+        use_transposed = options.get("use_transposed", False)
+
+        mat = high_level_object.linear.astype(bool, copy=False)
+
+        if use_transposed:
+            mat = np.transpose(mat)
+        if use_inverted:
+            mat = calc_inverse_matrix(mat)
+
+        decomposition = synth_cnot_count_full_pmh(mat, section_size=section_size)
+
+        if use_transposed:
+            decomposition = transpose_cx_circ(decomposition)
+        if use_inverted:
+            decomposition = decomposition.inverse()
+
+        return decomposition
+
+
+class KMSSynthesisPermutation(HighLevelSynthesisPlugin):
+    """The permutation synthesis plugin based on the Kutin, Moulton, Smithline method.
+
+    This plugin name is :``permutation.kms`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given Permutation."""
+        decomposition = synth_permutation_depth_lnn_kms(high_level_object.pattern)
+        return decomposition
+
+
+class BasicSynthesisPermutation(HighLevelSynthesisPlugin):
+    """The permutation synthesis plugin based on sorting.
+
+    This plugin name is :``permutation.basic`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given Permutation."""
+        decomposition = synth_permutation_basic(high_level_object.pattern)
+        return decomposition
+
+
+class ACGSynthesisPermutation(HighLevelSynthesisPlugin):
+    """The permutation synthesis plugin based on the Alon, Chung, Graham method.
+
+    This plugin name is :``permutation.acg`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given Permutation."""
+        decomposition = synth_permutation_acg(high_level_object.pattern)
+        return decomposition
+
+
+class QFTSynthesisFull(HighLevelSynthesisPlugin):
+    """Synthesis plugin for QFT gates using all-to-all connectivity.
+
+    This plugin name is :``qft.full`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    The plugin supports the following additional options:
+
+    * reverse_qubits (bool): Whether to synthesize the "QFT" operation (if ``False``,
+        which is the default) or the "QFT-with-reversal" operation (if ``True``).
+        Some implementation of the ``QFTGate`` include a layer of swap gates at the end
+        of the synthesized circuit, which can in principle be dropped if the ``QFTGate``
+        itself is the last gate in the circuit.
+    * approximation_degree (int): The degree of approximation (0 for no approximation).
+        It is possible to implement the QFT approximately by ignoring
+        controlled-phase rotations with the angle beneath a threshold. This is discussed
+        in more detail in [1] or [2].
+    * insert_barriers (bool): If True, barriers are inserted as visualization improvement.
+    * inverse (bool): If True, the inverse Fourier transform is constructed.
+    * name (str): The name of the circuit.
+
+    References:
+        1. Adriano Barenco, Artur Ekert, Kalle-Antti Suominen, and Päivi Törmä,
+           *Approximate Quantum Fourier Transform and Decoherence*,
+           Physical Review A (1996).
+           `arXiv:quant-ph/9601018 [quant-ph] <https://arxiv.org/abs/quant-ph/9601018>`_
+        2. Donny Cheung,
+           *Improved Bounds for the Approximate QFT* (2004),
+           `arXiv:quant-ph/0403071 [quant-ph] <https://https://arxiv.org/abs/quant-ph/0403071>`_
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given QFTGate."""
+        if not isinstance(high_level_object, QFTGate):
+            raise TranspilerError(
+                "The synthesis plugin 'qft.full` only applies to objects of type QFTGate."
+            )
+
+        reverse_qubits = options.get("reverse_qubits", False)
+        approximation_degree = options.get("approximation_degree", 0)
+        insert_barriers = options.get("insert_barriers", False)
+        inverse = options.get("inverse", False)
+        name = options.get("name", None)
+
+        decomposition = synth_qft_full(
+            num_qubits=high_level_object.num_qubits,
+            do_swaps=not reverse_qubits,
+            approximation_degree=approximation_degree,
+            insert_barriers=insert_barriers,
+            inverse=inverse,
+            name=name,
+        )
+        return decomposition
+
+
+class QFTSynthesisLine(HighLevelSynthesisPlugin):
+    """Synthesis plugin for QFT gates using linear connectivity.
+
+    This plugin name is :``qft.line`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    The plugin supports the following additional options:
+
+    * reverse_qubits (bool): Whether to synthesize the "QFT" operation (if ``False``,
+        which is the default) or the "QFT-with-reversal" operation (if ``True``).
+        Some implementation of the ``QFTGate`` include a layer of swap gates at the end
+        of the synthesized circuit, which can in principle be dropped if the ``QFTGate``
+        itself is the last gate in the circuit.
+    * approximation_degree (int): the degree of approximation (0 for no approximation).
+        It is possible to implement the QFT approximately by ignoring
+        controlled-phase rotations with the angle beneath a threshold. This is discussed
+        in more detail in [1] or [2].
+
+    References:
+        1. Adriano Barenco, Artur Ekert, Kalle-Antti Suominen, and Päivi Törmä,
+           *Approximate Quantum Fourier Transform and Decoherence*,
+           Physical Review A (1996).
+           `arXiv:quant-ph/9601018 [quant-ph] <https://arxiv.org/abs/quant-ph/9601018>`_
+        2. Donny Cheung,
+           *Improved Bounds for the Approximate QFT* (2004),
+           `arXiv:quant-ph/0403071 [quant-ph] <https://https://arxiv.org/abs/quant-ph/0403071>`_
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given QFTGate."""
+        if not isinstance(high_level_object, QFTGate):
+            raise TranspilerError(
+                "The synthesis plugin 'qft.line` only applies to objects of type QFTGate."
+            )
+
+        reverse_qubits = options.get("reverse_qubits", False)
+        approximation_degree = options.get("approximation_degree", 0)
+
+        decomposition = synth_qft_line(
+            num_qubits=high_level_object.num_qubits,
+            do_swaps=not reverse_qubits,
+            approximation_degree=approximation_degree,
+        )
+        return decomposition
+
+
+class TokenSwapperSynthesisPermutation(HighLevelSynthesisPlugin):
+    """The permutation synthesis plugin based on the token swapper algorithm.
+
+    This plugin name is :``permutation.token_swapper`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    In more detail, this plugin is used to synthesize objects of type `PermutationGate`.
+    When synthesis succeeds, the plugin outputs a quantum circuit consisting only of swap
+    gates. When synthesis does not succeed, the plugin outputs `None`.
+
+    If either `coupling_map` or `qubits` is None, then the synthesized circuit
+    is not required to adhere to connectivity constraints, as is the case
+    when the synthesis is done before layout/routing.
+
+    On the other hand, if both `coupling_map` and `qubits` are specified, the synthesized
+    circuit is supposed to adhere to connectivity constraints. At the moment, the
+    plugin only creates swap gates between qubits in `qubits`, i.e. it does not use
+    any other qubits in the coupling map (if such synthesis is not possible, the
+    plugin  outputs `None`).
+
+    The plugin supports the following plugin-specific options:
+
+    * trials: The number of trials for the token swapper to perform the mapping. The
+      circuit with the smallest number of SWAPs is returned.
+    * seed: The argument to the token swapper specifying the seed for random trials.
+    * parallel_threshold: The argument to the token swapper specifying the number of nodes
+      in the graph beyond which the algorithm will use parallel processing.
+
+    For more details on the token swapper algorithm, see to the paper:
+    `arXiv:1902.09102 <https://arxiv.org/abs/1902.09102>`__.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given Permutation."""
+
+        trials = options.get("trials", 5)
+        seed = options.get("seed", 0)
+        parallel_threshold = options.get("parallel_threshold", 50)
+
+        pattern = high_level_object.pattern
+        pattern_as_dict = {j: i for i, j in enumerate(pattern)}
+
+        # When the plugin is called from the HighLevelSynthesis transpiler pass,
+        # the coupling map already takes target into account.
+        if coupling_map is None or qubits is None:
+            # The abstract synthesis uses a fully connected coupling map, allowing
+            # arbitrary connections between qubits.
+            used_coupling_map = CouplingMap.from_full(len(pattern))
+        else:
+            # The concrete synthesis uses the coupling map restricted to the set of
+            # qubits over which the permutation gate is defined. If we allow using other
+            # qubits in the coupling map, replacing the node in the DAGCircuit that
+            # defines this PermutationGate by the DAG corresponding to the constructed
+            # decomposition becomes problematic. Note that we allow the reduced
+            # coupling map to be disconnected.
+            used_coupling_map = coupling_map.reduce(qubits, check_if_connected=False)
+
+        graph = used_coupling_map.graph.to_undirected()
+        swapper = ApproximateTokenSwapper(graph, seed=seed)
+
+        try:
+            swapper_result = swapper.map(
+                pattern_as_dict, trials, parallel_threshold=parallel_threshold
+            )
+        except rx.InvalidMapping:
+            swapper_result = None
+
+        if swapper_result is not None:
+            decomposition = QuantumCircuit(len(graph.node_indices()))
+            for swap in swapper_result:
+                decomposition.swap(*swap)
+            return decomposition
+
+        return None
+
+
+class MCXSynthesisNDirtyI15(HighLevelSynthesisPlugin):
+    r"""Synthesis plugin for a multi-controlled X gate based on the paper
+    by Iten et al. (2016).
+
+    See [1] for details.
+
+    This plugin name is :``mcx.n_dirty_i15`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    For a multi-controlled X gate with :math:`k\ge 3` control qubits this synthesis
+    method requires :math:`k - 2` additional dirty auxiliary qubits. The synthesized
+    circuit consists of :math:`2 * k - 1` qubits and at most :math:`8 * k - 6` CX gates.
+
+    The plugin supports the following plugin-specific options:
+
+    * num_clean_ancillas: The number of clean auxiliary qubits available.
+    * num_dirty_ancillas: The number of dirty auxiliary qubits available.
+    * relative_phase: When set to ``True``, the method applies the optimized multi-controlled
+      X gate up to a relative phase, in a way that, by lemma 8 of [1], the relative
+      phases of the ``action part`` cancel out with the phases of the ``reset part``.
+    * action_only: when set to ``True``, the method applies only the ``action part``
+      of lemma 8 of [1].
+
+    References:
+        1. Iten et. al., *Quantum Circuits for Isometries*, Phys. Rev. A 93, 032318 (2016),
+           `arXiv:1501.06911 <http://arxiv.org/abs/1501.06911>`_
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given MCX gate."""
+
+        if not isinstance(high_level_object, (MCXGate, C3XGate, C4XGate)):
+            # Unfortunately we occasionally have custom instructions called "mcx"
+            # which get wrongly caught by the plugin interface. A simple solution is
+            # to return None in this case, since HLS would proceed to examine
+            # their definition as it should.
+            return None
+
+        num_ctrl_qubits = high_level_object.num_ctrl_qubits
+        num_clean_ancillas = options.get("num_clean_ancillas", 0)
+        num_dirty_ancillas = options.get("num_dirty_ancillas", 0)
+        relative_phase = options.get("relative_phase", False)
+        action_only = options.get("actions_only", False)
+
+        if num_ctrl_qubits >= 3 and num_dirty_ancillas + num_clean_ancillas < num_ctrl_qubits - 2:
+            # This synthesis method is not applicable as there are not enough ancilla qubits
+            return None
+
+        decomposition = synth_mcx_n_dirty_i15(num_ctrl_qubits, relative_phase, action_only)
+        return decomposition
+
+
+class MCXSynthesisNCleanM15(HighLevelSynthesisPlugin):
+    r"""Synthesis plugin for a multi-controlled X gate based on the paper by
+    Maslov (2016).
+
+    See [1] for details.
+
+    This plugin name is :``mcx.n_clean_m15`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    For a multi-controlled X gate with :math:`k\ge 3` control qubits this synthesis
+    method requires :math:`k - 2` additional clean auxiliary qubits. The synthesized
+    circuit consists of :math:`2 * k - 1` qubits and at most :math:`6 * k - 6` CX gates.
+
+    The plugin supports the following plugin-specific options:
+
+    * num_clean_ancillas: The number of clean auxiliary qubits available.
+
+    References:
+        1. Maslov., Phys. Rev. A 93, 022311 (2016),
+           `arXiv:1508.03273 <https://arxiv.org/pdf/1508.03273>`_
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given MCX gate."""
+
+        if not isinstance(high_level_object, (MCXGate, C3XGate, C4XGate)):
+            # Unfortunately we occasionally have custom instructions called "mcx"
+            # which get wrongly caught by the plugin interface. A simple solution is
+            # to return None in this case, since HLS would proceed to examine
+            # their definition as it should.
+            return None
+
+        num_ctrl_qubits = high_level_object.num_ctrl_qubits
+        num_clean_ancillas = options.get("num_clean_ancillas", 0)
+
+        if num_ctrl_qubits >= 3 and num_clean_ancillas < num_ctrl_qubits - 2:
+            # This synthesis method is not applicable as there are not enough ancilla qubits
+            return None
+
+        decomposition = synth_mcx_n_clean_m15(num_ctrl_qubits)
+        return decomposition
+
+
+class MCXSynthesis1CleanB95(HighLevelSynthesisPlugin):
+    r"""Synthesis plugin for a multi-controlled X gate based on the paper by
+    Barenco et al. (1995).
+
+    See [1] for details.
+
+    This plugin name is :``mcx.1_clean_b95`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    For a multi-controlled X gate with :math:`k\ge 5` control qubits this synthesis
+    method requires a single additional clean auxiliary qubit. The synthesized
+    circuit consists of :math:`k + 2` qubits and at most :math:`16 * k - 8` CX gates.
+
+    The plugin supports the following plugin-specific options:
+
+    * num_clean_ancillas: The number of clean auxiliary qubits available.
+
+    References:
+        1. Barenco et. al., Phys.Rev. A52 3457 (1995),
+           `arXiv:quant-ph/9503016 <https://arxiv.org/abs/quant-ph/9503016>`_
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given MCX gate."""
+
+        if not isinstance(high_level_object, (MCXGate, C3XGate, C4XGate)):
+            # Unfortunately we occasionally have custom instructions called "mcx"
+            # which get wrongly caught by the plugin interface. A simple solution is
+            # to return None in this case, since HLS would proceed to examine
+            # their definition as it should.
+            return None
+
+        num_ctrl_qubits = high_level_object.num_ctrl_qubits
+
+        if num_ctrl_qubits <= 2:
+            # The method requires at least 3 control qubits
+            return None
+
+        num_clean_ancillas = options.get("num_clean_ancillas", 0)
+
+        if num_ctrl_qubits >= 5 and num_clean_ancillas == 0:
+            # This synthesis method is not applicable as there are not enough ancilla qubits
+            return None
+
+        decomposition = synth_mcx_1_clean_b95(num_ctrl_qubits)
+        return decomposition
+
+
+class MCXSynthesisGrayCode(HighLevelSynthesisPlugin):
+    r"""Synthesis plugin for a multi-controlled X gate based on the Gray code.
+
+    This plugin name is :``mcx.gray_code`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    For a multi-controlled X gate with :math:`k` control qubits this synthesis
+    method requires no additional clean auxiliary qubits. The synthesized
+    circuit consists of :math:`k + 1` qubits.
+
+    It is not recommended to use this method for large values of :math:`k + 1`
+    as it produces exponentially many gates.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given MCX gate."""
+
+        if not isinstance(high_level_object, (MCXGate, C3XGate, C4XGate)):
+            # Unfortunately we occasionally have custom instructions called "mcx"
+            # which get wrongly caught by the plugin interface. A simple solution is
+            # to return None in this case, since HLS would proceed to examine
+            # their definition as it should.
+            return None
+
+        num_ctrl_qubits = high_level_object.num_ctrl_qubits
+        decomposition = synth_mcx_gray_code(num_ctrl_qubits)
+        return decomposition
+
+
+class MCXSynthesisNoAuxV24(HighLevelSynthesisPlugin):
+    r"""Synthesis plugin for a multi-controlled X gate based on the
+    implementation for MCPhaseGate, which is in turn based on the
+    paper by Vale et al. (2024).
+
+    See [1] for details.
+
+    This plugin name is :``mcx.noaux_v24`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    For a multi-controlled X gate with :math:`k` control qubits this synthesis
+    method requires no additional clean auxiliary qubits. The synthesized
+    circuit consists of :math:`k + 1` qubits.
+
+    References:
+        1. Vale et. al., *Circuit Decomposition of Multicontrolled Special Unitary
+           Single-Qubit Gates*, IEEE TCAD 43(3) (2024),
+           `arXiv:2302.06377 <https://arxiv.org/abs/2302.06377>`_
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given MCX gate."""
+
+        if not isinstance(high_level_object, (MCXGate, C3XGate, C4XGate)):
+            # Unfortunately we occasionally have custom instructions called "mcx"
+            # which get wrongly caught by the plugin interface. A simple solution is
+            # to return None in this case, since HLS would proceed to examine
+            # their definition as it should.
+            return None
+
+        num_ctrl_qubits = high_level_object.num_ctrl_qubits
+        decomposition = synth_mcx_noaux_v24(num_ctrl_qubits)
+        return decomposition
+
+
+class MCXSynthesisDefault(HighLevelSynthesisPlugin):
+    r"""The default synthesis plugin for a multi-controlled X gate.
+
+    This plugin name is :``mcx.default`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        """Run synthesis for the given MCX gate."""
+
+        if not isinstance(high_level_object, (MCXGate, C3XGate, C4XGate)):
+            # Unfortunately we occasionally have custom instructions called "mcx"
+            # which get wrongly caught by the plugin interface. A simple solution is
+            # to return None in this case, since HLS would proceed to examine
+            # their definition as it should.
+            return None
+
+        # Iteratively run other synthesis methods available
+
+        if (
+            decomposition := MCXSynthesisNCleanM15().run(
+                high_level_object, coupling_map, target, qubits, **options
+            )
+        ) is not None:
+            return decomposition
+
+        if (
+            decomposition := MCXSynthesisNDirtyI15().run(
+                high_level_object, coupling_map, target, qubits, **options
+            )
+        ) is not None:
+            return decomposition
+
+        if (
+            decomposition := MCXSynthesis1CleanB95().run(
+                high_level_object, coupling_map, target, qubits, **options
+            )
+        ) is not None:
+            return decomposition
+
+        return MCXSynthesisNoAuxV24().run(
+            high_level_object, coupling_map, target, qubits, **options
+        )
diff --git a/qiskit/transpiler/passes/synthesis/plugin.py b/qiskit/transpiler/passes/synthesis/plugin.py
index c57c6d76f9fb..a56c48e9cf96 100644
--- a/qiskit/transpiler/passes/synthesis/plugin.py
+++ b/qiskit/transpiler/passes/synthesis/plugin.py
@@ -378,7 +378,7 @@ def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **
 is :class:`~.KMSSynthesisPermutation`. This particular synthesis algorithm created
 a circuit adhering to the linear nearest-neighbor connectivity.
 
-.. automodule:: qiskit.transpiler.passes.synthesis.high_level_synthesis
+.. automodule:: qiskit.transpiler.passes.synthesis.hls_plugins
    :no-members:
    :no-inherited-members:
    :no-special-members:
diff --git a/releasenotes/notes/add-mcx-plugins-85e5b248692a36db.yaml b/releasenotes/notes/add-mcx-plugins-85e5b248692a36db.yaml
new file mode 100644
index 000000000000..84ec35942d0a
--- /dev/null
+++ b/releasenotes/notes/add-mcx-plugins-85e5b248692a36db.yaml
@@ -0,0 +1,45 @@
+---
+features_synthesis:
+  - |
+    Added synthesis functions :func:`.synth_mcx_gray_code` and :func:`.synth_mcx_noaux_v24`
+    that synthesize multi-controlled X gates. These functions do not require additional
+    ancilla qubits.
+  - |
+    Added synthesis functions :func:`.synth_c3x` and  :func:`.synth_c4x` that
+    synthesize 3-controlled and 4-controlled X-gates respectively.
+features_transpiler:
+  - |
+    Added multiple high-level-synthesis plugins for synthesizing an :class:`.MCXGate`:
+
+    * :class:`.MCXSynthesisNCleanM15`, based on :func:`.synth_mcx_n_clean_m15`.
+    * :class:`.MCXSynthesisNDirtyI15`, based on :func:`.synth_mcx_n_dirty_i15`.
+    * :class:`.MCXSynthesis1CleanB95`, based on :func:`.synth_mcx_1_clean_b95`.
+    * :class:`.MCXSynthesisNoAuxV24`, based on :func:`.synth_mcx_noaux_v24`.
+    * :class:`.MCXSynthesisGrayCode`, based on :func:`.synth_mcx_gray_code`.
+
+    As well:
+
+    * :class:`.MCXSynthesisDefault`, choosing the most efficient synthesis
+      method based on the number of clean and dirty ancilla qubits available.
+
+    As an example, consider how the transpilation of the following circuit::
+
+      from qiskit.circuit import QuantumCircuit
+      from qiskit.compiler import transpile
+
+      qc = QuantumCircuit(7)
+      qc.x(0)
+      qc.mcx([0, 1, 2, 3], [4])
+      qc.mcx([0, 1, 2, 3, 4], [5])
+      qc.mcx([0, 1, 2, 3, 4, 5], [6])
+
+      transpile(qc)
+
+    For the first MCX gate, qubits ``5`` and ``6`` can be used as clean
+    ancillas, and the best available synthesis method ``synth_mcx_n_clean_m15``
+    will get chosen.
+    For the second MCX gate, qubit ``6`` can be used as a clean ancilla,
+    the method ``synth_mcx_n_clean_m15`` no longer applies, so the method
+    ``synth_mcx_1_clean_b95`` will get chosen.
+    For the third MCX gate, there are no ancilla qubits, and the method
+    ``synth_mcx_noaux_v24`` will get chosen.
diff --git a/test/python/circuit/test_circuit_qasm.py b/test/python/circuit/test_circuit_qasm.py
index 5f01e5c647a6..984851e00388 100644
--- a/test/python/circuit/test_circuit_qasm.py
+++ b/test/python/circuit/test_circuit_qasm.py
@@ -394,14 +394,13 @@ def test_circuit_qasm_with_mcx_gate(self):
 
         # qasm output doesn't support parameterized gate yet.
         # param0 for "gate mcuq(param0) is not used inside the definition
-        pattern = r"""OPENQASM 2.0;
+        expected_qasm = """OPENQASM 2.0;
 include "qelib1.inc";
-gate mcx q0,q1,q2,q3 { h q3; p\(pi/8\) q0; p\(pi/8\) q1; p\(pi/8\) q2; p\(pi/8\) q3; cx q0,q1; p\(-pi/8\) q1; cx q0,q1; cx q1,q2; p\(-pi/8\) q2; cx q0,q2; p\(pi/8\) q2; cx q1,q2; p\(-pi/8\) q2; cx q0,q2; cx q2,q3; p\(-pi/8\) q3; cx q1,q3; p\(pi/8\) q3; cx q2,q3; p\(-pi/8\) q3; cx q0,q3; p\(pi/8\) q3; cx q2,q3; p\(-pi/8\) q3; cx q1,q3; p\(pi/8\) q3; cx q2,q3; p\(-pi/8\) q3; cx q0,q3; h q3; }
-gate (?P<mcx_id>mcx_[0-9]*) q0,q1,q2,q3 { mcx q0,q1,q2,q3; }
-qreg q\[4\];
-(?P=mcx_id) q\[0\],q\[1\],q\[2\],q\[3\];"""
-        expected_qasm = re.compile(pattern, re.MULTILINE)
-        self.assertRegex(dumps(qc), expected_qasm)
+gate mcx q0,q1,q2,q3 { h q3; p(pi/8) q0; p(pi/8) q1; p(pi/8) q2; p(pi/8) q3; cx q0,q1; p(-pi/8) q1; cx q0,q1; cx q1,q2; p(-pi/8) q2; cx q0,q2; p(pi/8) q2; cx q1,q2; p(-pi/8) q2; cx q0,q2; cx q2,q3; p(-pi/8) q3; cx q1,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q0,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q1,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q0,q3; h q3; }
+qreg q[4];
+mcx q[0],q[1],q[2],q[3];"""
+
+        self.assertEqual(dumps(qc), expected_qasm)
 
     def test_circuit_qasm_with_mcx_gate_variants(self):
         """Test circuit qasm() method with MCXGrayCode, MCXRecursive, MCXVChain"""
@@ -420,8 +419,7 @@ def test_circuit_qasm_with_mcx_gate_variants(self):
 include "qelib1.inc";
 gate mcu1(param0) q0,q1,q2,q3,q4,q5 {{ cu1(pi/16) q4,q5; cx q4,q3; cu1(-pi/16) q3,q5; cx q4,q3; cu1(pi/16) q3,q5; cx q3,q2; cu1(-pi/16) q2,q5; cx q4,q2; cu1(pi/16) q2,q5; cx q3,q2; cu1(-pi/16) q2,q5; cx q4,q2; cu1(pi/16) q2,q5; cx q2,q1; cu1(-pi/16) q1,q5; cx q4,q1; cu1(pi/16) q1,q5; cx q3,q1; cu1(-pi/16) q1,q5; cx q4,q1; cu1(pi/16) q1,q5; cx q2,q1; cu1(-pi/16) q1,q5; cx q4,q1; cu1(pi/16) q1,q5; cx q3,q1; cu1(-pi/16) q1,q5; cx q4,q1; cu1(pi/16) q1,q5; cx q1,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; cx q3,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; cx q2,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; cx q3,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; cx q1,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; cx q3,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; cx q2,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; cx q3,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; }}
 gate mcx_gray q0,q1,q2,q3,q4,q5 {{ h q5; mcu1(pi) q0,q1,q2,q3,q4,q5; h q5; }}
-gate mcx q0,q1,q2,q3 {{ h q3; p(pi/8) q0; p(pi/8) q1; p(pi/8) q2; p(pi/8) q3; cx q0,q1; p(-pi/8) q1; cx q0,q1; cx q1,q2; p(-pi/8) q2; cx q0,q2; p(pi/8) q2; cx q1,q2; p(-pi/8) q2; cx q0,q2; cx q2,q3; p(-pi/8) q3; cx q1,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q0,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q1,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q0,q3; h q3; }}
-gate mcx_vchain q0,q1,q2,q3,q4 {{ mcx q0,q1,q2,q3; }}
+gate mcx_vchain q0,q1,q2,q3,q4 {{ h q3; p(pi/8) q0; p(pi/8) q1; p(pi/8) q2; p(pi/8) q3; cx q0,q1; p(-pi/8) q1; cx q0,q1; cx q1,q2; p(-pi/8) q2; cx q0,q2; p(pi/8) q2; cx q1,q2; p(-pi/8) q2; cx q0,q2; cx q2,q3; p(-pi/8) q3; cx q1,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q0,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q1,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q0,q3; h q3; }}
 gate mcx_recursive q0,q1,q2,q3,q4,q5,q6 {{ mcx_vchain q0,q1,q2,q6,q3; mcx_vchain q3,q4,q6,q5,q0; mcx_vchain q0,q1,q2,q6,q3; mcx_vchain q3,q4,q6,q5,q0; }}
 gate mcx_vchain_{mcx_vchain_id} q0,q1,q2,q3,q4,q5,q6,q7,q8 {{ rccx q0,q1,q6; rccx q2,q6,q7; rccx q3,q7,q8; ccx q4,q8,q5; rccx q3,q7,q8; rccx q2,q6,q7; rccx q0,q1,q6; }}
 qreg q[9];
diff --git a/test/python/qasm2/test_export.py b/test/python/qasm2/test_export.py
index 0bba2f5c47e0..8de4bb8eb34f 100644
--- a/test/python/qasm2/test_export.py
+++ b/test/python/qasm2/test_export.py
@@ -387,14 +387,12 @@ def test_mcx_gate(self):
 
         # qasm output doesn't support parameterized gate yet.
         # param0 for "gate mcuq(param0) is not used inside the definition
-        pattern = r"""OPENQASM 2.0;
+        expected_qasm = """OPENQASM 2.0;
 include "qelib1.inc";
-gate mcx q0,q1,q2,q3 { h q3; p\(pi/8\) q0; p\(pi/8\) q1; p\(pi/8\) q2; p\(pi/8\) q3; cx q0,q1; p\(-pi/8\) q1; cx q0,q1; cx q1,q2; p\(-pi/8\) q2; cx q0,q2; p\(pi/8\) q2; cx q1,q2; p\(-pi/8\) q2; cx q0,q2; cx q2,q3; p\(-pi/8\) q3; cx q1,q3; p\(pi/8\) q3; cx q2,q3; p\(-pi/8\) q3; cx q0,q3; p\(pi/8\) q3; cx q2,q3; p\(-pi/8\) q3; cx q1,q3; p\(pi/8\) q3; cx q2,q3; p\(-pi/8\) q3; cx q0,q3; h q3; }
-gate (?P<mcx_id>mcx_[0-9]*) q0,q1,q2,q3 { mcx q0,q1,q2,q3; }
-qreg q\[4\];
-(?P=mcx_id) q\[0\],q\[1\],q\[2\],q\[3\];"""
-        expected_qasm = re.compile(pattern, re.MULTILINE)
-        self.assertRegex(qasm2.dumps(qc), expected_qasm)
+gate mcx q0,q1,q2,q3 { h q3; p(pi/8) q0; p(pi/8) q1; p(pi/8) q2; p(pi/8) q3; cx q0,q1; p(-pi/8) q1; cx q0,q1; cx q1,q2; p(-pi/8) q2; cx q0,q2; p(pi/8) q2; cx q1,q2; p(-pi/8) q2; cx q0,q2; cx q2,q3; p(-pi/8) q3; cx q1,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q0,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q1,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q0,q3; h q3; }
+qreg q[4];
+mcx q[0],q[1],q[2],q[3];"""
+        self.assertEqual(qasm2.dumps(qc), expected_qasm)
 
     def test_mcx_gate_variants(self):
         n = 5
@@ -406,13 +404,11 @@ def test_mcx_gate_variants(self):
 
         # qasm output doesn't support parameterized gate yet.
         # param0 for "gate mcuq(param0) is not used inside the definition
-        expected_qasm = f"""\
-OPENQASM 2.0;
+        expected_qasm = f"""OPENQASM 2.0;
 include "qelib1.inc";
 gate mcu1(param0) q0,q1,q2,q3,q4,q5 {{ cu1(pi/16) q4,q5; cx q4,q3; cu1(-pi/16) q3,q5; cx q4,q3; cu1(pi/16) q3,q5; cx q3,q2; cu1(-pi/16) q2,q5; cx q4,q2; cu1(pi/16) q2,q5; cx q3,q2; cu1(-pi/16) q2,q5; cx q4,q2; cu1(pi/16) q2,q5; cx q2,q1; cu1(-pi/16) q1,q5; cx q4,q1; cu1(pi/16) q1,q5; cx q3,q1; cu1(-pi/16) q1,q5; cx q4,q1; cu1(pi/16) q1,q5; cx q2,q1; cu1(-pi/16) q1,q5; cx q4,q1; cu1(pi/16) q1,q5; cx q3,q1; cu1(-pi/16) q1,q5; cx q4,q1; cu1(pi/16) q1,q5; cx q1,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; cx q3,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; cx q2,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; cx q3,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; cx q1,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; cx q3,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; cx q2,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; cx q3,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; }}
 gate mcx_gray q0,q1,q2,q3,q4,q5 {{ h q5; mcu1(pi) q0,q1,q2,q3,q4,q5; h q5; }}
-gate mcx q0,q1,q2,q3 {{ h q3; p(pi/8) q0; p(pi/8) q1; p(pi/8) q2; p(pi/8) q3; cx q0,q1; p(-pi/8) q1; cx q0,q1; cx q1,q2; p(-pi/8) q2; cx q0,q2; p(pi/8) q2; cx q1,q2; p(-pi/8) q2; cx q0,q2; cx q2,q3; p(-pi/8) q3; cx q1,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q0,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q1,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q0,q3; h q3; }}
-gate mcx_vchain q0,q1,q2,q3,q4 {{ mcx q0,q1,q2,q3; }}
+gate mcx_vchain q0,q1,q2,q3,q4 {{ h q3; p(pi/8) q0; p(pi/8) q1; p(pi/8) q2; p(pi/8) q3; cx q0,q1; p(-pi/8) q1; cx q0,q1; cx q1,q2; p(-pi/8) q2; cx q0,q2; p(pi/8) q2; cx q1,q2; p(-pi/8) q2; cx q0,q2; cx q2,q3; p(-pi/8) q3; cx q1,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q0,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q1,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q0,q3; h q3; }}
 gate mcx_recursive q0,q1,q2,q3,q4,q5,q6 {{ mcx_vchain q0,q1,q2,q6,q3; mcx_vchain q3,q4,q6,q5,q0; mcx_vchain q0,q1,q2,q6,q3; mcx_vchain q3,q4,q6,q5,q0; }}
 gate mcx_vchain_{mcx_vchain_id} q0,q1,q2,q3,q4,q5,q6,q7,q8 {{ rccx q0,q1,q6; rccx q2,q6,q7; rccx q3,q7,q8; ccx q4,q8,q5; rccx q3,q7,q8; rccx q2,q6,q7; rccx q0,q1,q6; }}
 qreg q[9];
diff --git a/test/python/transpiler/test_decompose.py b/test/python/transpiler/test_decompose.py
index 7b364f3ac10f..1223b37ca3ff 100644
--- a/test/python/transpiler/test_decompose.py
+++ b/test/python/transpiler/test_decompose.py
@@ -145,7 +145,7 @@ def test_decompose_oversized_instruction(self):
         self.assertEqual(qc1, output)
 
     def test_decomposition_preserves_qregs_order(self):
-        """Test decomposing a gate preserves it's definition registers order"""
+        """Test decomposing a gate preserves the order of registers in its definition"""
         qr = QuantumRegister(2, "qr1")
         qc1 = QuantumCircuit(qr)
         qc1.cx(1, 0)
diff --git a/test/python/transpiler/test_high_level_synthesis.py b/test/python/transpiler/test_high_level_synthesis.py
index 97c0b58bb377..f3b11c98bfc7 100644
--- a/test/python/transpiler/test_high_level_synthesis.py
+++ b/test/python/transpiler/test_high_level_synthesis.py
@@ -44,9 +44,10 @@
     CU1Gate,
     QFTGate,
     IGate,
+    MCXGate,
 )
 from qiskit.circuit.library.generalized_gates import LinearFunction
-from qiskit.quantum_info import Clifford
+from qiskit.quantum_info import Clifford, Operator, Statevector
 from qiskit.synthesis.linear import random_invertible_binary_matrix
 from qiskit.compiler import transpile
 from qiskit.exceptions import QiskitError
@@ -59,13 +60,20 @@
     high_level_synthesis_plugin_names,
 )
 from qiskit.transpiler.passes.synthesis.high_level_synthesis import HighLevelSynthesis, HLSConfig
+from qiskit.transpiler.passes.synthesis.hls_plugins import (
+    MCXSynthesis1CleanB95,
+    MCXSynthesisNCleanM15,
+    MCXSynthesisNDirtyI15,
+    MCXSynthesisGrayCode,
+    MCXSynthesisDefault,
+    MCXSynthesisNoAuxV24,
+)
 from qiskit.circuit.annotated_operation import (
     AnnotatedOperation,
     ControlModifier,
     InverseModifier,
     PowerModifier,
 )
-from qiskit.quantum_info import Operator
 from qiskit.providers.fake_provider import GenericBackendV2
 from qiskit.circuit.library.standard_gates.equivalence_library import (
     StandardEquivalenceLibrary as std_eqlib,
@@ -1364,8 +1372,23 @@ def test_definition_with_annotations(self):
         lazy_gate3 = AnnotatedOperation(custom_gate, ControlModifier(2))
         circuit = QuantumCircuit(6)
         circuit.append(lazy_gate3, [0, 1, 2, 3, 4, 5])
-        transpiled_circuit = HighLevelSynthesis(basis_gates=["cx", "u"])(circuit)
-        self.assertEqual(Operator(circuit), Operator(transpiled_circuit))
+
+        with self.subTest(qubits_initially_zero=False):
+            # When transpiling without assuming that qubits are initially zero,
+            # we should have that the Operators before and after are equal.
+            transpiled_circuit = HighLevelSynthesis(
+                basis_gates=["cx", "u"], qubits_initially_zero=False
+            )(circuit)
+            self.assertEqual(Operator(circuit), Operator(transpiled_circuit))
+
+        with self.subTest(qubits_initially_zero=True):
+            # When transpiling assuming that qubits are initially zero,
+            # we should have that the Statevectors before and after
+            # are equal (but not the full Operators).
+            transpiled_circuit = HighLevelSynthesis(
+                basis_gates=["cx", "u"], qubits_initially_zero=True
+            )(circuit)
+            self.assertEqual(Statevector(circuit), Statevector(transpiled_circuit))
 
     def test_definition_with_high_level_objects(self):
         """Test annotated gates with definitions involving annotations and
@@ -2287,5 +2310,148 @@ def test_qft_line_plugin_annotated_qft(self, qft_plugin_name):
         self.assertEqual(Operator(qc), Operator(qct))
 
 
+@ddt
+class TestMCXSynthesisPlugins(QiskitTestCase):
+    """Tests related to plugins for MCXGate."""
+
+    def test_supported_names(self):
+        """Test that there is a default synthesis plugin for MCXGate."""
+        supported_plugin_names = high_level_synthesis_plugin_names("mcx")
+        self.assertIn("default", supported_plugin_names)
+
+    def test_mcx_plugins_applicability(self):
+        """Test applicability of MCX synthesis plugins for MCX gates."""
+        gate = MCXGate(5)
+
+        with self.subTest(method="n_clean_m15", num_clean_ancillas=4, num_dirty_ancillas=4):
+            # should have a decomposition
+            decomposition = MCXSynthesisNCleanM15().run(
+                gate, num_clean_ancillas=4, num_dirty_ancillas=4
+            )
+            self.assertIsNotNone(decomposition)
+
+        with self.subTest(method="n_clean_m15", num_clean_ancillas=2, num_dirty_ancillas=4):
+            # should not have a decomposition
+            decomposition = MCXSynthesisNCleanM15().run(
+                gate, num_clean_ancillas=2, num_dirty_ancillas=4
+            )
+            self.assertIsNone(decomposition)
+
+        with self.subTest(method="n_dirty_i15", num_clean_ancillas=4, num_dirty_ancillas=4):
+            # should have a decomposition
+            decomposition = MCXSynthesisNDirtyI15().run(
+                gate, num_clean_ancillas=4, num_dirty_ancillas=4
+            )
+            self.assertIsNotNone(decomposition)
+
+        with self.subTest(method="n_dirty_i15", num_clean_ancillas=2, num_dirty_ancillas=2):
+            # should have a decomposition
+            decomposition = MCXSynthesisNDirtyI15().run(
+                gate, num_clean_ancillas=2, num_dirty_ancillas=2
+            )
+            self.assertIsNotNone(decomposition)
+
+        with self.subTest(method="n_dirty_i15", num_clean_ancillas=1, num_dirty_ancillas=1):
+            # should not have a decomposition
+            decomposition = MCXSynthesisNDirtyI15().run(
+                gate, num_clean_ancillas=1, num_dirty_ancillas=1
+            )
+            self.assertIsNone(decomposition)
+
+        with self.subTest(method="1_clean_b95", num_clean_ancillas=1, num_dirty_ancillas=0):
+            # should have a decomposition
+            decomposition = MCXSynthesis1CleanB95().run(
+                gate, num_clean_ancillas=1, num_dirty_ancillas=0
+            )
+            self.assertIsNotNone(decomposition)
+
+        with self.subTest(method="1_clean_b95", num_clean_ancillas=0, num_dirty_ancillas=1):
+            # should not have a decomposition
+            decomposition = MCXSynthesis1CleanB95().run(
+                gate, num_clean_ancillas=0, num_dirty_ancillas=1
+            )
+            self.assertIsNone(decomposition)
+
+        with self.subTest(method="noaux_v24", num_clean_ancillas=1, num_dirty_ancillas=1):
+            # should have a decomposition
+            decomposition = MCXSynthesisNoAuxV24().run(
+                gate, num_clean_ancillas=1, num_dirty_ancillas=1
+            )
+            self.assertIsNotNone(decomposition)
+
+        with self.subTest(method="noaux_v24", num_clean_ancillas=0, num_dirty_ancillas=0):
+            # should have a decomposition
+            decomposition = MCXSynthesisNoAuxV24().run(
+                gate, num_clean_ancillas=0, num_dirty_ancillas=0
+            )
+            self.assertIsNotNone(decomposition)
+
+        with self.subTest(method="gray_code", num_clean_ancillas=1, num_dirty_ancillas=1):
+            # should have a decomposition
+            decomposition = MCXSynthesisGrayCode().run(
+                gate, num_clean_ancillas=1, num_dirty_ancillas=1
+            )
+            self.assertIsNotNone(decomposition)
+
+        with self.subTest(method="gray_code", num_clean_ancillas=0, num_dirty_ancillas=0):
+            # should have a decomposition
+            decomposition = MCXSynthesisGrayCode().run(
+                gate, num_clean_ancillas=0, num_dirty_ancillas=0
+            )
+            self.assertIsNotNone(decomposition)
+
+        with self.subTest(method="default", num_clean_ancillas=1, num_dirty_ancillas=1):
+            # should have a decomposition
+            decomposition = MCXSynthesisDefault().run(
+                gate, num_clean_ancillas=1, num_dirty_ancillas=1
+            )
+            self.assertIsNotNone(decomposition)
+
+        with self.subTest(method="default", num_clean_ancillas=0, num_dirty_ancillas=0):
+            # should have a decomposition
+            decomposition = MCXSynthesisDefault().run(
+                gate, num_clean_ancillas=0, num_dirty_ancillas=0
+            )
+            self.assertIsNotNone(decomposition)
+
+    @data("n_clean_m15", "n_dirty_i15", "1_clean_b95", "noaux_v24", "gray_code", "default")
+    def test_mcx_plugins_correctness_from_arbitrary(self, mcx_plugin_name):
+        """Test that all plugins return a correct Operator when qubits are not
+        initially zero."""
+        qc = QuantumCircuit(6)
+        qc.h(0)
+        qc.cx(0, 1)
+        qc.mcx(control_qubits=[0, 1, 2], target_qubit=[3])
+        qc.mcx(control_qubits=[2, 3, 4, 5], target_qubit=[1])
+        qc.mcx(control_qubits=[5, 4, 3, 2, 1], target_qubit=[0])
+        hls_config = HLSConfig(mcx=[mcx_plugin_name])
+        hls_pass = HighLevelSynthesis(hls_config=hls_config, qubits_initially_zero=False)
+        qct = hls_pass(qc)
+        self.assertEqual(Operator(qc), Operator(qct))
+
+    @data("n_clean_m15", "n_dirty_i15", "1_clean_b95", "noaux_v24", "gray_code", "default")
+    def test_mcx_plugins_correctness_from_zero(self, mcx_plugin_name):
+        """Test that all plugins return a correct Statevector when qubits are
+        initially zero."""
+        qc = QuantumCircuit(6)
+        qc.h(0)
+        qc.cx(0, 1)
+        qc.mcx(control_qubits=[0, 1, 2], target_qubit=[3])
+        qc.mcx(control_qubits=[2, 3, 4, 5], target_qubit=[1])
+        qc.mcx(control_qubits=[5, 4, 3, 2, 1], target_qubit=[0])
+        hls_config = HLSConfig(mcx=[mcx_plugin_name])
+        hls_pass = HighLevelSynthesis(hls_config=hls_config, qubits_initially_zero=True)
+        qct = hls_pass(qc)
+        self.assertEqual(Statevector(qc), Statevector(qct))
+
+    def test_annotated_mcx(self):
+        """Test synthesis of annotated MCX gates."""
+        qc = QuantumCircuit(6)
+        qc.h(0)
+        qc.append(MCXGate(3).inverse(annotated=True).control(2, annotated=True), [0, 1, 2, 3, 4, 5])
+        qct = transpile(qc, qubits_initially_zero=False)
+        self.assertEqual(Operator(qc), Operator(qct))
+
+
 if __name__ == "__main__":
     unittest.main()

From 1e7c10f7a5a4902223ca2649f42c6b8d68d05361 Mon Sep 17 00:00:00 2001
From: abbycross <across@us.ibm.com>
Date: Thu, 22 Aug 2024 15:23:11 -0400
Subject: [PATCH 18/85] Sections in docs.quantum.ibm.com have been renamed
 (#13017)

---
 .github/ISSUE_TEMPLATE/config.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
index f94ee26f4498..08ca898577d7 100644
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -2,4 +2,4 @@ blank_issues_enabled: true
 contact_links:
   - name: Non-API docs issues
     url: https://github.com/Qiskit/documentation/issues/new/choose
-    about: Open an issue about documentation in the Start, Build, Transpile, Verify, Run, or Migration guides sections of docs.quantum.ibm.com (non-API documentation)
\ No newline at end of file
+    about: Open an issue about documentation in the guides and additional resources sections of docs.quantum.ibm.com (non-API documentation)

From 6b6efc7d547e5baef7d906c850e2bc69ed6430fb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Elena=20Pe=C3=B1a=20Tapia?=
 <57907331+ElePT@users.noreply.github.com>
Date: Fri, 23 Aug 2024 13:04:35 +0200
Subject: [PATCH 19/85] Filter aer warnings in deprecated `FakeBackend` V1
 class (#13018)

* Filter aer warnings in fake backend for the deprecated V1 path

* Filter warnings in QiskitTestCase instead of catching them
---
 test/utils/base.py | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/test/utils/base.py b/test/utils/base.py
index e1b2180aac4e..0038f7772ebf 100644
--- a/test/utils/base.py
+++ b/test/utils/base.py
@@ -156,6 +156,14 @@ def setUpClass(cls):
             module="qiskit_aer",
         )
 
+        # Safe to remove once `FakeBackend` is removed (2.0)
+        warnings.filterwarnings(
+            "ignore",  # If "default", it floods the CI output
+            category=DeprecationWarning,
+            message=r".*from_backend using V1 based backend is deprecated as of Aer 0.15*",
+            module="qiskit.providers.fake_provider.fake_backend",
+        )
+
         allow_DeprecationWarning_message = [
             r"The property ``qiskit\.circuit\.bit\.Bit\.(register|index)`` is deprecated.*",
         ]

From a4bf87bf66df53a6984bd2fd82c19125339cc431 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Elena=20Pe=C3=B1a=20Tapia?=
 <57907331+ElePT@users.noreply.github.com>
Date: Fri, 23 Aug 2024 18:31:24 +0200
Subject: [PATCH 20/85] Fix Rust-space `TwoQubitBasisDecomposer` for
 non-standard KAK gate (#13014)

* Get rid of encoded assumption in TwoQubitBasisDecomposer that the given KAK gate is a Rust-space StandardGate

* Improve unit test

* Update test/python/synthesis/test_synthesis.py

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>

---------

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>
---
 crates/accelerate/src/two_qubit_decompose.rs  | 66 +++++++++++++------
 ...ser-non-std-kak-gate-edc69ffb5d9ef302.yaml |  5 ++
 test/python/synthesis/test_synthesis.py       | 15 +++++
 3 files changed, 66 insertions(+), 20 deletions(-)
 create mode 100644 releasenotes/notes/fix-2q-basis-decomposer-non-std-kak-gate-edc69ffb5d9ef302.yaml

diff --git a/crates/accelerate/src/two_qubit_decompose.rs b/crates/accelerate/src/two_qubit_decompose.rs
index 2072c5034ff7..77ebb3f9433c 100644
--- a/crates/accelerate/src/two_qubit_decompose.rs
+++ b/crates/accelerate/src/two_qubit_decompose.rs
@@ -55,6 +55,7 @@ use qiskit_circuit::circuit_data::CircuitData;
 use qiskit_circuit::circuit_instruction::OperationFromPython;
 use qiskit_circuit::gate_matrix::{CX_GATE, H_GATE, ONE_QUBIT_IDENTITY, SX_GATE, X_GATE};
 use qiskit_circuit::operations::{Param, StandardGate};
+use qiskit_circuit::packed_instruction::PackedOperation;
 use qiskit_circuit::slice::{PySequenceIndex, SequenceIndex};
 use qiskit_circuit::util::{c64, GateArray1Q, GateArray2Q, C_M_ONE, C_ONE, C_ZERO, IM, M_IM};
 use qiskit_circuit::Qubit;
@@ -2063,26 +2064,51 @@ impl TwoQubitBasisDecomposer {
     ) -> PyResult<CircuitData> {
         let kak_gate = kak_gate.extract::<OperationFromPython>(py)?;
         let sequence = self.__call__(unitary, basis_fidelity, approximate, _num_basis_uses)?;
-        CircuitData::from_standard_gates(
-            py,
-            2,
-            sequence
-                .gates
-                .into_iter()
-                .map(|(gate, params, qubits)| match gate {
-                    Some(gate) => (
-                        gate,
-                        params.into_iter().map(Param::Float).collect(),
-                        qubits.into_iter().map(|x| Qubit(x.into())).collect(),
-                    ),
-                    None => (
-                        kak_gate.operation.standard_gate(),
-                        kak_gate.params.clone(),
-                        qubits.into_iter().map(|x| Qubit(x.into())).collect(),
-                    ),
-                }),
-            Param::Float(sequence.global_phase),
-        )
+        match kak_gate.operation.try_standard_gate() {
+            Some(std_kak_gate) => CircuitData::from_standard_gates(
+                py,
+                2,
+                sequence
+                    .gates
+                    .into_iter()
+                    .map(|(gate, params, qubits)| match gate {
+                        Some(gate) => (
+                            gate,
+                            params.into_iter().map(Param::Float).collect(),
+                            qubits.into_iter().map(|x| Qubit(x.into())).collect(),
+                        ),
+                        None => (
+                            std_kak_gate,
+                            kak_gate.params.clone(),
+                            qubits.into_iter().map(|x| Qubit(x.into())).collect(),
+                        ),
+                    }),
+                Param::Float(sequence.global_phase),
+            ),
+            None => CircuitData::from_packed_operations(
+                py,
+                2,
+                0,
+                sequence
+                    .gates
+                    .into_iter()
+                    .map(|(gate, params, qubits)| match gate {
+                        Some(gate) => (
+                            PackedOperation::from_standard(gate),
+                            params.into_iter().map(Param::Float).collect(),
+                            qubits.into_iter().map(|x| Qubit(x.into())).collect(),
+                            Vec::new(),
+                        ),
+                        None => (
+                            kak_gate.operation.clone(),
+                            kak_gate.params.clone(),
+                            qubits.into_iter().map(|x| Qubit(x.into())).collect(),
+                            Vec::new(),
+                        ),
+                    }),
+                Param::Float(sequence.global_phase),
+            ),
+        }
     }
 
     fn num_basis_gates(&self, unitary: PyReadonlyArray2<Complex64>) -> usize {
diff --git a/releasenotes/notes/fix-2q-basis-decomposer-non-std-kak-gate-edc69ffb5d9ef302.yaml b/releasenotes/notes/fix-2q-basis-decomposer-non-std-kak-gate-edc69ffb5d9ef302.yaml
new file mode 100644
index 000000000000..903b9ceac2a2
--- /dev/null
+++ b/releasenotes/notes/fix-2q-basis-decomposer-non-std-kak-gate-edc69ffb5d9ef302.yaml
@@ -0,0 +1,5 @@
+---
+fixes:
+  - |
+    Fixed a bug in :class:`.TwoQubitBasisDecomposer` where the Rust-based code
+    would panic if the given KAK gate wasn't a Rust-space :class:`StandardGate`.
\ No newline at end of file
diff --git a/test/python/synthesis/test_synthesis.py b/test/python/synthesis/test_synthesis.py
index 05739db249b7..b4fac3f427f0 100644
--- a/test/python/synthesis/test_synthesis.py
+++ b/test/python/synthesis/test_synthesis.py
@@ -1270,6 +1270,21 @@ def test_use_dag(self, euler_bases, kak_gates, seed):
             requested_basis = set(oneq_gates + [kak_gate_name])
             self.assertTrue(decomposition_basis.issubset(requested_basis))
 
+    def test_non_std_gate(self):
+        """Test that the TwoQubitBasisDecomposer class can be correctly instantiated with a
+        non-standard KAK gate.
+
+        Reproduce from: https://github.com/Qiskit/qiskit/issues/12998
+        """
+        # note that `CXGate(ctrl_state=0)` is not handled as a "standard" gate.
+        decomposer = TwoQubitBasisDecomposer(CXGate(ctrl_state=0))
+        unitary = SwapGate().to_matrix()
+        decomposed_unitary = decomposer(unitary)
+        self.assertEqual(Operator(unitary), Operator(decomposed_unitary))
+        self.assertNotIn("swap", decomposed_unitary.count_ops())
+        self.assertNotIn("cx", decomposed_unitary.count_ops())
+        self.assertEqual(3, decomposed_unitary.count_ops()["cx_o0"])
+
 
 @ddt
 class TestPulseOptimalDecompose(CheckDecompositions):

From d3040a0b7f25d268c6342011d2d12d42354ed3bc Mon Sep 17 00:00:00 2001
From: Kevin Hartman <kevin@hart.mn>
Date: Fri, 23 Aug 2024 12:40:59 -0400
Subject: [PATCH 21/85] [DAGCircuit Oxidation] Port `DAGCircuit` to Rust
 (#12550)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Port DAGCircuit to Rust

This commit migrates the entirety of the `DAGCircuit` class to Rust. It
fully replaces the Python version of the class. The primary advantage
of this migration is moving from a Python space rustworkx directed graph
representation to a Rust space petgraph (the upstream library for
rustworkx) directed graph. Moving the graph data structure to rust
enables us to directly interact with the DAG directly from transpiler
passes in Rust in the future. This will enable a significant speed-up in
those transpiler passes. Additionally, this should also improve the
memory footprint as the DAGCircuit no longer stores `DAGNode`
instances, and instead stores a lighter enum NodeType, which simply
contains a `PackedInstruction` or the wire objects directly.

Internally, the new Rust-based `DAGCircuit` uses a `petgraph::StableGraph`
with node weights of type `NodeType` and edge weights of type `Wire`. The
NodeType enum contains variants for `QubitIn`, `QubitOut`, `ClbitIn`,
`ClbitOut`, and `Operation`, which should save us from all of the
`isinstance` checking previously needed when working with `DAGNode` Python
instances. The `Wire` enum contains variants `Qubit`, `Clbit`, and `Var`.

As the full Qiskit data model is not rust-native at this point while
all the class code in the `DAGCircuit` exists in Rust now, there are
still sections that rely on Python or actively run Python code via Rust
to function. These typically involve anything that uses `condition`,
control flow, classical vars, calibrations, bit/register manipulation,
etc. In the future as we either migrate this functionality to Rust or
deprecate and remove it this can be updated in place to avoid the use
of Python.

API access from Python-space remains in terms of `DAGNode` instances to
maintain API compatibility with the Python implementation. However,
internally, we convert to and deal in terms of NodeType. When the user
requests a particular node via lookup or iteration, we inflate an ephemeral
`DAGNode` based on the internal `NodeType` and give them that. This is very
similar to what was done in #10827 when porting CircuitData to Rust.

As part of this porting there are a few small differences to keep in
mind with the new Rust implementation of DAGCircuit. The first is that
the topological ordering is slightly different with the new DAGCircuit.
Previously, the Python version of `DAGCircuit` using a lexicographical
topological sort key which was basically `"0,1,0,2"` where the first
`0,1` are qargs on qubit indices `0,1` for nodes and `0,2` are cargs
on clbit indices `0,2`. However, the sort key has now changed to be
`(&[Qubit(0), Qubit(1)], &[Clbit(0), Clbit(2)])` in rust in this case
which for the most part should behave identically, but there are some
edge cases that will appear where the sort order is different. It will
always be a valid topological ordering as the lexicographical key is
used as a tie breaker when generating a topological sort. But if you're
relaying on the exact same sort order there will be differences after
this PR. The second is that a lot of undocumented functionality in the
DAGCircuit which previously worked because of Python's implicit support
for interacting with data structures is no longer functional. For
example, previously the `DAGCircuit.qubits` list could be set directly
(as the circuit visualizers previously did), but this was never
documented as supported (and would corrupt the DAGCircuit). Any
functionality like this we'd have to explicit include in the Rust
implementation and as they were not included in the documented public
API this PR opted to remove the vast majority of this type of
functionality.

The last related thing might require future work to mitigate is that
this PR breaks the linkage between `DAGNode` and the underlying
`DAGCirucit` object. In the Python implementation the `DAGNode` objects
were stored directly in the `DAGCircuit` and when an API method returned
a `DAGNode` from the DAG it was a shared reference to the underlying
object in the `DAGCircuit`. This meant if you mutated the `DAGNode` it
would be reflected in the `DAGCircuit`. This was not always a sound
usage of the API as the `DAGCircuit` was implicitly caching many
attributes of the DAG and you should always be using the `DAGCircuit`
API to mutate any nodes to prevent any corruption of the `DAGCircuit`.
However, now as the underlying data store for nodes in the DAG are
no longer the python space objects returned by `DAGCircuit` methods
mutating a `DAGNode` will not make any change in the underlying
`DAGCircuit`. This can come as quite the surprise at first, especially
if you were relying on this side effect, even if it was unsound.

It's also worth noting that 2 large pieces of functionality from
rustworkx are included in this PR. These are the new files
`rustworkx_core_vnext` and `dot_utils` which are rustworkx's VF2
implementation and its dot file generation. As there was not a rust
interface exposed for this functionality from rustworkx-core there was
no way to use these functions in rustworkx. Until these interfaces
added to rustworkx-core in future releases we'll have to keep these
local copies. The vf2 implementation is in progress in
Qiskit/rustworkx#1235, but `dot_utils` might make sense to keep around
longer term as it is slightly modified from the upstream rustworkx
implementation to directly interface with `DAGCircuit` instead of a
generic graph.

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>
Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>
Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>
Co-authored-by: Alexander Ivrii <alexi@il.ibm.com>
Co-authored-by: Eli Arbel <46826214+eliarbel@users.noreply.github.com>
Co-authored-by: John Lapeyre <jlapeyre@users.noreply.github.com>
Co-authored-by: Jake Lishman <jake.lishman@ibm.com>

* Update visual mpl circuit drawer references

Right now there is a bug in the matplotlib circuit visualizer likely
caused by the new `__eq__` implementation for `DAGOpNode` that didn't
exist before were some gates are missing from the visualization. In the
interest of unblocking this PR this commit updates the references for
these cases temporarily until this issue is fixed.

* Ensure DAGNode.sort_key is always a string

Previously the sort_key attribute of the Python space DAGCircuit was
incorrectly being set to `None` for rust generated node objects. This
was done as for the default path the sort key is determined from the
rust domain's representation of qubits and there is no analogous data in
the Python object. However, this was indavertandly a breaking API change
as sort_key is expected to always be a string. This commit adds a
default string to use for all node types so that we always have a
reasonable value that matches the typing of the class. A future step is
likely to add back the `dag` kwarg to the node types and generate the
string on the fly from the rust space data.

* Make Python argument first in Param::eq and Param::is_close

The standard function signature convention for functions that take a
`py: Python` argument is to make the Python argument the first (or
second after `&self`). The `Param::eq` and `Param::is_close` methods
were not following this convention and had `py` as a later argument in
the signature. This commit corrects the oversight.

* Fix merge conflict with #12943

With the recent merge with main we pulled in #12943 which conflicted
with the rust space API changes made in this PR branch. This commit
updates the usage to conform with the new interface introduced in this
PR.

* Add release notes and test for invalid args on apply methods

This commit adds several release notes to document this change. This
includes a feature note to describe the high level change and the user
facing benefit (mainly reduced memory consumption for DAGCircuits),
two upgrade notes to document the differences with shared references
caused by the new data structure, and a fix note documenting the fix
for how qargs and cargs are handled on `.apply_operation_back()` and
`.apply_operation_front()`. Along with the fix note a new unit test is
added to serve as a regression test so that we don't accidentally allow
adding cargs as qargs and vice versa in the future.

* Restore `inplace` argument functionality for substitute_node()

This commit restores the functionality of the `inplace` argument for
`substitute_node()` and restores the tests validating the object
identity when using the flag. This flag was originally excluded from
the implementation because the Rust representation of the dag is not
a shared reference with Python space and the flag doesn't really mean
the same thing as there is always a second copy of the data for Python
space now. The implementation here is cheating slighty as we're passed
in the DAG node by reference it relies on that reference to update the
input node at the same time we update the dag. Unlike the previous
Python implementation where we were updating the node in place and the
`inplace` argument was slightly faster because everything was done by
reference. The rust space data is still a compressed copy of the data
we return to Python so the `inplace` flag will be slightly more
inefficient as we need to copy to update the Python space representation
in addition to the rust version.

* Revert needless dict() cast on metadata in dag_to_circuit()

This commit removes an unecessary `dict()` cast on the `dag.metadata`
when setting it on `QuantumCircuit.metadata` in
`qiskit.converters.dag_to_circuit()`. This slipped in at some point
during the development of this PR and it's not clear why, but it isn't
needed so this removes it.

* Add code comment for DAGOpNode.__eq__ parameter checking

This commit adds a small inline code comment to make it clear why we
skip parameter comparisons in DAGOpNode.__eq__ for python ops. It might
not be clear why the value is hard coded to `true` in this case, as this
check is done via Python so we don't need to duplicate it in rust space.

* Raise a ValueError on DAGNode creation with invalid index

This commit adds error checking to the DAGNode constructor to raise a
PyValueError if the input index is not valid (any index < -1).
Previously this would have panicked instead of raising a user catchable
error.

* Use macro argument to set python getter/setter name

This commit updates the function names for `get__node_id` and
`set__node_id` method to use a name that clippy is happy with and
leverage the pyo3 macros to set the python space name correctly instead
of using the implicit naming rules.

* Remove Ord and PartialOrd derives from interner::Index

The Ord and PartialOrd traits were originally added to the Index struct
so they could be used for the sort key in lexicographical topological
sorting. However, that approach was abandonded during the development of
this PR and instead the expanded Qubit and Clbit indices were used
instead. This left the ordering traits as unnecessary on Index and
potentially misleading. This commit just opts to remove them as they're
not needed anymore.

* Fix missing nodes in matplotlib drawer.

Previously, the change in equality for DAGNodes was causing nodes
to clobber eachother in the matplotlib drawer's tracking data
structures when used as keys to maps.

To fix this, we ensure that all nodes have a unique ID across
layers before constructing the matplotlib drawer. They actually
of course _do_ in the original DAG, but we don't really care
what the original IDs are, so we just make them up.

Writing to _node_id on a DAGNode may seem odd, but it exists
in the old Python API (prior to being ported to Rust) and
doesn't actually mutate the DAG at all since DAGNodes are
ephemeral.

* Revert "Update visual mpl circuit drawer references"

With the previous commit the bug in the matplotlib drawer causing the
images to diverge should be fixed. This commit reverts the change to the
reference images as there should be no difference now.

This reverts commit 1e4e6f386286b0b4e7f3ebd3f706f948dd707575.

* Update visual mpl circuit drawer references for control flow circuits

The earlier commit that "fixed" the drawers corrected the visualization
to match expectations in most cases. However after restoring the
references to what's on main several comparison tests with control flow
in the circuit were still failing. The failure mode looks similar to the
other cases, but across control flow blocks instead of at the circuit
level. This commit temporarily updates the references of these to the
state of what is generated currently to unblock CI. If/when we have a
fix this commit can be reverted.

* Fix edge cases in DAGOpNode.__eq__

This commit fixes a couple of edge cases in DAGOpNode.__eq__ method
around the python interaction for the method. The first is that in
the case where we had python object parameter types for the gates we
weren't comparing them at all. This is fixed so we use python object
equality for the params in this case. Then we were dropping the error
handling in the case of using python for equality, this fixes it to
return the error to users if the equality check fails. Finally a comment
is added to explain the expected use case for `DAGOpNode.__eq__` and why
parameter checking is more strict than elsewhere.

* Remove Param::add() for global phase addition

This commit removes the Param::add() method and instead adds a local
private function to the `dag_circuit` module for doing global phase
addition. Previously the `Param::add()` method was used solely for
adding global phase in `DAGCircuit` and it took some shortcuts knowing
that context. This made the method implementation ill suited as a
general implementation.

* More complete fix for matplotlib drawer.

* Revert "Update visual mpl circuit drawer references for control flow circuits"

This reverts commit 9a6f9536a3a7412d19a9fd9bbd761825c9a53d0f.

* Unify rayon versions in workspace

* Remove unused _GLOBAL_NID.

* Use global monotonic ID counter for ids in drawer

The fundamental issue with matplotlib visualizations of control flow is
that locally in the control flow block the nodes look the same but are
stored in an outer circuit dictionary. If the gates are the same and on
the same qubits and happen to have the same node id inside the different
control flow blocks the drawer would think it's already drawn the node
and skip it incorrectly. The previous fix for this didn't go far enough
because it wasn't accounting for the recursive execution of the drawer
for inner blocks (it also didn't account for LayerSpoolers of the same
length).

* Re-add missing documentation

* Remove unused BitData iterator stuff.

* Make types, dag, and bit count methods public

This commit makes some attributes of the dag circuit public as they will
need to be accessible from the accelerate crate to realistically start
using the DAGCircuit for rust transpiler passes.

* Make Wire pickle serialization explicit

This commit pivots away from using the PyO3 crate's conversion traits
for specialized pickle serialization output of Wire objects. The output
of the previous traits wasn't really intended for representing a Wire in
Python but only for pickle serialization. This commit migrates these to
custom methods, without a trait, to make it clear they're only for
pickle.

* Make py token usage explicit in _VarIndexMap

The _VarIndexMap type was designed to look like an IndexMap but is
actually an inner python dictionary. This is because `Var` types are still
defined in python and we need to use a dictionary if we have `Var`
objects as keys in the mapping. In the interest of looking like an
IndexMap all the methods (except for 1) used `with_gil` internally to
work with the dictionary. This could add unecessary overhead and to make
it explicit that there is python involvement with this struct's methods
this commit adds a py: Python argument to all the methods and removes
the `with_gil` usage.

* Make all pub(crate) visibility pub

* Remove unused method

* Reorganize code structure around PyVariableMapper and BitLocations

* Add missing var wires to .get_wires() method

In the porting of the get_wires() method to Rust the handling of Var
wires was missed in the output of the method. This commit corrects the
oversight and adds them to the output.

* Raise TypeError not ValueError for invalid input to set_global_phase

* De-duplicate check logic for op node adding methods

The methods for checking the input was valid on apply_operation_back,
apply_operation_front, and _apply_op_node_back were all identical. This
combines them into a single method to deduplicate the code.

* Improve collect_1q_runs() filter function

The filter function for collect_1q_runs() was needlessly building a
matrix for all the standard gates when all we need to know in that case
is whether the standard gate is parameterized or not. If it's not then
we're guaranteed to have a matrix available. This commit updates the
filter logic to account for this and improve it's throughput on standard
gates.

* Use swap_remove instead of shift_remove

* Combine input and output maps into single mapping

This commit combines the `DAGCircuit` `qubit_input_map` and
`qubit_output_map` fields into a single `IndexMap` `qubit_io_map` (and
the same for `clbit_input_map` and `clbit_output_map` going to
`clbit_io_map`). That stores the input and output as 2 element array
where the first element is the input node index and the second element
is the output node index. This reduces the number of lookups we need to
do in practice and also reduces the memory overhead of `DAGCircuit`.

* Ensure we account for clbits in depth() short circuit check

* Also account for Vars in DAGCircuit.width()

The number of vars should be included in the return from the width()
method. This was previously missing in the new implementation of this
method.

* Remove duplicated _get_node() method

The `_get_node()` method was duplicated with the already public
`node()` method. This commit removes the duplicate and updates it's only
usage in the code base.

* Handle Var wires in classical_predecessors

This method was missing the handling for var wires, this commit corrects
the oversight.

* Remove stray comment

* Use Operation::control_flow() instead of isinstance checking

* Use &str for increment_op and decrement_op

This commit reworks the interface for the increment_op and decrement_op
methods to work by reference instead of passing owned String objects to
the methods. Using owned String objects was resulting in unecessary
allocations and extra overhead that could be avoided. There are still a
few places we needed to copy strings to ensure we're not mutating things
while we have references to nodes in the dag, typically only in the
decrement/removal case. But this commit reduces the number of String
copies we need to make in the DAGCircuit.

* Also include vars in depth short circuit

* Fix typing for controlflow name lookup in count_ops

* Fix .properties() method to include operations field

The .properties() method should have included the output of .count_ops()
in its dictionary return but this was commented out temporarily while
other pieces of this PR were fixed. This commit circles back to it and
adds the missing field from the output.

As an aside we should probably deprecate the .properties() method for
removal in 2.0 it doesn't seem to be the most useful method in practice.

* Add missing Var wire handling to py_nodes_on_wire

* Add back optimization to avoid isinstance in op_nodes

This commit adds back an optimization to the op_nodes dag method to
avoid doing a python space op comparison when we're filtering on
non-standard gates and evaluating a standard gate. In these cases we
know that the filter will not match purely from rust without needing a
python space op object creation or an isinstance call so we can avoid
the overhead of doing that.

* Simplify/deduplicate __eq__ method

This commit reworks the logic in the DAGCircuit.__eq__ method
implementation to simplify the code a bit and make it less verbose and
duplicated.

* Invalidate cached py op when needed in substitute_node_with_dag

This commit fixes a potential issue in substitute_node_with_dag() when
the propagate_condition flag was set we were not invalidating cached py
ops when adding a new condition based on a propagated condition. This
could potentially cause the incorrect object to be returned to Python
after calling this method. This fixes the issues by clearing the cached
node so that when returning the op to python we are regenerating the
python object.

* Copy-editing suggestions for release notes

Co-authored-by: John Lapeyre <jlapeyre@users.noreply.github.com>

* Fix and simplify separable_circuits()

This commit fixes and simplifies the separable_circuits() method. At
it's core the method is building a subgraph of the original dag for each
weakly connected component in the dag with a little bit of extra
tracking to make sure the graph is a valid DAGCircuit. Instead of trying
to do this manually this commit updates the method implementation to
leverage the tools petgraph gives us for filtering graphs. This both
fixes a bug identified in review but also simplifies the code.

* Add clbit removal test

* Move to using a Vec<[NodeIndex; 2]> for io maps

This commit migrates the qubit_io_map and clbit_io_map to go from a type
of `IndexMap<Qubit, [NodeIndex; 2], RandomState>` to
`Vec<[NodeIndex; 2]>`. Our qubit indices (represented by the `Qubit`
type) must be a contiguous set for the circuit to be valid, and using an
`IndexMap` for these mappings of bit to input and output nodes only
really improved performance in the removal case, but at the cost of
additional runtime overhead for accessing the data. Since removals are
rare and also inefficient because it needs to reindex the entire dag
already we should instead optimize for the accessing the data. Since we
have contiguous indices using a Vec is a natural structure to represent
this mapping.

* Make add_clbits() signature the same as add_qubits()

At some point during the development of this PR the function signatures
between `add_qubits()` and `add_clbits()` diverged between taking a
`Vec<Bound<PyAny>>` and `&Bound<PySequence>`. In general they're are
comprable but since we are going to be working with a `Vec<>` in the
function body this is a better choice to let PyO3 worry about the
conversion for us. Additionally, this is a more natural signature for
rust consumption. This commit just updates `add_clbits()` to use a Vec
too.

* Add attribution comment to num_tensor_factors() method

* Add py argument to add_declared_var()

* Remove unnecessarily Python-space check

* Correct typo in `to_pickle` method

---------

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>
Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>
Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>
Co-authored-by: Alexander Ivrii <alexi@il.ibm.com>
Co-authored-by: Eli Arbel <46826214+eliarbel@users.noreply.github.com>
Co-authored-by: John Lapeyre <jlapeyre@users.noreply.github.com>
Co-authored-by: Jake Lishman <jake.lishman@ibm.com>
---
 Cargo.lock                                    |    6 +
 Cargo.toml                                    |    6 +-
 crates/accelerate/Cargo.toml                  |    8 +-
 .../accelerate/src/convert_2q_block_matrix.rs |   26 +-
 .../src/euler_one_qubit_decomposer.rs         |   24 +-
 crates/circuit/Cargo.toml                     |   14 +-
 crates/circuit/src/bit_data.rs                |   45 +-
 crates/circuit/src/circuit_data.rs            |   62 +-
 crates/circuit/src/circuit_instruction.rs     |   19 +-
 crates/circuit/src/dag_circuit.rs             | 6196 +++++++++++++++++
 crates/circuit/src/dag_node.rs                |  373 +-
 crates/circuit/src/dot_utils.rs               |  109 +
 crates/circuit/src/error.rs                   |   16 +
 crates/circuit/src/imports.rs                 |   28 +
 crates/circuit/src/interner.rs                |   83 +-
 crates/circuit/src/lib.rs                     |   29 +-
 crates/circuit/src/operations.rs              |   25 +
 crates/circuit/src/packed_instruction.rs      |  132 +-
 crates/circuit/src/rustworkx_core_vnext.rs    | 1417 ++++
 qiskit/converters/circuit_to_dag.py           |    5 +-
 qiskit/dagcircuit/dagcircuit.py               | 2403 +------
 qiskit/dagcircuit/dagnode.py                  |   65 -
 .../two_qubit/two_qubit_decompose.py          |    5 +-
 .../passes/basis/basis_translator.py          |    6 +-
 .../passes/basis/unroll_3q_or_more.py         |    4 +-
 .../passes/basis/unroll_custom_definitions.py |    4 +-
 .../passes/calibration/rzx_templates.py       |   22 +-
 .../transpiler/passes/layout/apply_layout.py  |    2 +-
 .../transpiler/passes/layout/sabre_layout.py  |    2 +-
 .../optimization/commutative_cancellation.py  |    4 +-
 .../passes/optimization/consolidate_blocks.py |    6 +-
 .../optimization/optimize_1q_decomposition.py |    6 +-
 .../passes/optimization/optimize_annotated.py |    6 +-
 .../passes/optimization/split_2q_unitaries.py |    7 +-
 .../transpiler/passes/routing/sabre_swap.py   |    4 +-
 .../passes/routing/stochastic_swap.py         |    6 +-
 .../padding/dynamical_decoupling.py           |    5 +-
 .../scheduling/scheduling/base_scheduler.py   |    4 +-
 .../passes/scheduling/time_unit_conversion.py |    2 +-
 .../passes/synthesis/high_level_synthesis.py  |    6 +-
 .../passes/synthesis/unitary_synthesis.py     |   12 +-
 .../transpiler/passes/utils/control_flow.py   |    6 +-
 .../transpiler/passes/utils/gate_direction.py |    6 +-
 .../passes/utils/merge_adjacent_barriers.py   |    2 +-
 qiskit/visualization/circuit/_utils.py        |   33 +-
 qiskit/visualization/dag_visualization.py     |  104 +-
 .../notes/dag-oxide-60b3d7219cb21703.yaml     |   49 +
 test/python/compiler/test_transpiler.py       |   22 +-
 test/python/dagcircuit/test_dagcircuit.py     |  146 +-
 test/python/transpiler/_dummy_passes.py       |   12 +-
 .../transpiler/test_collect_multiq_blocks.py  |    1 +
 test/python/visualization/test_utils.py       |  122 +-
 52 files changed, 8726 insertions(+), 2981 deletions(-)
 create mode 100644 crates/circuit/src/dag_circuit.rs
 create mode 100644 crates/circuit/src/dot_utils.rs
 create mode 100644 crates/circuit/src/error.rs
 create mode 100644 crates/circuit/src/rustworkx_core_vnext.rs
 create mode 100644 releasenotes/notes/dag-oxide-60b3d7219cb21703.yaml

diff --git a/Cargo.lock b/Cargo.lock
index 63e36f18645c..12daf2e6299e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1187,12 +1187,18 @@ dependencies = [
 name = "qiskit-circuit"
 version = "1.3.0"
 dependencies = [
+ "ahash 0.8.11",
+ "approx",
  "bytemuck",
  "hashbrown 0.14.5",
+ "indexmap",
+ "itertools 0.13.0",
  "ndarray",
  "num-complex",
  "numpy",
  "pyo3",
+ "rayon",
+ "rustworkx-core",
  "smallvec",
  "thiserror",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index f6141f787fdf..a35a87d4d3b1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,14 +16,18 @@ license = "Apache-2.0"
 [workspace.dependencies]
 bytemuck = "1.17"
 indexmap.version = "2.4.0"
-hashbrown.version = "0.14.0"
+hashbrown.version = "0.14.5"
 num-bigint = "0.4"
 num-complex = "0.4"
 ndarray = "^0.15.6"
 numpy = "0.21.0"
 smallvec = "1.13"
 thiserror = "1.0"
+rustworkx-core = "0.15"
+approx = "0.5"
+itertools = "0.13.0"
 ahash = "0.8.11"
+rayon = "1.10"
 
 # Most of the crates don't need the feature `extension-module`, since only `qiskit-pyext` builds an
 # actual C extension (the feature disables linking in `libpython`, which is forbidden in Python
diff --git a/crates/accelerate/Cargo.toml b/crates/accelerate/Cargo.toml
index c93e81b14dee..838fc0153577 100644
--- a/crates/accelerate/Cargo.toml
+++ b/crates/accelerate/Cargo.toml
@@ -10,7 +10,7 @@ name = "qiskit_accelerate"
 doctest = false
 
 [dependencies]
-rayon = "1.10"
+rayon.workspace = true
 numpy.workspace = true
 rand = "0.8"
 rand_pcg = "0.3"
@@ -18,10 +18,10 @@ rand_distr = "0.4.3"
 ahash.workspace = true
 num-traits = "0.2"
 num-complex.workspace = true
+rustworkx-core.workspace = true
 num-bigint.workspace = true
-rustworkx-core = "0.15"
 faer = "0.19.1"
-itertools = "0.13.0"
+itertools.workspace = true
 qiskit-circuit.workspace = true
 thiserror.workspace = true
 
@@ -38,7 +38,7 @@ workspace = true
 features = ["rayon", "approx-0_5"]
 
 [dependencies.approx]
-version = "0.5"
+workspace = true
 features = ["num-complex"]
 
 [dependencies.hashbrown]
diff --git a/crates/accelerate/src/convert_2q_block_matrix.rs b/crates/accelerate/src/convert_2q_block_matrix.rs
index e9f6e343b6bd..dc4d0b77c4a7 100644
--- a/crates/accelerate/src/convert_2q_block_matrix.rs
+++ b/crates/accelerate/src/convert_2q_block_matrix.rs
@@ -27,7 +27,7 @@ use qiskit_circuit::circuit_instruction::CircuitInstruction;
 use qiskit_circuit::dag_node::DAGOpNode;
 use qiskit_circuit::gate_matrix::ONE_QUBIT_IDENTITY;
 use qiskit_circuit::imports::QI_OPERATOR;
-use qiskit_circuit::operations::{Operation, OperationRef};
+use qiskit_circuit::operations::Operation;
 
 use crate::QiskitError;
 
@@ -35,7 +35,7 @@ fn get_matrix_from_inst<'py>(
     py: Python<'py>,
     inst: &'py CircuitInstruction,
 ) -> PyResult<Array2<Complex64>> {
-    if let Some(mat) = inst.op().matrix(&inst.params) {
+    if let Some(mat) = inst.operation.matrix(&inst.params) {
         Ok(mat)
     } else if inst.operation.try_standard_gate().is_some() {
         Err(QiskitError::new_err(
@@ -124,29 +124,7 @@ pub fn change_basis(matrix: ArrayView2<Complex64>) -> Array2<Complex64> {
     trans_matrix
 }
 
-#[pyfunction]
-pub fn collect_2q_blocks_filter(node: &Bound<PyAny>) -> Option<bool> {
-    let Ok(node) = node.downcast::<DAGOpNode>() else {
-        return None;
-    };
-    let node = node.borrow();
-    match node.instruction.op() {
-        gate @ (OperationRef::Standard(_) | OperationRef::Gate(_)) => Some(
-            gate.num_qubits() <= 2
-                && node
-                    .instruction
-                    .extra_attrs
-                    .as_ref()
-                    .and_then(|attrs| attrs.condition.as_ref())
-                    .is_none()
-                && !node.is_parameterized(),
-        ),
-        _ => Some(false),
-    }
-}
-
 pub fn convert_2q_block_matrix(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(blocks_to_matrix))?;
-    m.add_wrapped(wrap_pyfunction!(collect_2q_blocks_filter))?;
     Ok(())
 }
diff --git a/crates/accelerate/src/euler_one_qubit_decomposer.rs b/crates/accelerate/src/euler_one_qubit_decomposer.rs
index 7463777af624..75a2f7993f86 100644
--- a/crates/accelerate/src/euler_one_qubit_decomposer.rs
+++ b/crates/accelerate/src/euler_one_qubit_decomposer.rs
@@ -743,7 +743,7 @@ pub fn compute_error_list(
         .iter()
         .map(|node| {
             (
-                node.instruction.op().name().to_string(),
+                node.instruction.operation.name().to_string(),
                 smallvec![], // Params not needed in this path
             )
         })
@@ -988,10 +988,11 @@ pub fn optimize_1q_gates_decomposition(
                 .iter()
                 .map(|node| {
                     if let Some(err_map) = error_map {
-                        error *= compute_error_term(node.instruction.op().name(), err_map, qubit)
+                        error *=
+                            compute_error_term(node.instruction.operation.name(), err_map, qubit)
                     }
                     node.instruction
-                        .op()
+                        .operation
                         .matrix(&node.instruction.params)
                         .expect("No matrix defined for operation")
                 })
@@ -1043,22 +1044,6 @@ fn matmul_1q(operator: &mut [[Complex64; 2]; 2], other: Array2<Complex64>) {
     ];
 }
 
-#[pyfunction]
-pub fn collect_1q_runs_filter(node: &Bound<PyAny>) -> bool {
-    let Ok(node) = node.downcast::<DAGOpNode>() else {
-        return false;
-    };
-    let node = node.borrow();
-    let op = node.instruction.op();
-    op.num_qubits() == 1
-        && op.num_clbits() == 0
-        && op.matrix(&node.instruction.params).is_some()
-        && match &node.instruction.extra_attrs {
-            None => true,
-            Some(attrs) => attrs.condition.is_none(),
-        }
-}
-
 pub fn euler_one_qubit_decomposer(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(params_zyz))?;
     m.add_wrapped(wrap_pyfunction!(params_xyx))?;
@@ -1072,7 +1057,6 @@ pub fn euler_one_qubit_decomposer(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(compute_error_one_qubit_sequence))?;
     m.add_wrapped(wrap_pyfunction!(compute_error_list))?;
     m.add_wrapped(wrap_pyfunction!(optimize_1q_gates_decomposition))?;
-    m.add_wrapped(wrap_pyfunction!(collect_1q_runs_filter))?;
     m.add_class::<OneQubitGateSequence>()?;
     m.add_class::<OneQubitGateErrorMap>()?;
     m.add_class::<EulerBasis>()?;
diff --git a/crates/circuit/Cargo.toml b/crates/circuit/Cargo.toml
index 3eb430515fcf..ed1f849bbf62 100644
--- a/crates/circuit/Cargo.toml
+++ b/crates/circuit/Cargo.toml
@@ -10,17 +10,29 @@ name = "qiskit_circuit"
 doctest = false
 
 [dependencies]
+rayon.workspace = true
+ahash.workspace = true
+rustworkx-core.workspace = true
 bytemuck.workspace = true
-hashbrown.workspace = true
 num-complex.workspace = true
 ndarray.workspace = true
 numpy.workspace = true
 thiserror.workspace = true
+approx.workspace = true
+itertools.workspace = true
 
 [dependencies.pyo3]
 workspace = true
 features = ["hashbrown", "indexmap", "num-complex", "num-bigint", "smallvec"]
 
+[dependencies.hashbrown]
+workspace = true
+features = ["rayon"]
+
+[dependencies.indexmap]
+workspace = true
+features = ["rayon"]
+
 [dependencies.smallvec]
 workspace = true
 features = ["union"]
diff --git a/crates/circuit/src/bit_data.rs b/crates/circuit/src/bit_data.rs
index 977d1b34e496..0c0b20a02522 100644
--- a/crates/circuit/src/bit_data.rs
+++ b/crates/circuit/src/bit_data.rs
@@ -81,17 +81,6 @@ pub struct BitData<T> {
     cached: Py<PyList>,
 }
 
-pub struct BitNotFoundError<'py>(pub(crate) Bound<'py, PyAny>);
-
-impl<'py> From<BitNotFoundError<'py>> for PyErr {
-    fn from(error: BitNotFoundError) -> Self {
-        PyKeyError::new_err(format!(
-            "Bit {:?} has not been added to this circuit.",
-            error.0
-        ))
-    }
-}
-
 impl<T> BitData<T>
 where
     T: From<BitType> + Copy,
@@ -139,14 +128,19 @@ where
     pub fn map_bits<'py>(
         &self,
         bits: impl IntoIterator<Item = Bound<'py, PyAny>>,
-    ) -> Result<impl Iterator<Item = T>, BitNotFoundError<'py>> {
+    ) -> PyResult<impl Iterator<Item = T>> {
         let v: Result<Vec<_>, _> = bits
             .into_iter()
             .map(|b| {
                 self.indices
                     .get(&BitAsKey::new(&b))
                     .copied()
-                    .ok_or_else(|| BitNotFoundError(b))
+                    .ok_or_else(|| {
+                        PyKeyError::new_err(format!(
+                            "Bit {:?} has not been added to this circuit.",
+                            b
+                        ))
+                    })
             })
             .collect();
         v.map(|x| x.into_iter())
@@ -168,7 +162,7 @@ where
     }
 
     /// Adds a new Python bit.
-    pub fn add(&mut self, py: Python, bit: &Bound<PyAny>, strict: bool) -> PyResult<()> {
+    pub fn add(&mut self, py: Python, bit: &Bound<PyAny>, strict: bool) -> PyResult<T> {
         if self.bits.len() != self.cached.bind(bit.py()).len() {
             return Err(PyRuntimeError::new_err(
             format!("This circuit's {} list has become out of sync with the circuit data. Did something modify it?", self.description)
@@ -193,6 +187,29 @@ where
                 bit
             )));
         }
+        Ok(idx.into())
+    }
+
+    pub fn remove_indices<I>(&mut self, py: Python, indices: I) -> PyResult<()>
+    where
+        I: IntoIterator<Item = T>,
+    {
+        let mut indices_sorted: Vec<usize> = indices
+            .into_iter()
+            .map(|i| <BitType as From<T>>::from(i) as usize)
+            .collect();
+        indices_sorted.sort();
+
+        for index in indices_sorted.into_iter().rev() {
+            self.cached.bind(py).del_item(index)?;
+            let bit = self.bits.remove(index);
+            self.indices.remove(&BitAsKey::new(bit.bind(py)));
+        }
+        // Update indices.
+        for (i, bit) in self.bits.iter().enumerate() {
+            self.indices
+                .insert(BitAsKey::new(bit.bind(py)), (i as BitType).into());
+        }
         Ok(())
     }
 
diff --git a/crates/circuit/src/circuit_data.rs b/crates/circuit/src/circuit_data.rs
index d29455c5363b..4dd3956bee6a 100644
--- a/crates/circuit/src/circuit_data.rs
+++ b/crates/circuit/src/circuit_data.rs
@@ -16,7 +16,7 @@ use std::cell::OnceCell;
 use crate::bit_data::BitData;
 use crate::circuit_instruction::{CircuitInstruction, OperationFromPython};
 use crate::imports::{ANNOTATED_OPERATION, CLBIT, QUANTUM_CIRCUIT, QUBIT};
-use crate::interner::{IndexedInterner, Interner, InternerKey};
+use crate::interner::{IndexedInterner, Interner};
 use crate::operations::{Operation, OperationRef, Param, StandardGate};
 use crate::packed_instruction::{PackedInstruction, PackedOperation};
 use crate::parameter_table::{ParameterTable, ParameterTableError, ParameterUse, ParameterUuid};
@@ -148,12 +148,8 @@ impl CircuitData {
             global_phase,
         )?;
         for (operation, params, qargs, cargs) in instruction_iter {
-            let qubits = (&mut res.qargs_interner)
-                .intern(InternerKey::Value(qargs))?
-                .index;
-            let clbits = (&mut res.cargs_interner)
-                .intern(InternerKey::Value(cargs))?
-                .index;
+            let qubits = (&mut res.qargs_interner).intern(qargs)?;
+            let clbits = (&mut res.cargs_interner).intern(cargs)?;
             let params = (!params.is_empty()).then(|| Box::new(params));
             res.data.push(PackedInstruction {
                 op: operation,
@@ -203,13 +199,9 @@ impl CircuitData {
             instruction_iter.size_hint().0,
             global_phase,
         )?;
-        let no_clbit_index = (&mut res.cargs_interner)
-            .intern(InternerKey::Value(Vec::new()))?
-            .index;
+        let no_clbit_index = (&mut res.cargs_interner).intern(Vec::new())?;
         for (operation, params, qargs) in instruction_iter {
-            let qubits = (&mut res.qargs_interner)
-                .intern(InternerKey::Value(qargs.to_vec()))?
-                .index;
+            let qubits = (&mut res.qargs_interner).intern(qargs.to_vec())?;
             let params = (!params.is_empty()).then(|| Box::new(params));
             res.data.push(PackedInstruction {
                 op: operation.into(),
@@ -266,13 +258,9 @@ impl CircuitData {
         params: &[Param],
         qargs: &[Qubit],
     ) -> PyResult<()> {
-        let no_clbit_index = (&mut self.cargs_interner)
-            .intern(InternerKey::Value(Vec::new()))?
-            .index;
+        let no_clbit_index = (&mut self.cargs_interner).intern(Vec::new())?;
         let params = (!params.is_empty()).then(|| Box::new(params.iter().cloned().collect()));
-        let qubits = (&mut self.qargs_interner)
-            .intern(InternerKey::Value(qargs.to_vec()))?
-            .index;
+        let qubits = (&mut self.qargs_interner).intern(qargs.to_vec())?;
         self.data.push(PackedInstruction {
             op: operation.into(),
             qubits,
@@ -497,7 +485,8 @@ impl CircuitData {
     ///         was provided.
     #[pyo3(signature = (bit, *, strict=true))]
     pub fn add_qubit(&mut self, py: Python, bit: &Bound<PyAny>, strict: bool) -> PyResult<()> {
-        self.qubits.add(py, bit, strict)
+        self.qubits.add(py, bit, strict)?;
+        Ok(())
     }
 
     /// Registers a :class:`.Clbit` instance.
@@ -511,7 +500,8 @@ impl CircuitData {
     ///         was provided.
     #[pyo3(signature = (bit, *, strict=true))]
     pub fn add_clbit(&mut self, py: Python, bit: &Bound<PyAny>, strict: bool) -> PyResult<()> {
-        self.clbits.add(py, bit, strict)
+        self.clbits.add(py, bit, strict)?;
+        Ok(())
     }
 
     /// Performs a shallow copy.
@@ -582,10 +572,10 @@ impl CircuitData {
         let qubits = PySet::empty_bound(py)?;
         let clbits = PySet::empty_bound(py)?;
         for inst in self.data.iter() {
-            for b in self.qargs_interner.intern(inst.qubits).value.iter() {
+            for b in self.qargs_interner.intern(inst.qubits) {
                 qubits.add(self.qubits.get(*b).unwrap().clone_ref(py))?;
             }
-            for b in self.cargs_interner.intern(inst.clbits).value.iter() {
+            for b in self.cargs_interner.intern(inst.clbits) {
                 clbits.add(self.clbits.get(*b).unwrap().clone_ref(py))?;
             }
         }
@@ -751,8 +741,8 @@ impl CircuitData {
             let clbits = self.cargs_interner.intern(inst.clbits);
             CircuitInstruction {
                 operation: inst.op.clone(),
-                qubits: PyTuple::new_bound(py, self.qubits.map_indices(qubits.value)).unbind(),
-                clbits: PyTuple::new_bound(py, self.clbits.map_indices(clbits.value)).unbind(),
+                qubits: PyTuple::new_bound(py, self.qubits.map_indices(qubits)).unbind(),
+                clbits: PyTuple::new_bound(py, self.clbits.map_indices(clbits)).unbind(),
                 params: inst.params_view().iter().cloned().collect(),
                 extra_attrs: inst.extra_attrs.clone(),
                 #[cfg(feature = "cache_pygates")]
@@ -905,7 +895,6 @@ impl CircuitData {
                 let qubits = other
                     .qargs_interner
                     .intern(inst.qubits)
-                    .value
                     .iter()
                     .map(|b| {
                         Ok(self
@@ -917,7 +906,6 @@ impl CircuitData {
                 let clbits = other
                     .cargs_interner
                     .intern(inst.clbits)
-                    .value
                     .iter()
                     .map(|b| {
                         Ok(self
@@ -927,14 +915,12 @@ impl CircuitData {
                     })
                     .collect::<PyResult<Vec<Clbit>>>()?;
                 let new_index = self.data.len();
-                let qubits_id =
-                    Interner::intern(&mut self.qargs_interner, InternerKey::Value(qubits))?;
-                let clbits_id =
-                    Interner::intern(&mut self.cargs_interner, InternerKey::Value(clbits))?;
+                let qubits_id = Interner::intern(&mut self.qargs_interner, qubits)?;
+                let clbits_id = Interner::intern(&mut self.cargs_interner, clbits)?;
                 self.data.push(PackedInstruction {
                     op: inst.op.clone(),
-                    qubits: qubits_id.index,
-                    clbits: clbits_id.index,
+                    qubits: qubits_id,
+                    clbits: clbits_id,
                     params: inst.params.clone(),
                     extra_attrs: inst.extra_attrs.clone(),
                     #[cfg(feature = "cache_pygates")]
@@ -1106,7 +1092,7 @@ impl CircuitData {
     pub fn num_nonlocal_gates(&self) -> usize {
         self.data
             .iter()
-            .filter(|inst| inst.op().num_qubits() > 1 && !inst.op().directive())
+            .filter(|inst| inst.op.num_qubits() > 1 && !inst.op.directive())
             .count()
     }
 }
@@ -1129,16 +1115,16 @@ impl CircuitData {
     fn pack(&mut self, py: Python, inst: &CircuitInstruction) -> PyResult<PackedInstruction> {
         let qubits = Interner::intern(
             &mut self.qargs_interner,
-            InternerKey::Value(self.qubits.map_bits(inst.qubits.bind(py))?.collect()),
+            self.qubits.map_bits(inst.qubits.bind(py))?.collect(),
         )?;
         let clbits = Interner::intern(
             &mut self.cargs_interner,
-            InternerKey::Value(self.clbits.map_bits(inst.clbits.bind(py))?.collect()),
+            self.clbits.map_bits(inst.clbits.bind(py))?.collect(),
         )?;
         Ok(PackedInstruction {
             op: inst.operation.clone(),
-            qubits: qubits.index,
-            clbits: clbits.index,
+            qubits,
+            clbits,
             params: (!inst.params.is_empty()).then(|| Box::new(inst.params.clone())),
             extra_attrs: inst.extra_attrs.clone(),
             #[cfg(feature = "cache_pygates")]
diff --git a/crates/circuit/src/circuit_instruction.rs b/crates/circuit/src/circuit_instruction.rs
index ae649b5a8110..b0620d78fb75 100644
--- a/crates/circuit/src/circuit_instruction.rs
+++ b/crates/circuit/src/circuit_instruction.rs
@@ -114,11 +114,6 @@ pub struct CircuitInstruction {
 }
 
 impl CircuitInstruction {
-    /// View the operation in this `CircuitInstruction`.
-    pub fn op(&self) -> OperationRef {
-        self.operation.view()
-    }
-
     /// Get the Python-space operation, ensuring that it is mutable from Python space (singleton
     /// gates might not necessarily satisfy this otherwise).
     ///
@@ -135,6 +130,12 @@ impl CircuitInstruction {
             out.call_method0(intern!(py, "to_mutable"))
         }
     }
+
+    pub fn condition(&self) -> Option<&PyObject> {
+        self.extra_attrs
+            .as_ref()
+            .and_then(|args| args.condition.as_ref())
+    }
 }
 
 #[pymethods]
@@ -230,7 +231,7 @@ impl CircuitInstruction {
     /// Returns the Instruction name corresponding to the op for this node
     #[getter]
     fn get_name(&self, py: Python) -> PyObject {
-        self.op().name().to_object(py)
+        self.operation.name().to_object(py)
     }
 
     #[getter]
@@ -252,7 +253,7 @@ impl CircuitInstruction {
     }
 
     #[getter]
-    fn condition(&self, py: Python) -> Option<PyObject> {
+    fn get_condition(&self, py: Python) -> Option<PyObject> {
         self.extra_attrs
             .as_ref()
             .and_then(|attrs| attrs.condition.as_ref().map(|x| x.clone_ref(py)))
@@ -292,13 +293,13 @@ impl CircuitInstruction {
 
     /// Is the :class:`.Operation` contained in this node a directive?
     pub fn is_directive(&self) -> bool {
-        self.op().directive()
+        self.operation.directive()
     }
 
     /// Is the :class:`.Operation` contained in this instruction a control-flow operation (i.e. an
     /// instance of :class:`.ControlFlowOp`)?
     pub fn is_control_flow(&self) -> bool {
-        self.op().control_flow()
+        self.operation.control_flow()
     }
 
     /// Does this instruction contain any :class:`.ParameterExpression` parameters?
diff --git a/crates/circuit/src/dag_circuit.rs b/crates/circuit/src/dag_circuit.rs
new file mode 100644
index 000000000000..bb5fff5e343a
--- /dev/null
+++ b/crates/circuit/src/dag_circuit.rs
@@ -0,0 +1,6196 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// 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.
+
+use std::hash::{Hash, Hasher};
+
+use ahash::RandomState;
+
+use crate::bit_data::BitData;
+use crate::circuit_instruction::{
+    CircuitInstruction, ExtraInstructionAttributes, OperationFromPython,
+};
+use crate::dag_node::{DAGInNode, DAGNode, DAGOpNode, DAGOutNode};
+use crate::dot_utils::build_dot;
+use crate::error::DAGCircuitError;
+use crate::imports;
+use crate::interner::{IndexedInterner, Interner};
+use crate::operations::{Operation, OperationRef, Param, PyInstruction};
+use crate::packed_instruction::PackedInstruction;
+use crate::rustworkx_core_vnext::isomorphism;
+use crate::{BitType, Clbit, Qubit, TupleLikeArg};
+
+use hashbrown::{HashMap, HashSet};
+use indexmap::IndexMap;
+use itertools::Itertools;
+
+use pyo3::exceptions::{PyIndexError, PyRuntimeError, PyTypeError, PyValueError};
+use pyo3::intern;
+use pyo3::prelude::*;
+use pyo3::types::{
+    IntoPyDict, PyDict, PyInt, PyIterator, PyList, PySequence, PySet, PyString, PyTuple, PyType,
+};
+
+use rustworkx_core::dag_algo::layers;
+use rustworkx_core::err::ContractError;
+use rustworkx_core::graph_ext::ContractNodesDirected;
+use rustworkx_core::petgraph;
+use rustworkx_core::petgraph::prelude::StableDiGraph;
+use rustworkx_core::petgraph::prelude::*;
+use rustworkx_core::petgraph::stable_graph::{EdgeReference, NodeIndex};
+use rustworkx_core::petgraph::unionfind::UnionFind;
+use rustworkx_core::petgraph::visit::{
+    EdgeIndexable, IntoEdgeReferences, IntoNodeReferences, NodeFiltered, NodeIndexable,
+};
+use rustworkx_core::petgraph::Incoming;
+use rustworkx_core::traversal::{
+    ancestors as core_ancestors, bfs_successors as core_bfs_successors,
+    descendants as core_descendants,
+};
+
+use std::cmp::Ordering;
+use std::collections::{BTreeMap, VecDeque};
+use std::convert::Infallible;
+use std::f64::consts::PI;
+
+#[cfg(feature = "cache_pygates")]
+use std::cell::OnceCell;
+
+static CONTROL_FLOW_OP_NAMES: [&str; 4] = ["for_loop", "while_loop", "if_else", "switch_case"];
+static SEMANTIC_EQ_SYMMETRIC: [&str; 4] = ["barrier", "swap", "break_loop", "continue_loop"];
+
+#[derive(Clone, Debug)]
+pub enum NodeType {
+    QubitIn(Qubit),
+    QubitOut(Qubit),
+    ClbitIn(Clbit),
+    ClbitOut(Clbit),
+    VarIn(PyObject),
+    VarOut(PyObject),
+    Operation(PackedInstruction),
+}
+
+#[derive(Clone, Debug)]
+pub enum Wire {
+    Qubit(Qubit),
+    Clbit(Clbit),
+    Var(PyObject),
+}
+
+impl PartialEq for Wire {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Wire::Qubit(q1), Wire::Qubit(q2)) => q1 == q2,
+            (Wire::Clbit(c1), Wire::Clbit(c2)) => c1 == c2,
+            (Wire::Var(v1), Wire::Var(v2)) => {
+                v1.is(v2) || Python::with_gil(|py| v1.bind(py).eq(v2).unwrap())
+            }
+            _ => false,
+        }
+    }
+}
+
+impl Eq for Wire {}
+
+impl Hash for Wire {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        match self {
+            Self::Qubit(qubit) => qubit.hash(state),
+            Self::Clbit(clbit) => clbit.hash(state),
+            Self::Var(var) => Python::with_gil(|py| var.bind(py).hash().unwrap().hash(state)),
+        }
+    }
+}
+
+impl Wire {
+    fn to_pickle(&self, py: Python) -> PyObject {
+        match self {
+            Self::Qubit(bit) => (0, bit.0.into_py(py)).into_py(py),
+            Self::Clbit(bit) => (1, bit.0.into_py(py)).into_py(py),
+            Self::Var(var) => (2, var.clone_ref(py)).into_py(py),
+        }
+    }
+
+    fn from_pickle(b: &Bound<PyAny>) -> PyResult<Self> {
+        let tuple: Bound<PyTuple> = b.extract()?;
+        let wire_type: usize = tuple.get_item(0)?.extract()?;
+        if wire_type == 0 {
+            Ok(Self::Qubit(Qubit(tuple.get_item(1)?.extract()?)))
+        } else if wire_type == 1 {
+            Ok(Self::Clbit(Clbit(tuple.get_item(1)?.extract()?)))
+        } else if wire_type == 2 {
+            Ok(Self::Var(tuple.get_item(1)?.unbind()))
+        } else {
+            Err(PyTypeError::new_err("Invalid wire type"))
+        }
+    }
+}
+
+// TODO: Remove me.
+// This is a temporary map type used to store a mapping of
+// Var to NodeIndex to hold us over until Var is ported to
+// Rust. Currently, we need this because PyObject cannot be
+// used as the key to an IndexMap.
+//
+// Once we've got Var ported, Wire should also become Hash + Eq
+// and we can consider combining input/output nodes maps.
+#[derive(Clone, Debug)]
+struct _VarIndexMap {
+    dict: Py<PyDict>,
+}
+
+impl _VarIndexMap {
+    pub fn new(py: Python) -> Self {
+        Self {
+            dict: PyDict::new_bound(py).unbind(),
+        }
+    }
+
+    pub fn keys(&self, py: Python) -> impl Iterator<Item = PyObject> {
+        self.dict
+            .bind(py)
+            .keys()
+            .into_iter()
+            .map(|k| k.unbind())
+            .collect::<Vec<_>>()
+            .into_iter()
+    }
+
+    pub fn contains_key(&self, py: Python, key: &PyObject) -> bool {
+        self.dict.bind(py).contains(key).unwrap()
+    }
+
+    pub fn get(&self, py: Python, key: &PyObject) -> Option<NodeIndex> {
+        self.dict
+            .bind(py)
+            .get_item(key)
+            .unwrap()
+            .map(|v| NodeIndex::new(v.extract().unwrap()))
+    }
+
+    pub fn insert(&mut self, py: Python, key: PyObject, value: NodeIndex) {
+        self.dict
+            .bind(py)
+            .set_item(key, value.index().into_py(py))
+            .unwrap()
+    }
+
+    pub fn remove(&mut self, py: Python, key: &PyObject) -> Option<NodeIndex> {
+        let bound_dict = self.dict.bind(py);
+        let res = bound_dict
+            .get_item(key.clone_ref(py))
+            .unwrap()
+            .map(|v| NodeIndex::new(v.extract().unwrap()));
+        let _del_result = bound_dict.del_item(key);
+        res
+    }
+    pub fn values<'py>(&self, py: Python<'py>) -> impl Iterator<Item = NodeIndex> + 'py {
+        let values = self.dict.bind(py).values();
+        values.iter().map(|x| NodeIndex::new(x.extract().unwrap()))
+    }
+
+    pub fn iter<'py>(&self, py: Python<'py>) -> impl Iterator<Item = (PyObject, NodeIndex)> + 'py {
+        self.dict
+            .bind(py)
+            .iter()
+            .map(|(var, index)| (var.unbind(), NodeIndex::new(index.extract().unwrap())))
+    }
+}
+
+/// Quantum circuit as a directed acyclic graph.
+///
+/// There are 3 types of nodes in the graph: inputs, outputs, and operations.
+/// The nodes are connected by directed edges that correspond to qubits and
+/// bits.
+#[pyclass(module = "qiskit._accelerate.circuit")]
+#[derive(Clone, Debug)]
+pub struct DAGCircuit {
+    /// Circuit name.  Generally, this corresponds to the name
+    /// of the QuantumCircuit from which the DAG was generated.
+    #[pyo3(get, set)]
+    name: Option<PyObject>,
+    /// Circuit metadata
+    #[pyo3(get, set)]
+    metadata: Option<PyObject>,
+
+    calibrations: HashMap<String, Py<PyDict>>,
+
+    pub dag: StableDiGraph<NodeType, Wire>,
+
+    #[pyo3(get)]
+    qregs: Py<PyDict>,
+    #[pyo3(get)]
+    cregs: Py<PyDict>,
+
+    /// The cache used to intern instruction qargs.
+    qargs_cache: IndexedInterner<Vec<Qubit>>,
+    /// The cache used to intern instruction cargs.
+    cargs_cache: IndexedInterner<Vec<Clbit>>,
+    /// Qubits registered in the circuit.
+    pub qubits: BitData<Qubit>,
+    /// Clbits registered in the circuit.
+    pub clbits: BitData<Clbit>,
+    /// Global phase.
+    global_phase: Param,
+    /// Duration.
+    #[pyo3(get, set)]
+    duration: Option<PyObject>,
+    /// Unit of duration.
+    #[pyo3(get, set)]
+    unit: String,
+
+    // Note: these are tracked separately from `qubits` and `clbits`
+    // because it's not yet clear if the Rust concept of a native Qubit
+    // and Clbit should correspond directly to the numerical Python
+    // index that users see in the Python API.
+    /// The index locations of bits, and their positions within
+    /// registers.
+    qubit_locations: Py<PyDict>,
+    clbit_locations: Py<PyDict>,
+
+    /// Map from qubit to input and output nodes of the graph.
+    qubit_io_map: Vec<[NodeIndex; 2]>,
+
+    /// Map from clbit to input and output nodes of the graph.
+    clbit_io_map: Vec<[NodeIndex; 2]>,
+
+    // TODO: use IndexMap<Wire, NodeIndex> once Var is ported to Rust
+    /// Map from var to input nodes of the graph.
+    var_input_map: _VarIndexMap,
+    /// Map from var to output nodes of the graph.
+    var_output_map: _VarIndexMap,
+
+    /// Operation kind to count
+    op_names: IndexMap<String, usize, RandomState>,
+
+    // Python modules we need to frequently access (for now).
+    control_flow_module: PyControlFlowModule,
+    vars_info: HashMap<String, DAGVarInfo>,
+    vars_by_type: [Py<PySet>; 3],
+}
+
+#[derive(Clone, Debug)]
+struct PyControlFlowModule {
+    condition_resources: Py<PyAny>,
+    node_resources: Py<PyAny>,
+}
+
+#[derive(Clone, Debug)]
+struct PyLegacyResources {
+    clbits: Py<PyTuple>,
+    cregs: Py<PyTuple>,
+}
+
+impl PyControlFlowModule {
+    fn new(py: Python) -> PyResult<Self> {
+        let module = PyModule::import_bound(py, "qiskit.circuit.controlflow")?;
+        Ok(PyControlFlowModule {
+            condition_resources: module.getattr("condition_resources")?.unbind(),
+            node_resources: module.getattr("node_resources")?.unbind(),
+        })
+    }
+
+    fn condition_resources(&self, condition: &Bound<PyAny>) -> PyResult<PyLegacyResources> {
+        let res = self
+            .condition_resources
+            .bind(condition.py())
+            .call1((condition,))?;
+        Ok(PyLegacyResources {
+            clbits: res.getattr("clbits")?.downcast_into_exact()?.unbind(),
+            cregs: res.getattr("cregs")?.downcast_into_exact()?.unbind(),
+        })
+    }
+
+    fn node_resources(&self, node: &Bound<PyAny>) -> PyResult<PyLegacyResources> {
+        let res = self.node_resources.bind(node.py()).call1((node,))?;
+        Ok(PyLegacyResources {
+            clbits: res.getattr("clbits")?.downcast_into_exact()?.unbind(),
+            cregs: res.getattr("cregs")?.downcast_into_exact()?.unbind(),
+        })
+    }
+}
+
+struct PyVariableMapper {
+    mapper: Py<PyAny>,
+}
+
+impl PyVariableMapper {
+    fn new(
+        py: Python,
+        target_cregs: Bound<PyAny>,
+        bit_map: Option<Bound<PyDict>>,
+        var_map: Option<Bound<PyDict>>,
+        add_register: Option<Py<PyAny>>,
+    ) -> PyResult<Self> {
+        let kwargs: HashMap<&str, Option<Py<PyAny>>> =
+            HashMap::from_iter([("add_register", add_register)]);
+        Ok(PyVariableMapper {
+            mapper: imports::VARIABLE_MAPPER
+                .get_bound(py)
+                .call(
+                    (target_cregs, bit_map, var_map),
+                    Some(&kwargs.into_py_dict_bound(py)),
+                )?
+                .unbind(),
+        })
+    }
+
+    fn map_condition<'py>(
+        &self,
+        condition: &Bound<'py, PyAny>,
+        allow_reorder: bool,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        let py = condition.py();
+        let kwargs: HashMap<&str, Py<PyAny>> =
+            HashMap::from_iter([("allow_reorder", allow_reorder.into_py(py))]);
+        self.mapper.bind(py).call_method(
+            intern!(py, "map_condition"),
+            (condition,),
+            Some(&kwargs.into_py_dict_bound(py)),
+        )
+    }
+
+    fn map_target<'py>(&self, target: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyAny>> {
+        let py = target.py();
+        self.mapper
+            .bind(py)
+            .call_method1(intern!(py, "map_target"), (target,))
+    }
+}
+
+impl IntoPy<Py<PyAny>> for PyVariableMapper {
+    fn into_py(self, _py: Python<'_>) -> Py<PyAny> {
+        self.mapper
+    }
+}
+
+#[pyfunction]
+fn reject_new_register(reg: &Bound<PyAny>) -> PyResult<()> {
+    Err(DAGCircuitError::new_err(format!(
+        "No register with '{:?}' to map this expression onto.",
+        reg.getattr("bits")?
+    )))
+}
+
+#[pyclass(module = "qiskit._accelerate.circuit")]
+#[derive(Clone, Debug)]
+struct BitLocations {
+    #[pyo3(get)]
+    index: usize,
+    #[pyo3(get)]
+    registers: Py<PyList>,
+}
+
+#[derive(Copy, Clone, Debug)]
+enum DAGVarType {
+    Input = 0,
+    Capture = 1,
+    Declare = 2,
+}
+
+#[derive(Clone, Debug)]
+struct DAGVarInfo {
+    var: PyObject,
+    type_: DAGVarType,
+    in_node: NodeIndex,
+    out_node: NodeIndex,
+}
+
+#[pymethods]
+impl DAGCircuit {
+    #[new]
+    pub fn new(py: Python<'_>) -> PyResult<Self> {
+        Ok(DAGCircuit {
+            name: None,
+            metadata: Some(PyDict::new_bound(py).unbind().into()),
+            calibrations: HashMap::new(),
+            dag: StableDiGraph::default(),
+            qregs: PyDict::new_bound(py).unbind(),
+            cregs: PyDict::new_bound(py).unbind(),
+            qargs_cache: IndexedInterner::new(),
+            cargs_cache: IndexedInterner::new(),
+            qubits: BitData::new(py, "qubits".to_string()),
+            clbits: BitData::new(py, "clbits".to_string()),
+            global_phase: Param::Float(0.),
+            duration: None,
+            unit: "dt".to_string(),
+            qubit_locations: PyDict::new_bound(py).unbind(),
+            clbit_locations: PyDict::new_bound(py).unbind(),
+            qubit_io_map: Vec::new(),
+            clbit_io_map: Vec::new(),
+            var_input_map: _VarIndexMap::new(py),
+            var_output_map: _VarIndexMap::new(py),
+            op_names: IndexMap::default(),
+            control_flow_module: PyControlFlowModule::new(py)?,
+            vars_info: HashMap::new(),
+            vars_by_type: [
+                PySet::empty_bound(py)?.unbind(),
+                PySet::empty_bound(py)?.unbind(),
+                PySet::empty_bound(py)?.unbind(),
+            ],
+        })
+    }
+
+    #[getter]
+    fn input_map(&self, py: Python) -> PyResult<Py<PyDict>> {
+        let out_dict = PyDict::new_bound(py);
+        for (qubit, indices) in self
+            .qubit_io_map
+            .iter()
+            .enumerate()
+            .map(|(idx, indices)| (Qubit(idx as u32), indices))
+        {
+            out_dict.set_item(
+                self.qubits.get(qubit).unwrap().clone_ref(py),
+                self.get_node(py, indices[0])?,
+            )?;
+        }
+        for (clbit, indices) in self
+            .clbit_io_map
+            .iter()
+            .enumerate()
+            .map(|(idx, indices)| (Clbit(idx as u32), indices))
+        {
+            out_dict.set_item(
+                self.clbits.get(clbit).unwrap().clone_ref(py),
+                self.get_node(py, indices[0])?,
+            )?;
+        }
+        for (var, index) in self.var_input_map.dict.bind(py).iter() {
+            out_dict.set_item(
+                var,
+                self.get_node(py, NodeIndex::new(index.extract::<usize>()?))?,
+            )?;
+        }
+        Ok(out_dict.unbind())
+    }
+
+    #[getter]
+    fn output_map(&self, py: Python) -> PyResult<Py<PyDict>> {
+        let out_dict = PyDict::new_bound(py);
+        for (qubit, indices) in self
+            .qubit_io_map
+            .iter()
+            .enumerate()
+            .map(|(idx, indices)| (Qubit(idx as u32), indices))
+        {
+            out_dict.set_item(
+                self.qubits.get(qubit).unwrap().clone_ref(py),
+                self.get_node(py, indices[1])?,
+            )?;
+        }
+        for (clbit, indices) in self
+            .clbit_io_map
+            .iter()
+            .enumerate()
+            .map(|(idx, indices)| (Clbit(idx as u32), indices))
+        {
+            out_dict.set_item(
+                self.clbits.get(clbit).unwrap().clone_ref(py),
+                self.get_node(py, indices[1])?,
+            )?;
+        }
+        for (var, index) in self.var_output_map.dict.bind(py).iter() {
+            out_dict.set_item(
+                var,
+                self.get_node(py, NodeIndex::new(index.extract::<usize>()?))?,
+            )?;
+        }
+        Ok(out_dict.unbind())
+    }
+
+    fn __getstate__(&self, py: Python) -> PyResult<Py<PyDict>> {
+        let out_dict = PyDict::new_bound(py);
+        out_dict.set_item("name", self.name.as_ref().map(|x| x.clone_ref(py)))?;
+        out_dict.set_item("metadata", self.metadata.as_ref().map(|x| x.clone_ref(py)))?;
+        out_dict.set_item("calibrations", self.calibrations.clone())?;
+        out_dict.set_item("qregs", self.qregs.clone_ref(py))?;
+        out_dict.set_item("cregs", self.cregs.clone_ref(py))?;
+        out_dict.set_item("global_phase", self.global_phase.clone())?;
+        out_dict.set_item(
+            "qubit_io_map",
+            self.qubit_io_map
+                .iter()
+                .enumerate()
+                .map(|(k, v)| (k, [v[0].index(), v[1].index()]))
+                .collect::<IndexMap<_, _, RandomState>>(),
+        )?;
+        out_dict.set_item(
+            "clbit_io_map",
+            self.clbit_io_map
+                .iter()
+                .enumerate()
+                .map(|(k, v)| (k, [v[0].index(), v[1].index()]))
+                .collect::<IndexMap<_, _, RandomState>>(),
+        )?;
+        out_dict.set_item("var_input_map", self.var_input_map.dict.clone_ref(py))?;
+        out_dict.set_item("var_output_map", self.var_output_map.dict.clone_ref(py))?;
+        out_dict.set_item("op_name", self.op_names.clone())?;
+        out_dict.set_item(
+            "vars_info",
+            self.vars_info
+                .iter()
+                .map(|(k, v)| {
+                    (
+                        k,
+                        (
+                            v.var.clone_ref(py),
+                            v.type_ as u8,
+                            v.in_node.index(),
+                            v.out_node.index(),
+                        ),
+                    )
+                })
+                .collect::<HashMap<_, _>>(),
+        )?;
+        out_dict.set_item("vars_by_type", self.vars_by_type.clone())?;
+        out_dict.set_item("qubits", self.qubits.bits())?;
+        out_dict.set_item("clbits", self.clbits.bits())?;
+        let mut nodes: Vec<PyObject> = Vec::with_capacity(self.dag.node_count());
+        for node_idx in self.dag.node_indices() {
+            let node_data = self.get_node(py, node_idx)?;
+            nodes.push((node_idx.index(), node_data).to_object(py));
+        }
+        out_dict.set_item("nodes", nodes)?;
+        out_dict.set_item(
+            "nodes_removed",
+            self.dag.node_count() != self.dag.node_bound(),
+        )?;
+        let mut edges: Vec<PyObject> = Vec::with_capacity(self.dag.edge_bound());
+        // edges are saved with none (deleted edges) instead of their index to save space
+        for i in 0..self.dag.edge_bound() {
+            let idx = EdgeIndex::new(i);
+            let edge = match self.dag.edge_weight(idx) {
+                Some(edge_w) => {
+                    let endpoints = self.dag.edge_endpoints(idx).unwrap();
+                    (
+                        endpoints.0.index(),
+                        endpoints.1.index(),
+                        edge_w.clone().to_pickle(py),
+                    )
+                        .to_object(py)
+                }
+                None => py.None(),
+            };
+            edges.push(edge);
+        }
+        out_dict.set_item("edges", edges)?;
+        Ok(out_dict.unbind())
+    }
+
+    fn __setstate__(&mut self, py: Python, state: PyObject) -> PyResult<()> {
+        let dict_state = state.downcast_bound::<PyDict>(py)?;
+        self.name = dict_state.get_item("name")?.unwrap().extract()?;
+        self.metadata = dict_state.get_item("metadata")?.unwrap().extract()?;
+        self.calibrations = dict_state.get_item("calibrations")?.unwrap().extract()?;
+        self.qregs = dict_state.get_item("qregs")?.unwrap().extract()?;
+        self.cregs = dict_state.get_item("cregs")?.unwrap().extract()?;
+        self.global_phase = dict_state.get_item("global_phase")?.unwrap().extract()?;
+        self.op_names = dict_state.get_item("op_name")?.unwrap().extract()?;
+        self.var_input_map = _VarIndexMap {
+            dict: dict_state.get_item("var_input_map")?.unwrap().extract()?,
+        };
+        self.var_output_map = _VarIndexMap {
+            dict: dict_state.get_item("var_output_map")?.unwrap().extract()?,
+        };
+        self.vars_by_type = dict_state.get_item("vars_by_type")?.unwrap().extract()?;
+        let binding = dict_state.get_item("vars_info")?.unwrap();
+        let vars_info_raw = binding.downcast::<PyDict>().unwrap();
+        self.vars_info = HashMap::with_capacity(vars_info_raw.len());
+        for (key, value) in vars_info_raw.iter() {
+            let val_tuple = value.downcast::<PyTuple>()?;
+            let info = DAGVarInfo {
+                var: val_tuple.get_item(0)?.unbind(),
+                type_: match val_tuple.get_item(1)?.extract::<u8>()? {
+                    0 => DAGVarType::Input,
+                    1 => DAGVarType::Capture,
+                    2 => DAGVarType::Declare,
+                    _ => return Err(PyValueError::new_err("Invalid var type")),
+                },
+                in_node: NodeIndex::new(val_tuple.get_item(2)?.extract()?),
+                out_node: NodeIndex::new(val_tuple.get_item(3)?.extract()?),
+            };
+            self.vars_info.insert(key.extract()?, info);
+        }
+
+        let binding = dict_state.get_item("qubits")?.unwrap();
+        let qubits_raw = binding.downcast::<PyList>().unwrap();
+        for bit in qubits_raw.iter() {
+            self.qubits.add(py, &bit, false)?;
+        }
+        let binding = dict_state.get_item("clbits")?.unwrap();
+        let clbits_raw = binding.downcast::<PyList>().unwrap();
+        for bit in clbits_raw.iter() {
+            self.clbits.add(py, &bit, false)?;
+        }
+        let binding = dict_state.get_item("qubit_io_map")?.unwrap();
+        let qubit_index_map_raw = binding.downcast::<PyDict>().unwrap();
+        self.qubit_io_map = Vec::with_capacity(qubit_index_map_raw.len());
+        for (_k, v) in qubit_index_map_raw.iter() {
+            let indices: [usize; 2] = v.extract()?;
+            self.qubit_io_map
+                .push([NodeIndex::new(indices[0]), NodeIndex::new(indices[1])]);
+        }
+        let binding = dict_state.get_item("clbit_io_map")?.unwrap();
+        let clbit_index_map_raw = binding.downcast::<PyDict>().unwrap();
+        self.clbit_io_map = Vec::with_capacity(clbit_index_map_raw.len());
+
+        for (_k, v) in clbit_index_map_raw.iter() {
+            let indices: [usize; 2] = v.extract()?;
+            self.clbit_io_map
+                .push([NodeIndex::new(indices[0]), NodeIndex::new(indices[1])]);
+        }
+        // Rebuild Graph preserving index holes:
+        let binding = dict_state.get_item("nodes")?.unwrap();
+        let nodes_lst = binding.downcast::<PyList>()?;
+        let binding = dict_state.get_item("edges")?.unwrap();
+        let edges_lst = binding.downcast::<PyList>()?;
+        let node_removed: bool = dict_state.get_item("nodes_removed")?.unwrap().extract()?;
+        self.dag = StableDiGraph::default();
+        if !node_removed {
+            for item in nodes_lst.iter() {
+                let node_w = item.downcast::<PyTuple>().unwrap().get_item(1).unwrap();
+                let weight = self.pack_into(py, &node_w)?;
+                self.dag.add_node(weight);
+            }
+        } else if nodes_lst.len() == 1 {
+            // graph has only one node, handle logic here to save one if in the loop later
+            let binding = nodes_lst.get_item(0).unwrap();
+            let item = binding.downcast::<PyTuple>().unwrap();
+            let node_idx: usize = item.get_item(0).unwrap().extract().unwrap();
+            let node_w = item.get_item(1).unwrap();
+
+            for _i in 0..node_idx {
+                self.dag.add_node(NodeType::QubitIn(Qubit(u32::MAX)));
+            }
+            let weight = self.pack_into(py, &node_w)?;
+            self.dag.add_node(weight);
+            for i in 0..node_idx {
+                self.dag.remove_node(NodeIndex::new(i));
+            }
+        } else {
+            let binding = nodes_lst.get_item(nodes_lst.len() - 1).unwrap();
+            let last_item = binding.downcast::<PyTuple>().unwrap();
+
+            // list of temporary nodes that will be removed later to re-create holes
+            let node_bound_1: usize = last_item.get_item(0).unwrap().extract().unwrap();
+            let mut tmp_nodes: Vec<NodeIndex> =
+                Vec::with_capacity(node_bound_1 + 1 - nodes_lst.len());
+
+            for item in nodes_lst {
+                let item = item.downcast::<PyTuple>().unwrap();
+                let next_index: usize = item.get_item(0).unwrap().extract().unwrap();
+                let weight: PyObject = item.get_item(1).unwrap().extract().unwrap();
+                while next_index > self.dag.node_bound() {
+                    // node does not exist
+                    let tmp_node = self.dag.add_node(NodeType::QubitIn(Qubit(u32::MAX)));
+                    tmp_nodes.push(tmp_node);
+                }
+                // add node to the graph, and update the next available node index
+                let weight = self.pack_into(py, weight.bind(py))?;
+                self.dag.add_node(weight);
+            }
+            // Remove any temporary nodes we added
+            for tmp_node in tmp_nodes {
+                self.dag.remove_node(tmp_node);
+            }
+        }
+
+        // to ensure O(1) on edge deletion, use a temporary node to store missing edges
+        let tmp_node = self.dag.add_node(NodeType::QubitIn(Qubit(u32::MAX)));
+
+        for item in edges_lst {
+            if item.is_none() {
+                // add a temporary edge that will be deleted later to re-create the hole
+                self.dag
+                    .add_edge(tmp_node, tmp_node, Wire::Qubit(Qubit(u32::MAX)));
+            } else {
+                let triple = item.downcast::<PyTuple>().unwrap();
+                let edge_p: usize = triple.get_item(0).unwrap().extract().unwrap();
+                let edge_c: usize = triple.get_item(1).unwrap().extract().unwrap();
+                let edge_w = Wire::from_pickle(&triple.get_item(2).unwrap())?;
+                self.dag
+                    .add_edge(NodeIndex::new(edge_p), NodeIndex::new(edge_c), edge_w);
+            }
+        }
+        self.dag.remove_node(tmp_node);
+        Ok(())
+    }
+
+    /// Returns the current sequence of registered :class:`.Qubit` instances as a list.
+    ///
+    /// .. warning::
+    ///
+    ///     Do not modify this list yourself.  It will invalidate the :class:`DAGCircuit` data
+    ///     structures.
+    ///
+    /// Returns:
+    ///     list(:class:`.Qubit`): The current sequence of registered qubits.
+    #[getter]
+    pub fn qubits(&self, py: Python<'_>) -> Py<PyList> {
+        self.qubits.cached().clone_ref(py)
+    }
+
+    /// Returns the current sequence of registered :class:`.Clbit`
+    /// instances as a list.
+    ///
+    /// .. warning::
+    ///
+    ///     Do not modify this list yourself.  It will invalidate the :class:`DAGCircuit` data
+    ///     structures.
+    ///
+    /// Returns:
+    ///     list(:class:`.Clbit`): The current sequence of registered clbits.
+    #[getter]
+    pub fn clbits(&self, py: Python<'_>) -> Py<PyList> {
+        self.clbits.cached().clone_ref(py)
+    }
+
+    /// Return a list of the wires in order.
+    #[getter]
+    fn get_wires(&self, py: Python<'_>) -> PyResult<Py<PyList>> {
+        let wires: Vec<&PyObject> = self
+            .qubits
+            .bits()
+            .iter()
+            .chain(self.clbits.bits().iter())
+            .collect();
+        let out_list = PyList::new_bound(py, wires);
+        for var_type_set in &self.vars_by_type {
+            for var in var_type_set.bind(py).iter() {
+                out_list.append(var)?;
+            }
+        }
+        Ok(out_list.unbind())
+    }
+
+    /// Returns the number of nodes in the dag.
+    #[getter]
+    fn get_node_counter(&self) -> usize {
+        self.dag.node_count()
+    }
+
+    /// Return the global phase of the circuit.
+    #[getter]
+    fn get_global_phase(&self) -> Param {
+        self.global_phase.clone()
+    }
+
+    /// Set the global phase of the circuit.
+    ///
+    /// Args:
+    ///     angle (float, :class:`.ParameterExpression`): The phase angle.
+    #[setter]
+    fn set_global_phase(&mut self, angle: Param) -> PyResult<()> {
+        match angle {
+            Param::Float(angle) => {
+                self.global_phase = Param::Float(angle.rem_euclid(2. * PI));
+            }
+            Param::ParameterExpression(angle) => {
+                self.global_phase = Param::ParameterExpression(angle);
+            }
+            Param::Obj(_) => return Err(PyTypeError::new_err("Invalid type for global phase")),
+        }
+        Ok(())
+    }
+
+    /// Return calibration dictionary.
+    ///
+    /// The custom pulse definition of a given gate is of the form
+    ///    {'gate_name': {(qubits, params): schedule}}
+    #[getter]
+    fn get_calibrations(&self) -> HashMap<String, Py<PyDict>> {
+        self.calibrations.clone()
+    }
+
+    /// Set the circuit calibration data from a dictionary of calibration definition.
+    ///
+    ///  Args:
+    ///      calibrations (dict): A dictionary of input in the format
+    ///          {'gate_name': {(qubits, gate_params): schedule}}
+    #[setter]
+    fn set_calibrations(&mut self, calibrations: HashMap<String, Py<PyDict>>) {
+        self.calibrations = calibrations;
+    }
+
+    /// Register a low-level, custom pulse definition for the given gate.
+    ///
+    /// Args:
+    ///     gate (Union[Gate, str]): Gate information.
+    ///     qubits (Union[int, Tuple[int]]): List of qubits to be measured.
+    ///     schedule (Schedule): Schedule information.
+    ///     params (Optional[List[Union[float, Parameter]]]): A list of parameters.
+    ///
+    /// Raises:
+    ///     Exception: if the gate is of type string and params is None.
+    fn add_calibration<'py>(
+        &mut self,
+        py: Python<'py>,
+        mut gate: Bound<'py, PyAny>,
+        qubits: Bound<'py, PyAny>,
+        schedule: Py<PyAny>,
+        mut params: Option<Bound<'py, PyAny>>,
+    ) -> PyResult<()> {
+        if gate.is_instance(imports::GATE.get_bound(py))? {
+            params = Some(gate.getattr(intern!(py, "params"))?);
+            gate = gate.getattr(intern!(py, "name"))?;
+        }
+
+        let params_tuple = if let Some(operands) = params {
+            let add_calibration = PyModule::from_code_bound(
+                py,
+                r#"
+import numpy as np
+
+def _format(operand):
+    try:
+        # Using float/complex value as a dict key is not good idea.
+        # This makes the mapping quite sensitive to the rounding error.
+        # However, the mechanism is already tied to the execution model (i.e. pulse gate)
+        # and we cannot easily update this rule.
+        # The same logic exists in QuantumCircuit.add_calibration.
+        evaluated = complex(operand)
+        if np.isreal(evaluated):
+            evaluated = float(evaluated.real)
+            if evaluated.is_integer():
+                evaluated = int(evaluated)
+        return evaluated
+    except TypeError:
+        # Unassigned parameter
+        return operand
+    "#,
+                "add_calibration.py",
+                "add_calibration",
+            )?;
+
+            let format = add_calibration.getattr("_format")?;
+            let mapped: PyResult<Vec<_>> = operands.iter()?.map(|p| format.call1((p?,))).collect();
+            PyTuple::new_bound(py, mapped?).into_any()
+        } else {
+            PyTuple::empty_bound(py).into_any()
+        };
+
+        let calibrations = self
+            .calibrations
+            .entry(gate.extract()?)
+            .or_insert_with(|| PyDict::new_bound(py).unbind())
+            .bind(py);
+
+        let qubits = if let Ok(qubits) = qubits.downcast::<PySequence>() {
+            qubits.to_tuple()?.into_any()
+        } else {
+            PyTuple::new_bound(py, [qubits]).into_any()
+        };
+        let key = PyTuple::new_bound(py, &[qubits.unbind(), params_tuple.into_any().unbind()]);
+        calibrations.set_item(key, schedule)?;
+        Ok(())
+    }
+
+    /// Return True if the dag has a calibration defined for the node operation. In this
+    /// case, the operation does not need to be translated to the device basis.
+    fn has_calibration_for(&self, py: Python, node: PyRef<DAGOpNode>) -> PyResult<bool> {
+        if !self
+            .calibrations
+            .contains_key(node.instruction.operation.name())
+        {
+            return Ok(false);
+        }
+        let mut params = Vec::new();
+        for p in &node.instruction.params {
+            if let Param::ParameterExpression(exp) = p {
+                let exp = exp.bind(py);
+                if !exp.getattr(intern!(py, "parameters"))?.is_truthy()? {
+                    let as_py_float = exp.call_method0(intern!(py, "__float__"))?;
+                    params.push(as_py_float.unbind());
+                    continue;
+                }
+            }
+            params.push(p.to_object(py));
+        }
+        let qubits: Vec<BitType> = self
+            .qubits
+            .map_bits(node.instruction.qubits.bind(py).iter())?
+            .map(|bit| bit.0)
+            .collect();
+        let qubits = PyTuple::new_bound(py, qubits);
+        let params = PyTuple::new_bound(py, params);
+        self.calibrations[node.instruction.operation.name()]
+            .bind(py)
+            .contains((qubits, params).to_object(py))
+    }
+
+    /// Remove all operation nodes with the given name.
+    fn remove_all_ops_named(&mut self, opname: &str) {
+        let mut to_remove = Vec::new();
+        for (id, weight) in self.dag.node_references() {
+            if let NodeType::Operation(packed) = &weight {
+                if opname == packed.op.name() {
+                    to_remove.push(id);
+                }
+            }
+        }
+        for node in to_remove {
+            self.remove_op_node(node);
+        }
+    }
+
+    /// Add individual qubit wires.
+    fn add_qubits(&mut self, py: Python, qubits: Vec<Bound<PyAny>>) -> PyResult<()> {
+        for bit in qubits.iter() {
+            if !bit.is_instance(imports::QUBIT.get_bound(py))? {
+                return Err(DAGCircuitError::new_err("not a Qubit instance."));
+            }
+
+            if self.qubits.find(bit).is_some() {
+                return Err(DAGCircuitError::new_err(format!(
+                    "duplicate qubits {}",
+                    bit
+                )));
+            }
+        }
+
+        for bit in qubits.iter() {
+            self.add_qubit_unchecked(py, bit)?;
+        }
+        Ok(())
+    }
+
+    /// Add individual qubit wires.
+    fn add_clbits(&mut self, py: Python, clbits: Vec<Bound<PyAny>>) -> PyResult<()> {
+        for bit in clbits.iter() {
+            if !bit.is_instance(imports::CLBIT.get_bound(py))? {
+                return Err(DAGCircuitError::new_err("not a Clbit instance."));
+            }
+
+            if self.clbits.find(bit).is_some() {
+                return Err(DAGCircuitError::new_err(format!(
+                    "duplicate clbits {}",
+                    bit
+                )));
+            }
+        }
+
+        for bit in clbits.iter() {
+            self.add_clbit_unchecked(py, bit)?;
+        }
+        Ok(())
+    }
+
+    /// Add all wires in a quantum register.
+    fn add_qreg(&mut self, py: Python, qreg: &Bound<PyAny>) -> PyResult<()> {
+        if !qreg.is_instance(imports::QUANTUM_REGISTER.get_bound(py))? {
+            return Err(DAGCircuitError::new_err("not a QuantumRegister instance."));
+        }
+
+        let register_name = qreg.getattr(intern!(py, "name"))?;
+        if self.qregs.bind(py).contains(&register_name)? {
+            return Err(DAGCircuitError::new_err(format!(
+                "duplicate register {}",
+                register_name
+            )));
+        }
+        self.qregs.bind(py).set_item(&register_name, qreg)?;
+
+        for (index, bit) in qreg.iter()?.enumerate() {
+            let bit = bit?;
+            if self.qubits.find(&bit).is_none() {
+                self.add_qubit_unchecked(py, &bit)?;
+            }
+            let locations: PyRef<BitLocations> = self
+                .qubit_locations
+                .bind(py)
+                .get_item(&bit)?
+                .unwrap()
+                .extract()?;
+            locations.registers.bind(py).append((qreg, index))?;
+        }
+        Ok(())
+    }
+
+    /// Add all wires in a classical register.
+    fn add_creg(&mut self, py: Python, creg: &Bound<PyAny>) -> PyResult<()> {
+        if !creg.is_instance(imports::CLASSICAL_REGISTER.get_bound(py))? {
+            return Err(DAGCircuitError::new_err(
+                "not a ClassicalRegister instance.",
+            ));
+        }
+
+        let register_name = creg.getattr(intern!(py, "name"))?;
+        if self.cregs.bind(py).contains(&register_name)? {
+            return Err(DAGCircuitError::new_err(format!(
+                "duplicate register {}",
+                register_name
+            )));
+        }
+        self.cregs.bind(py).set_item(register_name, creg)?;
+
+        for (index, bit) in creg.iter()?.enumerate() {
+            let bit = bit?;
+            if self.clbits.find(&bit).is_none() {
+                self.add_clbit_unchecked(py, &bit)?;
+            }
+            let locations: PyRef<BitLocations> = self
+                .clbit_locations
+                .bind(py)
+                .get_item(&bit)?
+                .unwrap()
+                .extract()?;
+            locations.registers.bind(py).append((creg, index))?;
+        }
+        Ok(())
+    }
+
+    /// Finds locations in the circuit, by mapping the Qubit and Clbit to positional index
+    /// BitLocations is defined as: BitLocations = namedtuple("BitLocations", ("index", "registers"))
+    ///
+    /// Args:
+    ///     bit (Bit): The bit to locate.
+    ///
+    /// Returns:
+    ///     namedtuple(int, List[Tuple(Register, int)]): A 2-tuple. The first element (``index``)
+    ///         contains the index at which the ``Bit`` can be found (in either
+    ///         :obj:`~DAGCircuit.qubits`, :obj:`~DAGCircuit.clbits`, depending on its
+    ///         type). The second element (``registers``) is a list of ``(register, index)``
+    ///         pairs with an entry for each :obj:`~Register` in the circuit which contains the
+    ///         :obj:`~Bit` (and the index in the :obj:`~Register` at which it can be found).
+    ///
+    ///   Raises:
+    ///     DAGCircuitError: If the supplied :obj:`~Bit` was of an unknown type.
+    ///     DAGCircuitError: If the supplied :obj:`~Bit` could not be found on the circuit.
+    fn find_bit<'py>(&self, py: Python<'py>, bit: &Bound<PyAny>) -> PyResult<Bound<'py, PyAny>> {
+        if bit.is_instance(imports::QUBIT.get_bound(py))? {
+            return self.qubit_locations.bind(py).get_item(bit)?.ok_or_else(|| {
+                DAGCircuitError::new_err(format!(
+                    "Could not locate provided bit: {}. Has it been added to the DAGCircuit?",
+                    bit
+                ))
+            });
+        }
+
+        if bit.is_instance(imports::CLBIT.get_bound(py))? {
+            return self.clbit_locations.bind(py).get_item(bit)?.ok_or_else(|| {
+                DAGCircuitError::new_err(format!(
+                    "Could not locate provided bit: {}. Has it been added to the DAGCircuit?",
+                    bit
+                ))
+            });
+        }
+
+        Err(DAGCircuitError::new_err(format!(
+            "Could not locate bit of unknown type: {}",
+            bit.get_type()
+        )))
+    }
+
+    /// Remove classical bits from the circuit. All bits MUST be idle.
+    /// Any registers with references to at least one of the specified bits will
+    /// also be removed.
+    ///
+    /// .. warning::
+    ///     This method is rather slow, since it must iterate over the entire
+    ///     DAG to fix-up bit indices.
+    ///
+    /// Args:
+    ///     clbits (List[Clbit]): The bits to remove.
+    ///
+    /// Raises:
+    ///     DAGCircuitError: a clbit is not a :obj:`.Clbit`, is not in the circuit,
+    ///         or is not idle.
+    #[pyo3(signature = (*clbits))]
+    fn remove_clbits(&mut self, py: Python, clbits: &Bound<PyTuple>) -> PyResult<()> {
+        let mut non_bits = Vec::new();
+        for bit in clbits.iter() {
+            if !bit.is_instance(imports::CLBIT.get_bound(py))? {
+                non_bits.push(bit);
+            }
+        }
+        if !non_bits.is_empty() {
+            return Err(DAGCircuitError::new_err(format!(
+                "clbits not of type Clbit: {:?}",
+                non_bits
+            )));
+        }
+
+        let bit_iter = match self.clbits.map_bits(clbits.iter()) {
+            Ok(bit_iter) => bit_iter,
+            Err(_) => {
+                return Err(DAGCircuitError::new_err(format!(
+                    "clbits not in circuit: {:?}",
+                    clbits
+                )))
+            }
+        };
+        let clbits: HashSet<Clbit> = bit_iter.collect();
+        let mut busy_bits = Vec::new();
+        for bit in clbits.iter() {
+            if !self.is_wire_idle(py, &Wire::Clbit(*bit))? {
+                busy_bits.push(self.clbits.get(*bit).unwrap());
+            }
+        }
+
+        if !busy_bits.is_empty() {
+            return Err(DAGCircuitError::new_err(format!(
+                "clbits not idle: {:?}",
+                busy_bits
+            )));
+        }
+
+        // Remove any references to bits.
+        let mut cregs_to_remove = Vec::new();
+        for creg in self.cregs.bind(py).values() {
+            for bit in creg.iter()? {
+                let bit = bit?;
+                if clbits.contains(&self.clbits.find(&bit).unwrap()) {
+                    cregs_to_remove.push(creg);
+                    break;
+                }
+            }
+        }
+        self.remove_cregs(py, &PyTuple::new_bound(py, cregs_to_remove))?;
+
+        // Remove DAG in/out nodes etc.
+        for bit in clbits.iter() {
+            self.remove_idle_wire(py, Wire::Clbit(*bit))?;
+        }
+
+        // Copy the current clbit mapping so we can use it while remapping
+        // wires used on edges and in operation cargs.
+        let old_clbits = self.clbits.clone();
+
+        // Remove the clbit indices, which will invalidate our mapping of Clbit to
+        // Python bits throughout the entire DAG.
+        self.clbits.remove_indices(py, clbits.clone())?;
+
+        // Update input/output maps to use new Clbits.
+        let io_mapping: HashMap<Clbit, [NodeIndex; 2]> = self
+            .clbit_io_map
+            .drain(..)
+            .enumerate()
+            .filter_map(|(k, v)| {
+                let clbit = Clbit(k as u32);
+                if clbits.contains(&clbit) {
+                    None
+                } else {
+                    Some((
+                        self.clbits
+                            .find(old_clbits.get(Clbit(k as u32)).unwrap().bind(py))
+                            .unwrap(),
+                        v,
+                    ))
+                }
+            })
+            .collect();
+
+        self.clbit_io_map = (0..io_mapping.len())
+            .map(|idx| {
+                let clbit = Clbit(idx as u32);
+                io_mapping[&clbit]
+            })
+            .collect();
+
+        // Update edges to use the new Clbits.
+        for edge_weight in self.dag.edge_weights_mut() {
+            if let Wire::Clbit(c) = edge_weight {
+                *c = self
+                    .clbits
+                    .find(old_clbits.get(*c).unwrap().bind(py))
+                    .unwrap();
+            }
+        }
+
+        // Update operation cargs to use the new Clbits.
+        for node_weight in self.dag.node_weights_mut() {
+            match node_weight {
+                NodeType::Operation(op) => {
+                    let cargs = self.cargs_cache.intern(op.clbits);
+                    let carg_bits = old_clbits
+                        .map_indices(&cargs[..])
+                        .map(|b| b.bind(py).clone());
+                    let mapped_cargs = self.clbits.map_bits(carg_bits)?.collect();
+                    let clbits = Interner::intern(&mut self.cargs_cache, mapped_cargs)?;
+                    op.clbits = clbits;
+                }
+                NodeType::ClbitIn(c) | NodeType::ClbitOut(c) => {
+                    *c = self
+                        .clbits
+                        .find(old_clbits.get(*c).unwrap().bind(py))
+                        .unwrap();
+                }
+                _ => (),
+            }
+        }
+
+        // Update bit locations.
+        let bit_locations = self.clbit_locations.bind(py);
+        for (i, bit) in self.clbits.bits().iter().enumerate() {
+            let raw_loc = bit_locations.get_item(bit)?.unwrap();
+            let loc = raw_loc.downcast::<BitLocations>().unwrap();
+            loc.borrow_mut().index = i;
+            bit_locations.set_item(bit, loc)?;
+        }
+        Ok(())
+    }
+
+    /// Remove classical registers from the circuit, leaving underlying bits
+    /// in place.
+    ///
+    /// Raises:
+    ///     DAGCircuitError: a creg is not a ClassicalRegister, or is not in
+    ///     the circuit.
+    #[pyo3(signature = (*cregs))]
+    fn remove_cregs(&mut self, py: Python, cregs: &Bound<PyTuple>) -> PyResult<()> {
+        let mut non_regs = Vec::new();
+        let mut unknown_regs = Vec::new();
+        let self_bound_cregs = self.cregs.bind(py);
+        for reg in cregs.iter() {
+            if !reg.is_instance(imports::CLASSICAL_REGISTER.get_bound(py))? {
+                non_regs.push(reg);
+            } else if let Some(existing_creg) =
+                self_bound_cregs.get_item(&reg.getattr(intern!(py, "name"))?)?
+            {
+                if !existing_creg.eq(&reg)? {
+                    unknown_regs.push(reg);
+                }
+            } else {
+                unknown_regs.push(reg);
+            }
+        }
+        if !non_regs.is_empty() {
+            return Err(DAGCircuitError::new_err(format!(
+                "cregs not of type ClassicalRegister: {:?}",
+                non_regs
+            )));
+        }
+        if !unknown_regs.is_empty() {
+            return Err(DAGCircuitError::new_err(format!(
+                "cregs not in circuit: {:?}",
+                unknown_regs
+            )));
+        }
+
+        for creg in cregs {
+            self.cregs
+                .bind(py)
+                .del_item(creg.getattr(intern!(py, "name"))?)?;
+            for (i, bit) in creg.iter()?.enumerate() {
+                let bit = bit?;
+                let bit_position = self
+                    .clbit_locations
+                    .bind(py)
+                    .get_item(bit)?
+                    .unwrap()
+                    .downcast_into_exact::<BitLocations>()?;
+                bit_position
+                    .borrow()
+                    .registers
+                    .bind(py)
+                    .as_any()
+                    .call_method1(intern!(py, "remove"), ((&creg, i),))?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Remove quantum bits from the circuit. All bits MUST be idle.
+    /// Any registers with references to at least one of the specified bits will
+    /// also be removed.
+    ///
+    /// .. warning::
+    ///     This method is rather slow, since it must iterate over the entire
+    ///     DAG to fix-up bit indices.
+    ///
+    /// Args:
+    ///     qubits (List[~qiskit.circuit.Qubit]): The bits to remove.
+    ///
+    /// Raises:
+    ///     DAGCircuitError: a qubit is not a :obj:`~.circuit.Qubit`, is not in the circuit,
+    ///         or is not idle.
+    #[pyo3(signature = (*qubits))]
+    fn remove_qubits(&mut self, py: Python, qubits: &Bound<PyTuple>) -> PyResult<()> {
+        let mut non_qbits = Vec::new();
+        for bit in qubits.iter() {
+            if !bit.is_instance(imports::QUBIT.get_bound(py))? {
+                non_qbits.push(bit);
+            }
+        }
+        if !non_qbits.is_empty() {
+            return Err(DAGCircuitError::new_err(format!(
+                "qubits not of type Qubit: {:?}",
+                non_qbits
+            )));
+        }
+
+        let bit_iter = match self.qubits.map_bits(qubits.iter()) {
+            Ok(bit_iter) => bit_iter,
+            Err(_) => {
+                return Err(DAGCircuitError::new_err(format!(
+                    "qubits not in circuit: {:?}",
+                    qubits
+                )))
+            }
+        };
+        let qubits: HashSet<Qubit> = bit_iter.collect();
+
+        let mut busy_bits = Vec::new();
+        for bit in qubits.iter() {
+            if !self.is_wire_idle(py, &Wire::Qubit(*bit))? {
+                busy_bits.push(self.qubits.get(*bit).unwrap());
+            }
+        }
+
+        if !busy_bits.is_empty() {
+            return Err(DAGCircuitError::new_err(format!(
+                "qubits not idle: {:?}",
+                busy_bits
+            )));
+        }
+
+        // Remove any references to bits.
+        let mut qregs_to_remove = Vec::new();
+        for qreg in self.qregs.bind(py).values() {
+            for bit in qreg.iter()? {
+                let bit = bit?;
+                if qubits.contains(&self.qubits.find(&bit).unwrap()) {
+                    qregs_to_remove.push(qreg);
+                    break;
+                }
+            }
+        }
+        self.remove_qregs(py, &PyTuple::new_bound(py, qregs_to_remove))?;
+
+        // Remove DAG in/out nodes etc.
+        for bit in qubits.iter() {
+            self.remove_idle_wire(py, Wire::Qubit(*bit))?;
+        }
+
+        // Copy the current qubit mapping so we can use it while remapping
+        // wires used on edges and in operation qargs.
+        let old_qubits = self.qubits.clone();
+
+        // Remove the qubit indices, which will invalidate our mapping of Qubit to
+        // Python bits throughout the entire DAG.
+        self.qubits.remove_indices(py, qubits.clone())?;
+
+        // Update input/output maps to use new Qubits.
+        let io_mapping: HashMap<Qubit, [NodeIndex; 2]> = self
+            .qubit_io_map
+            .drain(..)
+            .enumerate()
+            .filter_map(|(k, v)| {
+                let qubit = Qubit(k as u32);
+                if qubits.contains(&qubit) {
+                    None
+                } else {
+                    Some((
+                        self.qubits
+                            .find(old_qubits.get(qubit).unwrap().bind(py))
+                            .unwrap(),
+                        v,
+                    ))
+                }
+            })
+            .collect();
+
+        self.qubit_io_map = (0..io_mapping.len())
+            .map(|idx| {
+                let qubit = Qubit(idx as u32);
+                io_mapping[&qubit]
+            })
+            .collect();
+
+        // Update edges to use the new Qubits.
+        for edge_weight in self.dag.edge_weights_mut() {
+            if let Wire::Qubit(b) = edge_weight {
+                *b = self
+                    .qubits
+                    .find(old_qubits.get(*b).unwrap().bind(py))
+                    .unwrap();
+            }
+        }
+
+        // Update operation qargs to use the new Qubits.
+        for node_weight in self.dag.node_weights_mut() {
+            match node_weight {
+                NodeType::Operation(op) => {
+                    let qargs = self.qargs_cache.intern(op.qubits);
+                    let qarg_bits = old_qubits
+                        .map_indices(&qargs[..])
+                        .map(|b| b.bind(py).clone());
+                    let mapped_qargs = self.qubits.map_bits(qarg_bits)?.collect();
+                    let qubits = Interner::intern(&mut self.qargs_cache, mapped_qargs)?;
+                    op.qubits = qubits;
+                }
+                NodeType::QubitIn(q) | NodeType::QubitOut(q) => {
+                    *q = self
+                        .qubits
+                        .find(old_qubits.get(*q).unwrap().bind(py))
+                        .unwrap();
+                }
+                _ => (),
+            }
+        }
+
+        // Update bit locations.
+        let bit_locations = self.qubit_locations.bind(py);
+        for (i, bit) in self.qubits.bits().iter().enumerate() {
+            let raw_loc = bit_locations.get_item(bit)?.unwrap();
+            let loc = raw_loc.downcast::<BitLocations>().unwrap();
+            loc.borrow_mut().index = i;
+            bit_locations.set_item(bit, loc)?;
+        }
+        Ok(())
+    }
+
+    /// Remove quantum registers from the circuit, leaving underlying bits
+    /// in place.
+    ///
+    /// Raises:
+    ///     DAGCircuitError: a qreg is not a QuantumRegister, or is not in
+    ///     the circuit.
+    #[pyo3(signature = (*qregs))]
+    fn remove_qregs(&mut self, py: Python, qregs: &Bound<PyTuple>) -> PyResult<()> {
+        let mut non_regs = Vec::new();
+        let mut unknown_regs = Vec::new();
+        let self_bound_qregs = self.qregs.bind(py);
+        for reg in qregs.iter() {
+            if !reg.is_instance(imports::QUANTUM_REGISTER.get_bound(py))? {
+                non_regs.push(reg);
+            } else if let Some(existing_qreg) =
+                self_bound_qregs.get_item(&reg.getattr(intern!(py, "name"))?)?
+            {
+                if !existing_qreg.eq(&reg)? {
+                    unknown_regs.push(reg);
+                }
+            } else {
+                unknown_regs.push(reg);
+            }
+        }
+        if !non_regs.is_empty() {
+            return Err(DAGCircuitError::new_err(format!(
+                "qregs not of type QuantumRegister: {:?}",
+                non_regs
+            )));
+        }
+        if !unknown_regs.is_empty() {
+            return Err(DAGCircuitError::new_err(format!(
+                "qregs not in circuit: {:?}",
+                unknown_regs
+            )));
+        }
+
+        for qreg in qregs {
+            self.qregs
+                .bind(py)
+                .del_item(qreg.getattr(intern!(py, "name"))?)?;
+            for (i, bit) in qreg.iter()?.enumerate() {
+                let bit = bit?;
+                let bit_position = self
+                    .qubit_locations
+                    .bind(py)
+                    .get_item(bit)?
+                    .unwrap()
+                    .downcast_into_exact::<BitLocations>()?;
+                bit_position
+                    .borrow()
+                    .registers
+                    .bind(py)
+                    .as_any()
+                    .call_method1(intern!(py, "remove"), ((&qreg, i),))?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Verify that the condition is valid.
+    ///
+    /// Args:
+    ///     name (string): used for error reporting
+    ///     condition (tuple or None): a condition tuple (ClassicalRegister, int) or (Clbit, bool)
+    ///
+    /// Raises:
+    ///     DAGCircuitError: if conditioning on an invalid register
+    fn _check_condition(&self, py: Python, name: &str, condition: &Bound<PyAny>) -> PyResult<()> {
+        if condition.is_none() {
+            return Ok(());
+        }
+
+        let resources = self.control_flow_module.condition_resources(condition)?;
+        for reg in resources.cregs.bind(py) {
+            if !self
+                .cregs
+                .bind(py)
+                .contains(reg.getattr(intern!(py, "name"))?)?
+            {
+                return Err(DAGCircuitError::new_err(format!(
+                    "invalid creg in condition for {}",
+                    name
+                )));
+            }
+        }
+
+        for bit in resources.clbits.bind(py) {
+            if self.clbits.find(&bit).is_none() {
+                return Err(DAGCircuitError::new_err(format!(
+                    "invalid clbits in condition for {}",
+                    name
+                )));
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Return a copy of self with the same structure but empty.
+    ///
+    /// That structure includes:
+    ///     * name and other metadata
+    ///     * global phase
+    ///     * duration
+    ///     * all the qubits and clbits, including the registers.
+    ///
+    /// Returns:
+    ///     DAGCircuit: An empty copy of self.
+    #[pyo3(signature = (*, vars_mode="alike"))]
+    fn copy_empty_like(&self, py: Python, vars_mode: &str) -> PyResult<Self> {
+        let mut target_dag = DAGCircuit::new(py)?;
+        target_dag.name = self.name.as_ref().map(|n| n.clone_ref(py));
+        target_dag.global_phase = self.global_phase.clone();
+        target_dag.duration = self.duration.as_ref().map(|d| d.clone_ref(py));
+        target_dag.unit.clone_from(&self.unit);
+        target_dag.metadata = self.metadata.as_ref().map(|m| m.clone_ref(py));
+        target_dag.qargs_cache = self.qargs_cache.clone();
+        target_dag.cargs_cache = self.cargs_cache.clone();
+
+        for bit in self.qubits.bits() {
+            target_dag.add_qubit_unchecked(py, bit.bind(py))?;
+        }
+        for bit in self.clbits.bits() {
+            target_dag.add_clbit_unchecked(py, bit.bind(py))?;
+        }
+        for reg in self.qregs.bind(py).values() {
+            target_dag.add_qreg(py, &reg)?;
+        }
+        for reg in self.cregs.bind(py).values() {
+            target_dag.add_creg(py, &reg)?;
+        }
+        if vars_mode == "alike" {
+            for var in self.vars_by_type[DAGVarType::Input as usize]
+                .bind(py)
+                .iter()
+            {
+                target_dag.add_var(py, &var, DAGVarType::Input)?;
+            }
+            for var in self.vars_by_type[DAGVarType::Capture as usize]
+                .bind(py)
+                .iter()
+            {
+                target_dag.add_var(py, &var, DAGVarType::Capture)?;
+            }
+            for var in self.vars_by_type[DAGVarType::Declare as usize]
+                .bind(py)
+                .iter()
+            {
+                target_dag.add_var(py, &var, DAGVarType::Declare)?;
+            }
+        } else if vars_mode == "captures" {
+            for var in self.vars_by_type[DAGVarType::Input as usize]
+                .bind(py)
+                .iter()
+            {
+                target_dag.add_var(py, &var, DAGVarType::Capture)?;
+            }
+            for var in self.vars_by_type[DAGVarType::Capture as usize]
+                .bind(py)
+                .iter()
+            {
+                target_dag.add_var(py, &var, DAGVarType::Capture)?;
+            }
+            for var in self.vars_by_type[DAGVarType::Declare as usize]
+                .bind(py)
+                .iter()
+            {
+                target_dag.add_var(py, &var, DAGVarType::Capture)?;
+            }
+        } else if vars_mode != "drop" {
+            return Err(PyValueError::new_err(format!(
+                "unknown vars_mode: '{}'",
+                vars_mode
+            )));
+        }
+
+        Ok(target_dag)
+    }
+
+    #[pyo3(signature=(node, check=false))]
+    fn _apply_op_node_back(
+        &mut self,
+        py: Python,
+        node: &Bound<PyAny>,
+        check: bool,
+    ) -> PyResult<()> {
+        if let NodeType::Operation(inst) = self.pack_into(py, node)? {
+            if check {
+                self.check_op_addition(py, &inst)?;
+            }
+
+            self.push_back(py, inst)?;
+            Ok(())
+        } else {
+            Err(PyTypeError::new_err("Invalid node type input"))
+        }
+    }
+
+    /// Apply an operation to the output of the circuit.
+    ///
+    /// Args:
+    ///     op (qiskit.circuit.Operation): the operation associated with the DAG node
+    ///     qargs (tuple[~qiskit.circuit.Qubit]): qubits that op will be applied to
+    ///     cargs (tuple[Clbit]): cbits that op will be applied to
+    ///     check (bool): If ``True`` (default), this function will enforce that the
+    ///         :class:`.DAGCircuit` data-structure invariants are maintained (all ``qargs`` are
+    ///         :class:`~.circuit.Qubit`\\ s, all are in the DAG, etc).  If ``False``, the caller *must*
+    ///         uphold these invariants itself, but the cost of several checks will be skipped.
+    ///         This is most useful when building a new DAG from a source of known-good nodes.
+    /// Returns:
+    ///     DAGOpNode: the node for the op that was added to the dag
+    ///
+    /// Raises:
+    ///     DAGCircuitError: if a leaf node is connected to multiple outputs
+    #[pyo3(name = "apply_operation_back", signature = (op, qargs=None, cargs=None, *, check=true))]
+    fn py_apply_operation_back(
+        &mut self,
+        py: Python,
+        op: Bound<PyAny>,
+        qargs: Option<TupleLikeArg>,
+        cargs: Option<TupleLikeArg>,
+        check: bool,
+    ) -> PyResult<Py<PyAny>> {
+        let py_op = op.extract::<OperationFromPython>()?;
+        let qargs = qargs.map(|q| q.value);
+        let cargs = cargs.map(|c| c.value);
+        let node = {
+            let qubits_id = Interner::intern(
+                &mut self.qargs_cache,
+                self.qubits.map_bits(qargs.iter().flatten())?.collect(),
+            )?;
+            let clbits_id = Interner::intern(
+                &mut self.cargs_cache,
+                self.clbits.map_bits(cargs.iter().flatten())?.collect(),
+            )?;
+            let instr = PackedInstruction {
+                op: py_op.operation,
+                qubits: qubits_id,
+                clbits: clbits_id,
+                params: (!py_op.params.is_empty()).then(|| Box::new(py_op.params)),
+                extra_attrs: py_op.extra_attrs,
+                #[cfg(feature = "cache_pygates")]
+                py_op: op.unbind().into(),
+            };
+
+            if check {
+                self.check_op_addition(py, &instr)?;
+            }
+            self.push_back(py, instr)?
+        };
+
+        self.get_node(py, node)
+    }
+
+    /// Apply an operation to the input of the circuit.
+    ///
+    /// Args:
+    ///     op (qiskit.circuit.Operation): the operation associated with the DAG node
+    ///     qargs (tuple[~qiskit.circuit.Qubit]): qubits that op will be applied to
+    ///     cargs (tuple[Clbit]): cbits that op will be applied to
+    ///     check (bool): If ``True`` (default), this function will enforce that the
+    ///         :class:`.DAGCircuit` data-structure invariants are maintained (all ``qargs`` are
+    ///         :class:`~.circuit.Qubit`\\ s, all are in the DAG, etc).  If ``False``, the caller *must*
+    ///         uphold these invariants itself, but the cost of several checks will be skipped.
+    ///         This is most useful when building a new DAG from a source of known-good nodes.
+    /// Returns:
+    ///     DAGOpNode: the node for the op that was added to the dag
+    ///
+    /// Raises:
+    ///     DAGCircuitError: if initial nodes connected to multiple out edges
+    #[pyo3(name = "apply_operation_front", signature = (op, qargs=None, cargs=None, *, check=true))]
+    fn py_apply_operation_front(
+        &mut self,
+        py: Python,
+        op: Bound<PyAny>,
+        qargs: Option<TupleLikeArg>,
+        cargs: Option<TupleLikeArg>,
+        check: bool,
+    ) -> PyResult<Py<PyAny>> {
+        let py_op = op.extract::<OperationFromPython>()?;
+        let qargs = qargs.map(|q| q.value);
+        let cargs = cargs.map(|c| c.value);
+        let node = {
+            let qubits_id = Interner::intern(
+                &mut self.qargs_cache,
+                self.qubits.map_bits(qargs.iter().flatten())?.collect(),
+            )?;
+            let clbits_id = Interner::intern(
+                &mut self.cargs_cache,
+                self.clbits.map_bits(cargs.iter().flatten())?.collect(),
+            )?;
+            let instr = PackedInstruction {
+                op: py_op.operation,
+                qubits: qubits_id,
+                clbits: clbits_id,
+                params: (!py_op.params.is_empty()).then(|| Box::new(py_op.params)),
+                extra_attrs: py_op.extra_attrs,
+                #[cfg(feature = "cache_pygates")]
+                py_op: op.unbind().into(),
+            };
+
+            if check {
+                self.check_op_addition(py, &instr)?;
+            }
+            self.push_front(py, instr)?
+        };
+
+        self.get_node(py, node)
+    }
+
+    /// Compose the ``other`` circuit onto the output of this circuit.
+    ///
+    /// A subset of input wires of ``other`` are mapped
+    /// to a subset of output wires of this circuit.
+    ///
+    /// ``other`` can be narrower or of equal width to ``self``.
+    ///
+    /// Args:
+    ///     other (DAGCircuit): circuit to compose with self
+    ///     qubits (list[~qiskit.circuit.Qubit|int]): qubits of self to compose onto.
+    ///     clbits (list[Clbit|int]): clbits of self to compose onto.
+    ///     front (bool): If True, front composition will be performed (not implemented yet)
+    ///     inplace (bool): If True, modify the object. Otherwise return composed circuit.
+    ///     inline_captures (bool): If ``True``, variables marked as "captures" in the ``other`` DAG
+    ///         will be inlined onto existing uses of those same variables in ``self``.  If ``False``,
+    ///         all variables in ``other`` are required to be distinct from ``self``, and they will
+    ///         be added to ``self``.
+    ///
+    /// ..
+    ///     Note: unlike `QuantumCircuit.compose`, there's no `var_remap` argument here.  That's
+    ///     because the `DAGCircuit` inner-block structure isn't set up well to allow the recursion,
+    ///     and `DAGCircuit.compose` is generally only used to rebuild a DAG from layers within
+    ///     itself than to join unrelated circuits.  While there's no strong motivating use-case
+    ///     (unlike the `QuantumCircuit` equivalent), it's safer and more performant to not provide
+    ///     the option.
+    ///
+    /// Returns:
+    ///    DAGCircuit: the composed dag (returns None if inplace==True).
+    ///
+    /// Raises:
+    ///     DAGCircuitError: if ``other`` is wider or there are duplicate edge mappings.
+    #[allow(clippy::too_many_arguments)]
+    #[pyo3(signature = (other, qubits=None, clbits=None, front=false, inplace=true, *, inline_captures=false))]
+    fn compose(
+        slf: PyRefMut<Self>,
+        py: Python,
+        other: &DAGCircuit,
+        qubits: Option<Bound<PyList>>,
+        clbits: Option<Bound<PyList>>,
+        front: bool,
+        inplace: bool,
+        inline_captures: bool,
+    ) -> PyResult<Option<PyObject>> {
+        if front {
+            return Err(DAGCircuitError::new_err(
+                "Front composition not supported yet.",
+            ));
+        }
+
+        if other.qubits.len() > slf.qubits.len() || other.clbits.len() > slf.clbits.len() {
+            return Err(DAGCircuitError::new_err(
+                "Trying to compose with another DAGCircuit which has more 'in' edges.",
+            ));
+        }
+
+        // Number of qubits and clbits must match number in circuit or None
+        let identity_qubit_map = other
+            .qubits
+            .bits()
+            .iter()
+            .zip(slf.qubits.bits())
+            .into_py_dict_bound(py);
+        let identity_clbit_map = other
+            .clbits
+            .bits()
+            .iter()
+            .zip(slf.clbits.bits())
+            .into_py_dict_bound(py);
+
+        let qubit_map: Bound<PyDict> = match qubits {
+            None => identity_qubit_map.clone(),
+            Some(qubits) => {
+                if qubits.len() != other.qubits.len() {
+                    return Err(DAGCircuitError::new_err(concat!(
+                        "Number of items in qubits parameter does not",
+                        " match number of qubits in the circuit."
+                    )));
+                }
+
+                let self_qubits = slf.qubits.cached().bind(py);
+                let other_qubits = other.qubits.cached().bind(py);
+                let dict = PyDict::new_bound(py);
+                for (i, q) in qubits.iter().enumerate() {
+                    let q = if q.is_instance_of::<PyInt>() {
+                        self_qubits.get_item(q.extract()?)?
+                    } else {
+                        q
+                    };
+
+                    dict.set_item(other_qubits.get_item(i)?, q)?;
+                }
+                dict
+            }
+        };
+
+        let clbit_map: Bound<PyDict> = match clbits {
+            None => identity_clbit_map.clone(),
+            Some(clbits) => {
+                if clbits.len() != other.clbits.len() {
+                    return Err(DAGCircuitError::new_err(concat!(
+                        "Number of items in clbits parameter does not",
+                        " match number of clbits in the circuit."
+                    )));
+                }
+
+                let self_clbits = slf.clbits.cached().bind(py);
+                let other_clbits = other.clbits.cached().bind(py);
+                let dict = PyDict::new_bound(py);
+                for (i, q) in clbits.iter().enumerate() {
+                    let q = if q.is_instance_of::<PyInt>() {
+                        self_clbits.get_item(q.extract()?)?
+                    } else {
+                        q
+                    };
+
+                    dict.set_item(other_clbits.get_item(i)?, q)?;
+                }
+                dict
+            }
+        };
+
+        let edge_map = if qubit_map.is_empty() && clbit_map.is_empty() {
+            // try to do a 1-1 mapping in order
+            identity_qubit_map
+                .iter()
+                .chain(identity_clbit_map.iter())
+                .into_py_dict_bound(py)
+        } else {
+            qubit_map
+                .iter()
+                .chain(clbit_map.iter())
+                .into_py_dict_bound(py)
+        };
+
+        // Chck duplicates in wire map.
+        {
+            let edge_map_values: Vec<_> = edge_map.values().iter().collect();
+            if PySet::new_bound(py, edge_map_values.as_slice())?.len() != edge_map.len() {
+                return Err(DAGCircuitError::new_err("duplicates in wire_map"));
+            }
+        }
+
+        // Compose
+        let mut dag: PyRefMut<DAGCircuit> = if inplace {
+            slf
+        } else {
+            Py::new(py, slf.clone())?.into_bound(py).borrow_mut()
+        };
+
+        dag.global_phase = add_global_phase(py, &dag.global_phase, &other.global_phase)?;
+
+        for (gate, cals) in other.calibrations.iter() {
+            let calibrations = match dag.calibrations.get(gate) {
+                Some(calibrations) => calibrations,
+                None => {
+                    dag.calibrations
+                        .insert(gate.clone(), PyDict::new_bound(py).unbind());
+                    &dag.calibrations[gate]
+                }
+            };
+            calibrations.bind(py).update(cals.bind(py).as_mapping())?;
+        }
+
+        // This is all the handling we need for realtime variables, if there's no remapping. They:
+        //
+        // * get added to the DAG and then operations involving them get appended on normally.
+        // * get inlined onto an existing variable, then operations get appended normally.
+        // * there's a clash or a failed inlining, and we just raise an error.
+        //
+        // Notably if there's no remapping, there's no need to recurse into control-flow or to do any
+        // Var rewriting during the Expr visits.
+        for var in other.iter_input_vars(py)?.bind(py) {
+            dag.add_input_var(py, &var?)?;
+        }
+        if inline_captures {
+            for var in other.iter_captured_vars(py)?.bind(py) {
+                let var = var?;
+                if !dag.has_var(&var)? {
+                    return Err(DAGCircuitError::new_err(format!("Variable '{}' to be inlined is not in the base DAG. If you wanted it to be automatically added, use `inline_captures=False`.", var)));
+                }
+            }
+        } else {
+            for var in other.iter_captured_vars(py)?.bind(py) {
+                dag.add_captured_var(py, &var?)?;
+            }
+        }
+        for var in other.iter_declared_vars(py)?.bind(py) {
+            dag.add_declared_var(py, &var?)?;
+        }
+
+        let variable_mapper = PyVariableMapper::new(
+            py,
+            dag.cregs.bind(py).values().into_any(),
+            Some(edge_map.clone()),
+            None,
+            Some(wrap_pyfunction_bound!(reject_new_register, py)?.to_object(py)),
+        )?;
+
+        for node in other.topological_nodes()? {
+            match &other.dag[node] {
+                NodeType::QubitIn(q) => {
+                    let bit = other.qubits.get(*q).unwrap().bind(py);
+                    let m_wire = edge_map.get_item(bit)?.unwrap_or_else(|| bit.clone());
+                    let wire_in_dag = dag.qubits.find(&m_wire);
+
+                    if wire_in_dag.is_none()
+                        || (dag.qubit_io_map.len() - 1 < wire_in_dag.unwrap().0 as usize)
+                    {
+                        return Err(DAGCircuitError::new_err(format!(
+                            "wire {} not in self",
+                            m_wire,
+                        )));
+                    }
+                    // TODO: Python code has check here if node.wire is in other._wires. Why?
+                }
+                NodeType::ClbitIn(c) => {
+                    let bit = other.clbits.get(*c).unwrap().bind(py);
+                    let m_wire = edge_map.get_item(bit)?.unwrap_or_else(|| bit.clone());
+                    let wire_in_dag = dag.clbits.find(&m_wire);
+                    if wire_in_dag.is_none()
+                        || dag.clbit_io_map.len() - 1 < wire_in_dag.unwrap().0 as usize
+                    {
+                        return Err(DAGCircuitError::new_err(format!(
+                            "wire {} not in self",
+                            m_wire,
+                        )));
+                    }
+                    // TODO: Python code has check here if node.wire is in other._wires. Why?
+                }
+                NodeType::Operation(op) => {
+                    let m_qargs = {
+                        let qubits = other
+                            .qubits
+                            .map_indices(other.qargs_cache.intern(op.qubits).as_slice());
+                        let mut mapped = Vec::with_capacity(qubits.len());
+                        for bit in qubits {
+                            mapped.push(
+                                edge_map
+                                    .get_item(bit)?
+                                    .unwrap_or_else(|| bit.bind(py).clone()),
+                            );
+                        }
+                        PyTuple::new_bound(py, mapped)
+                    };
+                    let m_cargs = {
+                        let clbits = other
+                            .clbits
+                            .map_indices(other.cargs_cache.intern(op.clbits).as_slice());
+                        let mut mapped = Vec::with_capacity(clbits.len());
+                        for bit in clbits {
+                            mapped.push(
+                                edge_map
+                                    .get_item(bit)?
+                                    .unwrap_or_else(|| bit.bind(py).clone()),
+                            );
+                        }
+                        PyTuple::new_bound(py, mapped)
+                    };
+
+                    // We explicitly create a mutable py_op here since we might
+                    // update the condition.
+                    let mut py_op = op.unpack_py_op(py)?.into_bound(py);
+                    if py_op.getattr(intern!(py, "mutable"))?.extract::<bool>()? {
+                        py_op = py_op.call_method0(intern!(py, "to_mutable"))?;
+                    }
+
+                    if let Some(condition) = op.condition() {
+                        // TODO: do we need to check for condition.is_none()?
+                        let condition = variable_mapper.map_condition(condition.bind(py), true)?;
+                        if !op.op.control_flow() {
+                            py_op = py_op.call_method1(
+                                intern!(py, "c_if"),
+                                condition.downcast::<PyTuple>()?,
+                            )?;
+                        } else {
+                            py_op.setattr(intern!(py, "condition"), condition)?;
+                        }
+                    } else if py_op.is_instance(imports::SWITCH_CASE_OP.get_bound(py))? {
+                        py_op.setattr(
+                            intern!(py, "target"),
+                            variable_mapper.map_target(&py_op.getattr(intern!(py, "target"))?)?,
+                        )?;
+                    };
+
+                    dag.py_apply_operation_back(
+                        py,
+                        py_op,
+                        Some(TupleLikeArg { value: m_qargs }),
+                        Some(TupleLikeArg { value: m_cargs }),
+                        false,
+                    )?;
+                }
+                // If its a Var wire, we already checked that it exists in the destination.
+                NodeType::VarIn(_)
+                | NodeType::VarOut(_)
+                | NodeType::QubitOut(_)
+                | NodeType::ClbitOut(_) => (),
+            }
+        }
+
+        if !inplace {
+            Ok(Some(dag.into_py(py)))
+        } else {
+            Ok(None)
+        }
+    }
+
+    /// Reverse the operations in the ``self`` circuit.
+    ///
+    /// Returns:
+    ///     DAGCircuit: the reversed dag.
+    fn reverse_ops<'py>(slf: PyRef<Self>, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        let qc = imports::DAG_TO_CIRCUIT.get_bound(py).call1((slf,))?;
+        let reversed = qc.call_method0("reverse_ops")?;
+        imports::CIRCUIT_TO_DAG.get_bound(py).call1((reversed,))
+    }
+
+    /// Return idle wires.
+    ///
+    /// Args:
+    ///     ignore (list(str)): List of node names to ignore. Default: []
+    ///
+    /// Yields:
+    ///     Bit: Bit in idle wire.
+    ///
+    /// Raises:
+    ///     DAGCircuitError: If the DAG is invalid
+    fn idle_wires(&self, py: Python, ignore: Option<&Bound<PyList>>) -> PyResult<Py<PyIterator>> {
+        let mut result: Vec<PyObject> = Vec::new();
+        let wires = (0..self.qubit_io_map.len())
+            .map(|idx| Wire::Qubit(Qubit(idx as u32)))
+            .chain((0..self.clbit_io_map.len()).map(|idx| Wire::Clbit(Clbit(idx as u32))))
+            .chain(self.var_input_map.keys(py).map(Wire::Var));
+        match ignore {
+            Some(ignore) => {
+                // Convert the list to a Rust set.
+                let ignore_set = ignore
+                    .into_iter()
+                    .map(|s| s.extract())
+                    .collect::<PyResult<HashSet<String>>>()?;
+                for wire in wires {
+                    let nodes_found = self.nodes_on_wire(py, &wire, true).into_iter().any(|node| {
+                        let weight = self.dag.node_weight(node).unwrap();
+                        if let NodeType::Operation(packed) = weight {
+                            !ignore_set.contains(packed.op.name())
+                        } else {
+                            false
+                        }
+                    });
+
+                    if !nodes_found {
+                        result.push(match wire {
+                            Wire::Qubit(qubit) => self.qubits.get(qubit).unwrap().clone_ref(py),
+                            Wire::Clbit(clbit) => self.clbits.get(clbit).unwrap().clone_ref(py),
+                            Wire::Var(var) => var,
+                        });
+                    }
+                }
+            }
+            None => {
+                for wire in wires {
+                    if self.is_wire_idle(py, &wire)? {
+                        result.push(match wire {
+                            Wire::Qubit(qubit) => self.qubits.get(qubit).unwrap().clone_ref(py),
+                            Wire::Clbit(clbit) => self.clbits.get(clbit).unwrap().clone_ref(py),
+                            Wire::Var(var) => var,
+                        });
+                    }
+                }
+            }
+        }
+        Ok(PyTuple::new_bound(py, result).into_any().iter()?.unbind())
+    }
+
+    /// Return the number of operations.  If there is control flow present, this count may only
+    /// be an estimate, as the complete control-flow path cannot be statically known.
+    ///
+    /// Args:
+    ///     recurse: if ``True``, then recurse into control-flow operations.  For loops with
+    ///         known-length iterators are counted unrolled.  If-else blocks sum both of the two
+    ///         branches.  While loops are counted as if the loop body runs once only.  Defaults to
+    ///         ``False`` and raises :class:`.DAGCircuitError` if any control flow is present, to
+    ///         avoid silently returning a mostly meaningless number.
+    ///
+    /// Returns:
+    ///     int: the circuit size
+    ///
+    /// Raises:
+    ///     DAGCircuitError: if an unknown :class:`.ControlFlowOp` is present in a call with
+    ///         ``recurse=True``, or any control flow is present in a non-recursive call.
+    #[pyo3(signature= (*, recurse=false))]
+    fn size(&self, py: Python, recurse: bool) -> PyResult<usize> {
+        let mut length = self.dag.node_count() - (self.width() * 2);
+        if !recurse {
+            if CONTROL_FLOW_OP_NAMES
+                .iter()
+                .any(|n| self.op_names.contains_key(&n.to_string()))
+            {
+                return Err(DAGCircuitError::new_err(concat!(
+                    "Size with control flow is ambiguous.",
+                    " You may use `recurse=True` to get a result",
+                    " but see this method's documentation for the meaning of this."
+                )));
+            }
+            return Ok(length);
+        }
+
+        let circuit_to_dag = imports::CIRCUIT_TO_DAG.get_bound(py);
+        for node_index in
+            self.op_nodes_by_py_type(imports::CONTROL_FLOW_OP.get_bound(py).downcast()?, true)
+        {
+            let NodeType::Operation(node) = &self.dag[node_index] else {
+                return Err(DAGCircuitError::new_err("unknown control-flow type"));
+            };
+            let OperationRef::Instruction(inst) = node.op.view() else {
+                unreachable!("Control Flow operations must be a PyInstruction");
+            };
+            let inst_bound = inst.instruction.bind(py);
+            if inst_bound.is_instance(imports::FOR_LOOP_OP.get_bound(py))? {
+                let raw_blocks = inst_bound.getattr("blocks")?;
+                let blocks: &Bound<PySequence> = raw_blocks.downcast()?;
+                let block_zero = blocks.get_item(0).unwrap();
+                let inner_dag: &DAGCircuit =
+                    &circuit_to_dag.call1((block_zero.clone(),))?.extract()?;
+                length += node.params_view().len() * inner_dag.size(py, true)?
+            } else if inst_bound.is_instance(imports::WHILE_LOOP_OP.get_bound(py))? {
+                let raw_blocks = inst_bound.getattr("blocks")?;
+                let blocks: &Bound<PySequence> = raw_blocks.downcast()?;
+                let block_zero = blocks.get_item(0).unwrap();
+                let inner_dag: &DAGCircuit =
+                    &circuit_to_dag.call1((block_zero.clone(),))?.extract()?;
+                length += inner_dag.size(py, true)?
+            } else if inst_bound.is_instance(imports::IF_ELSE_OP.get_bound(py))?
+                || inst_bound.is_instance(imports::SWITCH_CASE_OP.get_bound(py))?
+            {
+                let raw_blocks = inst_bound.getattr("blocks")?;
+                let blocks: &Bound<PyTuple> = raw_blocks.downcast()?;
+                for block in blocks.iter() {
+                    let inner_dag: &DAGCircuit =
+                        &circuit_to_dag.call1((block.clone(),))?.extract()?;
+                    length += inner_dag.size(py, true)?;
+                }
+            } else {
+                continue;
+            }
+            // We don't count a control-flow node itself!
+            length -= 1;
+        }
+        Ok(length)
+    }
+
+    /// Return the circuit depth.  If there is control flow present, this count may only be an
+    /// estimate, as the complete control-flow path cannot be statically known.
+    ///
+    /// Args:
+    ///     recurse: if ``True``, then recurse into control-flow operations.  For loops
+    ///         with known-length iterators are counted as if the loop had been manually unrolled
+    ///         (*i.e.* with each iteration of the loop body written out explicitly).
+    ///         If-else blocks take the longer case of the two branches.  While loops are counted as
+    ///         if the loop body runs once only.  Defaults to ``False`` and raises
+    ///         :class:`.DAGCircuitError` if any control flow is present, to avoid silently
+    ///         returning a nonsensical number.
+    ///
+    /// Returns:
+    ///     int: the circuit depth
+    ///
+    /// Raises:
+    ///     DAGCircuitError: if not a directed acyclic graph
+    ///     DAGCircuitError: if unknown control flow is present in a recursive call, or any control
+    ///         flow is present in a non-recursive call.
+    #[pyo3(signature= (*, recurse=false))]
+    fn depth(&self, py: Python, recurse: bool) -> PyResult<usize> {
+        if self.qubits.is_empty() && self.clbits.is_empty() && self.vars_info.is_empty() {
+            return Ok(0);
+        }
+
+        Ok(if recurse {
+            let circuit_to_dag = imports::CIRCUIT_TO_DAG.get_bound(py);
+            let mut node_lookup: HashMap<NodeIndex, usize> = HashMap::new();
+
+            for node_index in
+                self.op_nodes_by_py_type(imports::CONTROL_FLOW_OP.get_bound(py).downcast()?, true)
+            {
+                if let NodeType::Operation(node) = &self.dag[node_index] {
+                    if let OperationRef::Instruction(inst) = node.op.view() {
+                        let inst_bound = inst.instruction.bind(py);
+                        let weight =
+                            if inst_bound.is_instance(imports::FOR_LOOP_OP.get_bound(py))? {
+                                node.params_view().len()
+                            } else {
+                                1
+                            };
+                        if weight == 0 {
+                            node_lookup.insert(node_index, 0);
+                        } else {
+                            let raw_blocks = inst_bound.getattr("blocks")?;
+                            let blocks = raw_blocks.downcast::<PyTuple>()?;
+                            let mut block_weights: Vec<usize> = Vec::with_capacity(blocks.len());
+                            for block in blocks.iter() {
+                                let inner_dag: &DAGCircuit =
+                                    &circuit_to_dag.call1((block,))?.extract()?;
+                                block_weights.push(inner_dag.depth(py, true)?);
+                            }
+                            node_lookup
+                                .insert(node_index, weight * block_weights.iter().max().unwrap());
+                        }
+                    }
+                }
+            }
+
+            let weight_fn = |edge: EdgeReference<'_, Wire>| -> Result<usize, Infallible> {
+                Ok(*node_lookup.get(&edge.target()).unwrap_or(&1))
+            };
+            match rustworkx_core::dag_algo::longest_path(&self.dag, weight_fn).unwrap() {
+                Some(res) => res.1,
+                None => return Err(DAGCircuitError::new_err("not a DAG")),
+            }
+        } else {
+            if CONTROL_FLOW_OP_NAMES
+                .iter()
+                .any(|x| self.op_names.contains_key(&x.to_string()))
+            {
+                return Err(DAGCircuitError::new_err("Depth with control flow is ambiguous. You may use `recurse=True` to get a result, but see this method's documentation for the meaning of this."));
+            }
+
+            let weight_fn = |_| -> Result<usize, Infallible> { Ok(1) };
+            match rustworkx_core::dag_algo::longest_path(&self.dag, weight_fn).unwrap() {
+                Some(res) => res.1,
+                None => return Err(DAGCircuitError::new_err("not a DAG")),
+            }
+        } - 1)
+    }
+
+    /// Return the total number of qubits + clbits used by the circuit.
+    /// This function formerly returned the number of qubits by the calculation
+    /// return len(self._wires) - self.num_clbits()
+    /// but was changed by issue #2564 to return number of qubits + clbits
+    /// with the new function DAGCircuit.num_qubits replacing the former
+    /// semantic of DAGCircuit.width().
+    fn width(&self) -> usize {
+        self.qubits.len() + self.clbits.len() + self.vars_info.len()
+    }
+
+    /// Return the total number of qubits used by the circuit.
+    /// num_qubits() replaces former use of width().
+    /// DAGCircuit.width() now returns qubits + clbits for
+    /// consistency with Circuit.width() [qiskit-terra #2564].
+    pub fn num_qubits(&self) -> usize {
+        self.qubits.len()
+    }
+
+    /// Return the total number of classical bits used by the circuit.
+    pub fn num_clbits(&self) -> usize {
+        self.clbits.len()
+    }
+
+    /// Compute how many components the circuit can decompose into.
+    fn num_tensor_factors(&self) -> usize {
+        // This function was forked from rustworkx's
+        // number_weekly_connected_components() function as of 0.15.0:
+        // https://github.com/Qiskit/rustworkx/blob/0.15.0/src/connectivity/mod.rs#L215-L235
+
+        let mut weak_components = self.dag.node_count();
+        let mut vertex_sets = UnionFind::new(self.dag.node_bound());
+        for edge in self.dag.edge_references() {
+            let (a, b) = (edge.source(), edge.target());
+            // union the two vertices of the edge
+            if vertex_sets.union(a.index(), b.index()) {
+                weak_components -= 1
+            };
+        }
+        weak_components
+    }
+
+    fn __eq__(&self, py: Python, other: &DAGCircuit) -> PyResult<bool> {
+        // Try to convert to float, but in case of unbound ParameterExpressions
+        // a TypeError will be raise, fallback to normal equality in those
+        // cases.
+        let phase_is_close = |self_phase: f64, other_phase: f64| -> bool {
+            ((self_phase - other_phase + PI).rem_euclid(2. * PI) - PI).abs() <= 1.0e-10
+        };
+        let normalize_param = |param: &Param| {
+            if let Param::ParameterExpression(ob) = param {
+                ob.bind(py)
+                    .call_method0(intern!(py, "numeric"))
+                    .ok()
+                    .map(|ob| ob.extract::<Param>())
+                    .unwrap_or_else(|| Ok(param.clone()))
+            } else {
+                Ok(param.clone())
+            }
+        };
+
+        let phase_eq = match [
+            normalize_param(&self.global_phase)?,
+            normalize_param(&other.global_phase)?,
+        ] {
+            [Param::Float(self_phase), Param::Float(other_phase)] => {
+                Ok(phase_is_close(self_phase, other_phase))
+            }
+            _ => self.global_phase.eq(py, &other.global_phase),
+        }?;
+        if !phase_eq {
+            return Ok(false);
+        }
+        if self.calibrations.len() != other.calibrations.len() {
+            return Ok(false);
+        }
+
+        for (k, v1) in &self.calibrations {
+            match other.calibrations.get(k) {
+                Some(v2) => {
+                    if !v1.bind(py).eq(v2.bind(py))? {
+                        return Ok(false);
+                    }
+                }
+                None => {
+                    return Ok(false);
+                }
+            }
+        }
+
+        // We don't do any semantic equivalence between Var nodes, as things stand; DAGs can only be
+        // equal in our mind if they use the exact same UUID vars.
+        for (our_vars, their_vars) in self.vars_by_type.iter().zip(&other.vars_by_type) {
+            if !our_vars.bind(py).eq(their_vars)? {
+                return Ok(false);
+            }
+        }
+
+        let self_bit_indices = {
+            let indices = self
+                .qubits
+                .bits()
+                .iter()
+                .chain(self.clbits.bits())
+                .enumerate()
+                .map(|(idx, bit)| (bit, idx));
+            indices.into_py_dict_bound(py)
+        };
+
+        let other_bit_indices = {
+            let indices = other
+                .qubits
+                .bits()
+                .iter()
+                .chain(other.clbits.bits())
+                .enumerate()
+                .map(|(idx, bit)| (bit, idx));
+            indices.into_py_dict_bound(py)
+        };
+
+        // Check if qregs are the same.
+        let self_qregs = self.qregs.bind(py);
+        let other_qregs = other.qregs.bind(py);
+        if self_qregs.len() != other_qregs.len() {
+            return Ok(false);
+        }
+        for (regname, self_bits) in self_qregs {
+            let self_bits = self_bits
+                .getattr("_bits")?
+                .downcast_into_exact::<PyList>()?;
+            let other_bits = match other_qregs.get_item(regname)? {
+                Some(bits) => bits.getattr("_bits")?.downcast_into_exact::<PyList>()?,
+                None => return Ok(false),
+            };
+            if !self
+                .qubits
+                .map_bits(self_bits)?
+                .eq(other.qubits.map_bits(other_bits)?)
+            {
+                return Ok(false);
+            }
+        }
+
+        // Check if cregs are the same.
+        let self_cregs = self.cregs.bind(py);
+        let other_cregs = other.cregs.bind(py);
+        if self_cregs.len() != other_cregs.len() {
+            return Ok(false);
+        }
+
+        for (regname, self_bits) in self_cregs {
+            let self_bits = self_bits
+                .getattr("_bits")?
+                .downcast_into_exact::<PyList>()?;
+            let other_bits = match other_cregs.get_item(regname)? {
+                Some(bits) => bits.getattr("_bits")?.downcast_into_exact::<PyList>()?,
+                None => return Ok(false),
+            };
+            if !self
+                .clbits
+                .map_bits(self_bits)?
+                .eq(other.clbits.map_bits(other_bits)?)
+            {
+                return Ok(false);
+            }
+        }
+
+        // Check for VF2 isomorphic match.
+        let legacy_condition_eq = imports::LEGACY_CONDITION_CHECK.get_bound(py);
+        let condition_op_check = imports::CONDITION_OP_CHECK.get_bound(py);
+        let switch_case_op_check = imports::SWITCH_CASE_OP_CHECK.get_bound(py);
+        let for_loop_op_check = imports::FOR_LOOP_OP_CHECK.get_bound(py);
+        let node_match = |n1: &NodeType, n2: &NodeType| -> PyResult<bool> {
+            match [n1, n2] {
+                [NodeType::Operation(inst1), NodeType::Operation(inst2)] => {
+                    if inst1.op.name() != inst2.op.name() {
+                        return Ok(false);
+                    }
+                    let check_args = || -> bool {
+                        let node1_qargs = self.qargs_cache.intern(inst1.qubits);
+                        let node2_qargs = other.qargs_cache.intern(inst2.qubits);
+                        let node1_cargs = self.cargs_cache.intern(inst1.clbits);
+                        let node2_cargs = other.cargs_cache.intern(inst2.clbits);
+                        if SEMANTIC_EQ_SYMMETRIC.contains(&inst1.op.name()) {
+                            let node1_qargs =
+                                node1_qargs.iter().copied().collect::<HashSet<Qubit>>();
+                            let node2_qargs =
+                                node2_qargs.iter().copied().collect::<HashSet<Qubit>>();
+                            let node1_cargs =
+                                node1_cargs.iter().copied().collect::<HashSet<Clbit>>();
+                            let node2_cargs =
+                                node2_cargs.iter().copied().collect::<HashSet<Clbit>>();
+                            if node1_qargs != node2_qargs || node1_cargs != node2_cargs {
+                                return false;
+                            }
+                        } else if node1_qargs != node2_qargs || node1_cargs != node2_cargs {
+                            return false;
+                        }
+                        true
+                    };
+                    let check_conditions = || -> PyResult<bool> {
+                        if let Some(cond1) = inst1
+                            .extra_attrs
+                            .as_ref()
+                            .and_then(|attrs| attrs.condition.as_ref())
+                        {
+                            if let Some(cond2) = inst2
+                                .extra_attrs
+                                .as_ref()
+                                .and_then(|attrs| attrs.condition.as_ref())
+                            {
+                                legacy_condition_eq
+                                    .call1((cond1, cond2, &self_bit_indices, &other_bit_indices))?
+                                    .extract::<bool>()
+                            } else {
+                                Ok(false)
+                            }
+                        } else {
+                            Ok(inst2
+                                .extra_attrs
+                                .as_ref()
+                                .and_then(|attrs| attrs.condition.as_ref())
+                                .is_none())
+                        }
+                    };
+
+                    match [inst1.op.view(), inst2.op.view()] {
+                        [OperationRef::Standard(_op1), OperationRef::Standard(_op2)] => {
+                            Ok(inst1.py_op_eq(py, inst2)?
+                                && check_args()
+                                && check_conditions()?
+                                && inst1
+                                    .params_view()
+                                    .iter()
+                                    .zip(inst2.params_view().iter())
+                                    .all(|(a, b)| a.is_close(py, b, 1e-10).unwrap()))
+                        }
+                        [OperationRef::Instruction(op1), OperationRef::Instruction(op2)] => {
+                            if op1.control_flow() && op2.control_flow() {
+                                let n1 = self.unpack_into(py, NodeIndex::new(0), n1)?;
+                                let n2 = other.unpack_into(py, NodeIndex::new(0), n2)?;
+                                let name = op1.name();
+                                if name == "if_else" || name == "while_loop" {
+                                    condition_op_check
+                                        .call1((n1, n2, &self_bit_indices, &other_bit_indices))?
+                                        .extract()
+                                } else if name == "switch_case" {
+                                    switch_case_op_check
+                                        .call1((n1, n2, &self_bit_indices, &other_bit_indices))?
+                                        .extract()
+                                } else if name == "for_loop" {
+                                    for_loop_op_check
+                                        .call1((n1, n2, &self_bit_indices, &other_bit_indices))?
+                                        .extract()
+                                } else {
+                                    Err(PyRuntimeError::new_err(format!(
+                                        "unhandled control-flow operation: {}",
+                                        name
+                                    )))
+                                }
+                            } else {
+                                Ok(inst1.py_op_eq(py, inst2)?
+                                    && check_args()
+                                    && check_conditions()?)
+                            }
+                        }
+                        [OperationRef::Gate(_op1), OperationRef::Gate(_op2)] => {
+                            Ok(inst1.py_op_eq(py, inst2)? && check_args() && check_conditions()?)
+                        }
+                        [OperationRef::Operation(_op1), OperationRef::Operation(_op2)] => {
+                            Ok(inst1.py_op_eq(py, inst2)? && check_args())
+                        }
+                        // Handle the case we end up with a pygate for a standardgate
+                        // this typically only happens if it's a ControlledGate in python
+                        // and we have mutable state set.
+                        [OperationRef::Standard(_op1), OperationRef::Gate(_op2)] => {
+                            Ok(inst1.py_op_eq(py, inst2)? && check_args() && check_conditions()?)
+                        }
+                        [OperationRef::Gate(_op1), OperationRef::Standard(_op2)] => {
+                            Ok(inst1.py_op_eq(py, inst2)? && check_args() && check_conditions()?)
+                        }
+                        _ => Ok(false),
+                    }
+                }
+                [NodeType::QubitIn(bit1), NodeType::QubitIn(bit2)] => Ok(bit1 == bit2),
+                [NodeType::ClbitIn(bit1), NodeType::ClbitIn(bit2)] => Ok(bit1 == bit2),
+                [NodeType::QubitOut(bit1), NodeType::QubitOut(bit2)] => Ok(bit1 == bit2),
+                [NodeType::ClbitOut(bit1), NodeType::ClbitOut(bit2)] => Ok(bit1 == bit2),
+                [NodeType::VarIn(var1), NodeType::VarIn(var2)] => var1.bind(py).eq(var2),
+                [NodeType::VarOut(var1), NodeType::VarOut(var2)] => var1.bind(py).eq(var2),
+                _ => Ok(false),
+            }
+        };
+
+        isomorphism::vf2::is_isomorphic(
+            &self.dag,
+            &other.dag,
+            node_match,
+            isomorphism::vf2::NoSemanticMatch,
+            true,
+            Ordering::Equal,
+            true,
+            None,
+        )
+        .map_err(|e| match e {
+            isomorphism::vf2::IsIsomorphicError::NodeMatcherErr(e) => e,
+            _ => {
+                unreachable!()
+            }
+        })
+    }
+
+    /// Yield nodes in topological order.
+    ///
+    /// Args:
+    ///     key (Callable): A callable which will take a DAGNode object and
+    ///         return a string sort key. If not specified the
+    ///         :attr:`~qiskit.dagcircuit.DAGNode.sort_key` attribute will be
+    ///         used as the sort key for each node.
+    ///
+    /// Returns:
+    ///     generator(DAGOpNode, DAGInNode, or DAGOutNode): node in topological order
+    #[pyo3(name = "topological_nodes")]
+    fn py_topological_nodes(
+        &self,
+        py: Python,
+        key: Option<Bound<PyAny>>,
+    ) -> PyResult<Py<PyIterator>> {
+        let nodes: PyResult<Vec<_>> = if let Some(key) = key {
+            self.topological_key_sort(py, &key)?
+                .map(|node| self.get_node(py, node))
+                .collect()
+        } else {
+            // Good path, using interner IDs.
+            self.topological_nodes()?
+                .map(|n| self.get_node(py, n))
+                .collect()
+        };
+
+        Ok(PyTuple::new_bound(py, nodes?)
+            .into_any()
+            .iter()
+            .unwrap()
+            .unbind())
+    }
+
+    /// Yield op nodes in topological order.
+    ///
+    /// Allowed to pass in specific key to break ties in top order
+    ///
+    /// Args:
+    ///     key (Callable): A callable which will take a DAGNode object and
+    ///         return a string sort key. If not specified the
+    ///         :attr:`~qiskit.dagcircuit.DAGNode.sort_key` attribute will be
+    ///         used as the sort key for each node.
+    ///
+    /// Returns:
+    ///     generator(DAGOpNode): op node in topological order
+    #[pyo3(name = "topological_op_nodes")]
+    fn py_topological_op_nodes(
+        &self,
+        py: Python,
+        key: Option<Bound<PyAny>>,
+    ) -> PyResult<Py<PyIterator>> {
+        let nodes: PyResult<Vec<_>> = if let Some(key) = key {
+            self.topological_key_sort(py, &key)?
+                .filter_map(|node| match self.dag.node_weight(node) {
+                    Some(NodeType::Operation(_)) => Some(self.get_node(py, node)),
+                    _ => None,
+                })
+                .collect()
+        } else {
+            // Good path, using interner IDs.
+            self.topological_op_nodes()?
+                .map(|n| self.get_node(py, n))
+                .collect()
+        };
+
+        Ok(PyTuple::new_bound(py, nodes?)
+            .into_any()
+            .iter()
+            .unwrap()
+            .unbind())
+    }
+
+    /// Replace a block of nodes with a single node.
+    ///
+    /// This is used to consolidate a block of DAGOpNodes into a single
+    /// operation. A typical example is a block of gates being consolidated
+    /// into a single ``UnitaryGate`` representing the unitary matrix of the
+    /// block.
+    ///
+    /// Args:
+    ///     node_block (List[DAGNode]): A list of dag nodes that represents the
+    ///         node block to be replaced
+    ///     op (qiskit.circuit.Operation): The operation to replace the
+    ///         block with
+    ///     wire_pos_map (Dict[Bit, int]): The dictionary mapping the bits to their positions in the
+    ///         output ``qargs`` or ``cargs``. This is necessary to reconstruct the arg order over
+    ///         multiple gates in the combined single op node.  If a :class:`.Bit` is not in the
+    ///         dictionary, it will not be added to the args; this can be useful when dealing with
+    ///         control-flow operations that have inherent bits in their ``condition`` or ``target``
+    ///         fields.
+    ///     cycle_check (bool): When set to True this method will check that
+    ///         replacing the provided ``node_block`` with a single node
+    ///         would introduce a cycle (which would invalidate the
+    ///         ``DAGCircuit``) and will raise a ``DAGCircuitError`` if a cycle
+    ///         would be introduced. This checking comes with a run time
+    ///         penalty. If you can guarantee that your input ``node_block`` is
+    ///         a contiguous block and won't introduce a cycle when it's
+    ///         contracted to a single node, this can be set to ``False`` to
+    ///         improve the runtime performance of this method.
+    ///
+    /// Raises:
+    ///     DAGCircuitError: if ``cycle_check`` is set to ``True`` and replacing
+    ///         the specified block introduces a cycle or if ``node_block`` is
+    ///         empty.
+    ///
+    /// Returns:
+    ///     DAGOpNode: The op node that replaces the block.
+    #[pyo3(signature = (node_block, op, wire_pos_map, cycle_check=true))]
+    fn replace_block_with_op(
+        &mut self,
+        py: Python,
+        node_block: Vec<PyRef<DAGNode>>,
+        op: Bound<PyAny>,
+        wire_pos_map: &Bound<PyDict>,
+        cycle_check: bool,
+    ) -> PyResult<Py<PyAny>> {
+        // If node block is empty return early
+        if node_block.is_empty() {
+            return Err(DAGCircuitError::new_err(
+                "Can't replace an empty 'node_block'",
+            ));
+        }
+
+        let mut qubit_pos_map: HashMap<Qubit, usize> = HashMap::new();
+        let mut clbit_pos_map: HashMap<Clbit, usize> = HashMap::new();
+        for (bit, index) in wire_pos_map.iter() {
+            if bit.is_instance(imports::QUBIT.get_bound(py))? {
+                qubit_pos_map.insert(self.qubits.find(&bit).unwrap(), index.extract()?);
+            } else if bit.is_instance(imports::CLBIT.get_bound(py))? {
+                clbit_pos_map.insert(self.clbits.find(&bit).unwrap(), index.extract()?);
+            } else {
+                return Err(DAGCircuitError::new_err(
+                    "Wire map keys must be Qubit or Clbit instances.",
+                ));
+            }
+        }
+
+        let block_ids: Vec<_> = node_block.iter().map(|n| n.node.unwrap()).collect();
+
+        let mut block_op_names = Vec::new();
+        let mut block_qargs: HashSet<Qubit> = HashSet::new();
+        let mut block_cargs: HashSet<Clbit> = HashSet::new();
+        for nd in &block_ids {
+            let weight = self.dag.node_weight(*nd);
+            match weight {
+                Some(NodeType::Operation(packed)) => {
+                    block_op_names.push(packed.op.name().to_string());
+                    block_qargs.extend(self.qargs_cache.intern(packed.qubits));
+                    block_cargs.extend(self.cargs_cache.intern(packed.clbits));
+
+                    if let Some(condition) = packed.condition() {
+                        block_cargs.extend(
+                            self.clbits.map_bits(
+                                self.control_flow_module
+                                    .condition_resources(condition.bind(py))?
+                                    .clbits
+                                    .bind(py),
+                            )?,
+                        );
+                        continue;
+                    }
+
+                    // Add classical bits from SwitchCaseOp, if applicable.
+                    if let OperationRef::Instruction(op) = packed.op.view() {
+                        if op.name() == "switch_case" {
+                            let op_bound = op.instruction.bind(py);
+                            let target = op_bound.getattr(intern!(py, "target"))?;
+                            if target.is_instance(imports::CLBIT.get_bound(py))? {
+                                block_cargs.insert(self.clbits.find(&target).unwrap());
+                            } else if target
+                                .is_instance(imports::CLASSICAL_REGISTER.get_bound(py))?
+                            {
+                                block_cargs.extend(
+                                    self.clbits
+                                        .map_bits(target.extract::<Vec<Bound<PyAny>>>()?)?,
+                                );
+                            } else {
+                                block_cargs.extend(
+                                    self.clbits.map_bits(
+                                        self.control_flow_module
+                                            .node_resources(&target)?
+                                            .clbits
+                                            .bind(py),
+                                    )?,
+                                );
+                            }
+                        }
+                    }
+                }
+                Some(_) => {
+                    return Err(DAGCircuitError::new_err(
+                        "Nodes in 'node_block' must be of type 'DAGOpNode'.",
+                    ))
+                }
+                None => {
+                    return Err(DAGCircuitError::new_err(
+                        "Node in 'node_block' not found in DAG.",
+                    ))
+                }
+            }
+        }
+
+        let mut block_qargs: Vec<Qubit> = block_qargs
+            .into_iter()
+            .filter(|q| qubit_pos_map.contains_key(q))
+            .collect();
+        block_qargs.sort_by_key(|q| qubit_pos_map[q]);
+
+        let mut block_cargs: Vec<Clbit> = block_cargs
+            .into_iter()
+            .filter(|c| clbit_pos_map.contains_key(c))
+            .collect();
+        block_cargs.sort_by_key(|c| clbit_pos_map[c]);
+
+        let py_op = op.extract::<OperationFromPython>()?;
+
+        if py_op.operation.num_qubits() as usize != block_qargs.len() {
+            return Err(DAGCircuitError::new_err(format!(
+                "Number of qubits in the replacement operation ({}) is not equal to the number of qubits in the block ({})!", py_op.operation.num_qubits(), block_qargs.len()
+            )));
+        }
+
+        let op_name = py_op.operation.name().to_string();
+        let qubits = Interner::intern(&mut self.qargs_cache, block_qargs)?;
+        let clbits = Interner::intern(&mut self.cargs_cache, block_cargs)?;
+        let weight = NodeType::Operation(PackedInstruction {
+            op: py_op.operation,
+            qubits,
+            clbits,
+            params: (!py_op.params.is_empty()).then(|| Box::new(py_op.params)),
+            extra_attrs: py_op.extra_attrs,
+            #[cfg(feature = "cache_pygates")]
+            py_op: op.unbind().into(),
+        });
+
+        let new_node = self
+            .dag
+            .contract_nodes(block_ids, weight, cycle_check)
+            .map_err(|e| match e {
+                ContractError::DAGWouldCycle => DAGCircuitError::new_err(
+                    "Replacing the specified node block would introduce a cycle",
+                ),
+            })?;
+
+        self.increment_op(op_name.as_str());
+        for name in block_op_names {
+            self.decrement_op(name.as_str());
+        }
+
+        self.get_node(py, new_node)
+    }
+
+    /// Replace one node with dag.
+    ///
+    /// Args:
+    ///     node (DAGOpNode): node to substitute
+    ///     input_dag (DAGCircuit): circuit that will substitute the node
+    ///     wires (list[Bit] | Dict[Bit, Bit]): gives an order for (qu)bits
+    ///         in the input circuit. If a list, then the bits refer to those in the ``input_dag``,
+    ///         and the order gets matched to the node wires by qargs first, then cargs, then
+    ///         conditions.  If a dictionary, then a mapping of bits in the ``input_dag`` to those
+    ///         that the ``node`` acts on.
+    ///     propagate_condition (bool): If ``True`` (default), then any ``condition`` attribute on
+    ///         the operation within ``node`` is propagated to each node in the ``input_dag``.  If
+    ///         ``False``, then the ``input_dag`` is assumed to faithfully implement suitable
+    ///         conditional logic already.  This is ignored for :class:`.ControlFlowOp`\\ s (i.e.
+    ///         treated as if it is ``False``); replacements of those must already fulfill the same
+    ///         conditional logic or this function would be close to useless for them.
+    ///
+    /// Returns:
+    ///     dict: maps node IDs from `input_dag` to their new node incarnations in `self`.
+    ///
+    /// Raises:
+    ///     DAGCircuitError: if met with unexpected predecessor/successors
+    #[pyo3(signature = (node, input_dag, wires=None, propagate_condition=true))]
+    fn substitute_node_with_dag(
+        &mut self,
+        py: Python,
+        node: &Bound<PyAny>,
+        input_dag: &DAGCircuit,
+        wires: Option<Bound<PyAny>>,
+        propagate_condition: bool,
+    ) -> PyResult<Py<PyDict>> {
+        let (node_index, bound_node) = match node.downcast::<DAGOpNode>() {
+            Ok(bound_node) => (bound_node.borrow().as_ref().node.unwrap(), bound_node),
+            Err(_) => return Err(DAGCircuitError::new_err("expected node DAGOpNode")),
+        };
+
+        let node = match &self.dag[node_index] {
+            NodeType::Operation(op) => op.clone(),
+            _ => return Err(DAGCircuitError::new_err("expected node")),
+        };
+
+        type WireMapsTuple = (HashMap<Qubit, Qubit>, HashMap<Clbit, Clbit>, Py<PyDict>);
+
+        let build_wire_map = |wires: &Bound<PyList>| -> PyResult<WireMapsTuple> {
+            let qargs_list = imports::BUILTIN_LIST
+                .get_bound(py)
+                .call1((bound_node.borrow().get_qargs(py),))?;
+            let qargs_list = qargs_list.downcast::<PyList>().unwrap();
+            let cargs_list = imports::BUILTIN_LIST
+                .get_bound(py)
+                .call1((bound_node.borrow().get_cargs(py),))?;
+            let cargs_list = cargs_list.downcast::<PyList>().unwrap();
+            let cargs_set = imports::BUILTIN_SET.get_bound(py).call1((cargs_list,))?;
+            let cargs_set = cargs_set.downcast::<PySet>().unwrap();
+            if !propagate_condition && self.may_have_additional_wires(py, &node) {
+                let (add_cargs, _add_vars) =
+                    self.additional_wires(py, node.op.view(), node.condition())?;
+                for wire in add_cargs.iter() {
+                    let clbit = &self.clbits.get(*wire).unwrap();
+                    if !cargs_set.contains(clbit.clone_ref(py))? {
+                        cargs_list.append(clbit)?;
+                    }
+                }
+            }
+            let qargs_len = qargs_list.len();
+            let cargs_len = cargs_list.len();
+
+            if qargs_len + cargs_len != wires.len() {
+                return Err(DAGCircuitError::new_err(format!(
+                    "bit mapping invalid: expected {}, got {}",
+                    qargs_len + cargs_len,
+                    wires.len()
+                )));
+            }
+            let mut qubit_wire_map = HashMap::new();
+            let mut clbit_wire_map = HashMap::new();
+            let var_map = PyDict::new_bound(py);
+            for (index, wire) in wires.iter().enumerate() {
+                if wire.is_instance(imports::QUBIT.get_bound(py))? {
+                    if index >= qargs_len {
+                        unreachable!()
+                    }
+                    let input_qubit: Qubit = input_dag.qubits.find(&wire).unwrap();
+                    let self_qubit: Qubit = self.qubits.find(&qargs_list.get_item(index)?).unwrap();
+                    qubit_wire_map.insert(input_qubit, self_qubit);
+                } else if wire.is_instance(imports::CLBIT.get_bound(py))? {
+                    if index < qargs_len {
+                        unreachable!()
+                    }
+                    clbit_wire_map.insert(
+                        input_dag.clbits.find(&wire).unwrap(),
+                        self.clbits
+                            .find(&cargs_list.get_item(index - qargs_len)?)
+                            .unwrap(),
+                    );
+                } else {
+                    return Err(DAGCircuitError::new_err(
+                        "`Var` nodes cannot be remapped during substitution",
+                    ));
+                }
+            }
+            Ok((qubit_wire_map, clbit_wire_map, var_map.unbind()))
+        };
+
+        let (mut qubit_wire_map, mut clbit_wire_map, var_map): (
+            HashMap<Qubit, Qubit>,
+            HashMap<Clbit, Clbit>,
+            Py<PyDict>,
+        ) = match wires {
+            Some(wires) => match wires.downcast::<PyDict>() {
+                Ok(bound_wires) => {
+                    let mut qubit_wire_map = HashMap::new();
+                    let mut clbit_wire_map = HashMap::new();
+                    let var_map = PyDict::new_bound(py);
+                    for (source_wire, target_wire) in bound_wires.iter() {
+                        if source_wire.is_instance(imports::QUBIT.get_bound(py))? {
+                            qubit_wire_map.insert(
+                                input_dag.qubits.find(&source_wire).unwrap(),
+                                self.qubits.find(&target_wire).unwrap(),
+                            );
+                        } else if source_wire.is_instance(imports::CLBIT.get_bound(py))? {
+                            clbit_wire_map.insert(
+                                input_dag.clbits.find(&source_wire).unwrap(),
+                                self.clbits.find(&target_wire).unwrap(),
+                            );
+                        } else {
+                            var_map.set_item(source_wire, target_wire)?;
+                        }
+                    }
+                    (qubit_wire_map, clbit_wire_map, var_map.unbind())
+                }
+                Err(_) => {
+                    let wires: Bound<PyList> = match wires.downcast::<PyList>() {
+                        Ok(bound_list) => bound_list.clone(),
+                        // If someone passes a sequence instead of an exact list (tuple is
+                        // occasionally used) cast that to a list and then use it.
+                        Err(_) => {
+                            let raw_wires = imports::BUILTIN_LIST.get_bound(py).call1((wires,))?;
+                            raw_wires.extract()?
+                        }
+                    };
+                    build_wire_map(&wires)?
+                }
+            },
+            None => {
+                let raw_wires = input_dag.get_wires(py);
+                let binding = raw_wires?;
+                let wires = binding.bind(py);
+                build_wire_map(wires)?
+            }
+        };
+
+        let var_iter = input_dag.iter_vars(py)?;
+        let raw_set = imports::BUILTIN_SET.get_bound(py).call1((var_iter,))?;
+        let input_dag_var_set: &Bound<PySet> = raw_set.downcast()?;
+
+        let node_vars = if self.may_have_additional_wires(py, &node) {
+            let (_additional_clbits, additional_vars) =
+                self.additional_wires(py, node.op.view(), node.condition())?;
+            let var_set = PySet::new_bound(py, &additional_vars)?;
+            if input_dag_var_set
+                .call_method1(intern!(py, "difference"), (var_set.clone(),))?
+                .is_truthy()?
+            {
+                return Err(DAGCircuitError::new_err(format!(
+                    "Cannot replace a node with a DAG with more variables. Variables in node: {:?}. Variables in dag: {:?}",
+                    var_set.str(), input_dag_var_set.str(),
+                )));
+            }
+            var_set
+        } else {
+            PySet::empty_bound(py)?
+        };
+        let bound_var_map = var_map.bind(py);
+        for var in input_dag_var_set.iter() {
+            bound_var_map.set_item(var.clone(), var)?;
+        }
+
+        for contracted_var in node_vars
+            .call_method1(intern!(py, "difference"), (input_dag_var_set,))?
+            .downcast::<PySet>()?
+            .iter()
+        {
+            let pred = self
+                .dag
+                .edges_directed(node_index, Incoming)
+                .find(|edge| {
+                    if let Wire::Var(var) = edge.weight() {
+                        contracted_var.eq(var).unwrap()
+                    } else {
+                        false
+                    }
+                })
+                .unwrap();
+            let succ = self
+                .dag
+                .edges_directed(node_index, Outgoing)
+                .find(|edge| {
+                    if let Wire::Var(var) = edge.weight() {
+                        contracted_var.eq(var).unwrap()
+                    } else {
+                        false
+                    }
+                })
+                .unwrap();
+            self.dag.add_edge(
+                pred.source(),
+                succ.target(),
+                Wire::Var(contracted_var.unbind()),
+            );
+        }
+
+        let mut new_input_dag: Option<DAGCircuit> = None;
+        // It doesn't make sense to try and propagate a condition from a control-flow op; a
+        // replacement for the control-flow op should implement the operation completely.
+        let node_map = if propagate_condition && !node.op.control_flow() {
+            // Nested until https://github.com/rust-lang/rust/issues/53667 is fixed in a stable
+            // release
+            if let Some(condition) = node
+                .extra_attrs
+                .as_ref()
+                .and_then(|attrs| attrs.condition.as_ref())
+            {
+                let mut in_dag = input_dag.copy_empty_like(py, "alike")?;
+                // The remapping of `condition` below is still using the old code that assumes a 2-tuple.
+                // This is because this remapping code only makes sense in the case of non-control-flow
+                // operations being replaced.  These can only have the 2-tuple conditions, and the
+                // ability to set a condition at an individual node level will be deprecated and removed
+                // in favour of the new-style conditional blocks.  The extra logic in here to add
+                // additional wires into the map as necessary would hugely complicate matters if we tried
+                // to abstract it out into the `VariableMapper` used elsewhere.
+                let wire_map = PyDict::new_bound(py);
+                for (source_qubit, target_qubit) in &qubit_wire_map {
+                    wire_map.set_item(
+                        in_dag.qubits.get(*source_qubit).unwrap().clone_ref(py),
+                        self.qubits.get(*target_qubit).unwrap().clone_ref(py),
+                    )?
+                }
+                for (source_clbit, target_clbit) in &clbit_wire_map {
+                    wire_map.set_item(
+                        in_dag.clbits.get(*source_clbit).unwrap().clone_ref(py),
+                        self.clbits.get(*target_clbit).unwrap().clone_ref(py),
+                    )?
+                }
+                wire_map.update(var_map.bind(py).as_mapping())?;
+
+                let reverse_wire_map = wire_map.iter().map(|(k, v)| (v, k)).into_py_dict_bound(py);
+                let (py_target, py_value): (Bound<PyAny>, Bound<PyAny>) =
+                    condition.bind(py).extract()?;
+                let (py_new_target, target_cargs) =
+                    if py_target.is_instance(imports::CLBIT.get_bound(py))? {
+                        let new_target = reverse_wire_map
+                            .get_item(&py_target)?
+                            .map(Ok::<_, PyErr>)
+                            .unwrap_or_else(|| {
+                                // Target was not in node's wires, so we need a dummy.
+                                let new_target = imports::CLBIT.get_bound(py).call0()?;
+                                in_dag.add_clbit_unchecked(py, &new_target)?;
+                                wire_map.set_item(&new_target, &py_target)?;
+                                reverse_wire_map.set_item(&py_target, &new_target)?;
+                                Ok(new_target)
+                            })?;
+                        (new_target.clone(), PySet::new_bound(py, &[new_target])?)
+                    } else {
+                        // ClassicalRegister
+                        let target_bits: Vec<Bound<PyAny>> =
+                            py_target.iter()?.collect::<PyResult<_>>()?;
+                        let mapped_bits: Vec<Option<Bound<PyAny>>> = target_bits
+                            .iter()
+                            .map(|b| reverse_wire_map.get_item(b))
+                            .collect::<PyResult<_>>()?;
+
+                        let mut new_target = Vec::with_capacity(target_bits.len());
+                        let target_cargs = PySet::empty_bound(py)?;
+                        for (ours, theirs) in target_bits.into_iter().zip(mapped_bits) {
+                            if let Some(theirs) = theirs {
+                                // Target bit was in node's wires.
+                                new_target.push(theirs.clone());
+                                target_cargs.add(theirs)?;
+                            } else {
+                                // Target bit was not in node's wires, so we need a dummy.
+                                let theirs = imports::CLBIT.get_bound(py).call0()?;
+                                in_dag.add_clbit_unchecked(py, &theirs)?;
+                                wire_map.set_item(&theirs, &ours)?;
+                                reverse_wire_map.set_item(&ours, &theirs)?;
+                                new_target.push(theirs.clone());
+                                target_cargs.add(theirs)?;
+                            }
+                        }
+                        let kwargs = [("bits", new_target.into_py(py))].into_py_dict_bound(py);
+                        let new_target_register = imports::CLASSICAL_REGISTER
+                            .get_bound(py)
+                            .call((), Some(&kwargs))?;
+                        in_dag.add_creg(py, &new_target_register)?;
+                        (new_target_register, target_cargs)
+                    };
+                let new_condition = PyTuple::new_bound(py, [py_new_target, py_value]);
+
+                qubit_wire_map.clear();
+                clbit_wire_map.clear();
+                for item in wire_map.items().iter() {
+                    let (in_bit, self_bit): (Bound<PyAny>, Bound<PyAny>) = item.extract()?;
+                    if in_bit.is_instance(imports::QUBIT.get_bound(py))? {
+                        let in_index = in_dag.qubits.find(&in_bit).unwrap();
+                        let self_index = self.qubits.find(&self_bit).unwrap();
+                        qubit_wire_map.insert(in_index, self_index);
+                    } else {
+                        let in_index = in_dag.clbits.find(&in_bit).unwrap();
+                        let self_index = self.clbits.find(&self_bit).unwrap();
+                        clbit_wire_map.insert(in_index, self_index);
+                    }
+                }
+                for in_node_index in input_dag.topological_op_nodes()? {
+                    let in_node = &input_dag.dag[in_node_index];
+                    if let NodeType::Operation(inst) = in_node {
+                        if inst
+                            .extra_attrs
+                            .as_ref()
+                            .and_then(|attrs| attrs.condition.as_ref())
+                            .is_some()
+                        {
+                            return Err(DAGCircuitError::new_err(
+                                "cannot propagate a condition to an element that already has one",
+                            ));
+                        }
+                        let cargs = input_dag.cargs_cache.intern(inst.clbits);
+                        let cargs_bits: Vec<PyObject> = input_dag
+                            .clbits
+                            .map_indices(cargs)
+                            .map(|x| x.clone_ref(py))
+                            .collect();
+                        if !target_cargs
+                            .call_method1(intern!(py, "intersection"), (cargs_bits,))?
+                            .downcast::<PySet>()?
+                            .is_empty()
+                        {
+                            return Err(DAGCircuitError::new_err("cannot propagate a condition to an element that acts on those bits"));
+                        }
+                        let mut new_inst = inst.clone();
+                        if new_condition.is_truthy()? {
+                            if let Some(ref mut attrs) = new_inst.extra_attrs {
+                                attrs.condition = Some(new_condition.as_any().clone().unbind());
+                            } else {
+                                new_inst.extra_attrs = Some(Box::new(ExtraInstructionAttributes {
+                                    condition: Some(new_condition.as_any().clone().unbind()),
+                                    label: None,
+                                    duration: None,
+                                    unit: None,
+                                }));
+                            }
+                            #[cfg(feature = "cache_pygates")]
+                            {
+                                new_inst.py_op.take();
+                            }
+                        }
+                        in_dag.push_back(py, new_inst)?;
+                    }
+                }
+                let node_map = self.substitute_node_with_subgraph(
+                    py,
+                    node_index,
+                    &in_dag,
+                    &qubit_wire_map,
+                    &clbit_wire_map,
+                    &var_map,
+                )?;
+                new_input_dag = Some(in_dag);
+                node_map
+            } else {
+                self.substitute_node_with_subgraph(
+                    py,
+                    node_index,
+                    input_dag,
+                    &qubit_wire_map,
+                    &clbit_wire_map,
+                    &var_map,
+                )?
+            }
+        } else {
+            self.substitute_node_with_subgraph(
+                py,
+                node_index,
+                input_dag,
+                &qubit_wire_map,
+                &clbit_wire_map,
+                &var_map,
+            )?
+        };
+        self.global_phase = add_global_phase(py, &self.global_phase, &input_dag.global_phase)?;
+
+        let wire_map_dict = PyDict::new_bound(py);
+        for (source, target) in clbit_wire_map.iter() {
+            let source_bit = match new_input_dag {
+                Some(ref in_dag) => in_dag.clbits.get(*source),
+                None => input_dag.clbits.get(*source),
+            };
+            let target_bit = self.clbits.get(*target);
+            wire_map_dict.set_item(source_bit, target_bit)?;
+        }
+        let bound_var_map = var_map.bind(py);
+
+        // Note: creating this list to hold new registers created by the mapper is a temporary
+        // measure until qiskit.expr is ported to Rust. It is necessary because we cannot easily
+        // have Python call back to DAGCircuit::add_creg while we're currently borrowing
+        // the DAGCircuit.
+        let new_registers = PyList::empty_bound(py);
+        let add_new_register = new_registers.getattr("append")?.unbind();
+        let flush_new_registers = |dag: &mut DAGCircuit| -> PyResult<()> {
+            for reg in &new_registers {
+                dag.add_creg(py, &reg)?;
+            }
+            new_registers.del_slice(0, new_registers.len())?;
+            Ok(())
+        };
+
+        let variable_mapper = PyVariableMapper::new(
+            py,
+            self.cregs.bind(py).values().into_any(),
+            Some(wire_map_dict),
+            Some(bound_var_map.clone()),
+            Some(add_new_register),
+        )?;
+
+        for (old_node_index, new_node_index) in node_map.iter() {
+            let old_node = match new_input_dag {
+                Some(ref in_dag) => &in_dag.dag[*old_node_index],
+                None => &input_dag.dag[*old_node_index],
+            };
+            if let NodeType::Operation(old_inst) = old_node {
+                if let OperationRef::Instruction(old_op) = old_inst.op.view() {
+                    if old_op.name() == "switch_case" {
+                        let raw_target = old_op.instruction.getattr(py, "target")?;
+                        let target = raw_target.bind(py);
+                        let kwargs = PyDict::new_bound(py);
+                        kwargs.set_item(
+                            "label",
+                            old_inst
+                                .extra_attrs
+                                .as_ref()
+                                .and_then(|attrs| attrs.label.as_ref()),
+                        )?;
+                        let new_op = imports::SWITCH_CASE_OP.get_bound(py).call(
+                            (
+                                variable_mapper.map_target(target)?,
+                                old_op.instruction.call_method0(py, "cases_specifier")?,
+                            ),
+                            Some(&kwargs),
+                        )?;
+                        flush_new_registers(self)?;
+
+                        if let NodeType::Operation(ref mut new_inst) =
+                            &mut self.dag[*new_node_index]
+                        {
+                            new_inst.op = PyInstruction {
+                                qubits: old_op.num_qubits(),
+                                clbits: old_op.num_clbits(),
+                                params: old_op.num_params(),
+                                control_flow: old_op.control_flow(),
+                                op_name: old_op.name().to_string(),
+                                instruction: new_op.clone().unbind(),
+                            }
+                            .into();
+                            #[cfg(feature = "cache_pygates")]
+                            {
+                                new_inst.py_op = new_op.unbind().into();
+                            }
+                        }
+                    }
+                }
+                if let Some(condition) = old_inst
+                    .extra_attrs
+                    .as_ref()
+                    .and_then(|attrs| attrs.condition.as_ref())
+                {
+                    if old_inst.op.name() != "switch_case" {
+                        let new_condition: Option<PyObject> = variable_mapper
+                            .map_condition(condition.bind(py), false)?
+                            .extract()?;
+                        flush_new_registers(self)?;
+
+                        if let NodeType::Operation(ref mut new_inst) =
+                            &mut self.dag[*new_node_index]
+                        {
+                            match &mut new_inst.extra_attrs {
+                                Some(attrs) => attrs.condition.clone_from(&new_condition),
+                                None => {
+                                    new_inst.extra_attrs =
+                                        Some(Box::new(ExtraInstructionAttributes {
+                                            label: None,
+                                            condition: new_condition.clone(),
+                                            unit: None,
+                                            duration: None,
+                                        }))
+                                }
+                            }
+                            #[cfg(feature = "cache_pygates")]
+                            {
+                                new_inst.py_op.take();
+                            }
+                            match new_inst.op.view() {
+                                OperationRef::Instruction(py_inst) => {
+                                    py_inst
+                                        .instruction
+                                        .setattr(py, "condition", new_condition)?;
+                                }
+                                OperationRef::Gate(py_gate) => {
+                                    py_gate.gate.setattr(py, "condition", new_condition)?;
+                                }
+                                OperationRef::Operation(py_op) => {
+                                    py_op.operation.setattr(py, "condition", new_condition)?;
+                                }
+                                OperationRef::Standard(_) => {}
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        let out_dict = PyDict::new_bound(py);
+        for (old_index, new_index) in node_map {
+            out_dict.set_item(old_index.index(), self.get_node(py, new_index)?)?;
+        }
+        Ok(out_dict.unbind())
+    }
+
+    /// Replace a DAGOpNode with a single operation. qargs, cargs and
+    /// conditions for the new operation will be inferred from the node to be
+    /// replaced. The new operation will be checked to match the shape of the
+    /// replaced operation.
+    ///
+    /// Args:
+    ///     node (DAGOpNode): Node to be replaced
+    ///     op (qiskit.circuit.Operation): The :class:`qiskit.circuit.Operation`
+    ///         instance to be added to the DAG
+    ///     inplace (bool): Optional, default False. If True, existing DAG node
+    ///         will be modified to include op. Otherwise, a new DAG node will
+    ///         be used.
+    ///     propagate_condition (bool): Optional, default True.  If True, a condition on the
+    ///         ``node`` to be replaced will be applied to the new ``op``.  This is the legacy
+    ///         behaviour.  If either node is a control-flow operation, this will be ignored.  If
+    ///         the ``op`` already has a condition, :exc:`.DAGCircuitError` is raised.
+    ///
+    /// Returns:
+    ///     DAGOpNode: the new node containing the added operation.
+    ///
+    /// Raises:
+    ///     DAGCircuitError: If replacement operation was incompatible with
+    ///     location of target node.
+    #[pyo3(signature = (node, op, inplace=false, propagate_condition=true))]
+    fn substitute_node(
+        &mut self,
+        node: &Bound<PyAny>,
+        op: &Bound<PyAny>,
+        inplace: bool,
+        propagate_condition: bool,
+    ) -> PyResult<Py<PyAny>> {
+        let mut node: PyRefMut<DAGOpNode> = match node.downcast() {
+            Ok(node) => node.borrow_mut(),
+            Err(_) => return Err(DAGCircuitError::new_err("Only DAGOpNodes can be replaced.")),
+        };
+        let py = op.py();
+        let node_index = node.as_ref().node.unwrap();
+        // Extract information from node that is going to be replaced
+        let old_packed = match self.dag.node_weight(node_index) {
+            Some(NodeType::Operation(old_packed)) => old_packed.clone(),
+            Some(_) => {
+                return Err(DAGCircuitError::new_err(
+                    "'node' must be of type 'DAGOpNode'.",
+                ))
+            }
+            None => return Err(DAGCircuitError::new_err("'node' not found in DAG.")),
+        };
+        // Extract information from new op
+        let new_op = op.extract::<OperationFromPython>()?;
+        let current_wires: HashSet<Wire> = self
+            .dag
+            .edges(node_index)
+            .map(|e| e.weight().clone())
+            .collect();
+        let mut new_wires: HashSet<Wire> = self
+            .qargs_cache
+            .intern(old_packed.qubits)
+            .iter()
+            .map(|x| Wire::Qubit(*x))
+            .chain(
+                self.cargs_cache
+                    .intern(old_packed.clbits)
+                    .iter()
+                    .map(|x| Wire::Clbit(*x)),
+            )
+            .collect();
+        let (additional_clbits, additional_vars) = self.additional_wires(
+            py,
+            new_op.operation.view(),
+            new_op
+                .extra_attrs
+                .as_ref()
+                .and_then(|attrs| attrs.condition.as_ref()),
+        )?;
+        new_wires.extend(additional_clbits.iter().map(|x| Wire::Clbit(*x)));
+        new_wires.extend(additional_vars.iter().map(|x| Wire::Var(x.clone_ref(py))));
+
+        if old_packed.op.num_qubits() != new_op.operation.num_qubits()
+            || old_packed.op.num_clbits() != new_op.operation.num_clbits()
+        {
+            return Err(DAGCircuitError::new_err(
+                format!(
+                    "Cannot replace node of width ({} qubits, {} clbits) with operation of mismatched width ({} qubits, {} clbits)",
+                    old_packed.op.num_qubits(), old_packed.op.num_clbits(), new_op.operation.num_qubits(), new_op.operation.num_clbits()
+                )));
+        }
+
+        #[cfg(feature = "cache_pygates")]
+        let mut py_op_cache = Some(op.clone().unbind());
+
+        let mut extra_attrs = new_op.extra_attrs.clone();
+        // If either operation is a control-flow operation, propagate_condition is ignored
+        if propagate_condition
+            && !(node.instruction.operation.control_flow() || new_op.operation.control_flow())
+        {
+            // if new_op has a condition, the condition can't be propagated from the old node
+            if new_op
+                .extra_attrs
+                .as_ref()
+                .and_then(|extra| extra.condition.as_ref())
+                .is_some()
+            {
+                return Err(DAGCircuitError::new_err(
+                    "Cannot propagate a condition to an operation that already has one.",
+                ));
+            }
+            if let Some(old_condition) = old_packed.condition() {
+                if matches!(new_op.operation.view(), OperationRef::Operation(_)) {
+                    return Err(DAGCircuitError::new_err(
+                        "Cannot add a condition on a generic Operation.",
+                    ));
+                }
+                if let Some(ref mut extra) = extra_attrs {
+                    extra.condition = Some(old_condition.clone_ref(py));
+                } else {
+                    extra_attrs = ExtraInstructionAttributes::new(
+                        None,
+                        None,
+                        None,
+                        Some(old_condition.clone_ref(py)),
+                    )
+                    .map(Box::new)
+                }
+                let binding = self
+                    .control_flow_module
+                    .condition_resources(old_condition.bind(py))?;
+                let condition_clbits = binding.clbits.bind(py);
+                for bit in condition_clbits {
+                    new_wires.insert(Wire::Clbit(self.clbits.find(&bit).unwrap()));
+                }
+                let op_ref = new_op.operation.view();
+                if let OperationRef::Instruction(inst) = op_ref {
+                    inst.instruction
+                        .bind(py)
+                        .setattr(intern!(py, "condition"), old_condition)?;
+                } else if let OperationRef::Gate(gate) = op_ref {
+                    gate.gate.bind(py).call_method1(
+                        intern!(py, "c_if"),
+                        old_condition.downcast_bound::<PyTuple>(py)?,
+                    )?;
+                }
+                #[cfg(feature = "cache_pygates")]
+                {
+                    py_op_cache = None;
+                }
+            }
+        };
+        if new_wires != current_wires {
+            // The new wires must be a non-strict subset of the current wires; if they add new
+            // wires, we'd not know where to cut the existing wire to insert the new dependency.
+            return Err(DAGCircuitError::new_err(format!(
+                "New operation '{:?}' does not span the same wires as the old node '{:?}'. New wires: {:?}, old_wires: {:?}.", op.str(), old_packed.op.view(), new_wires, current_wires
+            )));
+        }
+
+        if inplace {
+            node.instruction.operation = new_op.operation.clone();
+            node.instruction.params = new_op.params.clone();
+            node.instruction.extra_attrs = extra_attrs.clone();
+            #[cfg(feature = "cache_pygates")]
+            {
+                node.instruction.py_op = py_op_cache
+                    .as_ref()
+                    .map(|ob| OnceCell::from(ob.clone_ref(py)))
+                    .unwrap_or_default();
+            }
+        }
+        // Clone op data, as it will be moved into the PackedInstruction
+        let new_weight = NodeType::Operation(PackedInstruction {
+            op: new_op.operation.clone(),
+            qubits: old_packed.qubits,
+            clbits: old_packed.clbits,
+            params: (!new_op.params.is_empty()).then(|| new_op.params.into()),
+            extra_attrs,
+            #[cfg(feature = "cache_pygates")]
+            py_op: py_op_cache.map(OnceCell::from).unwrap_or_default(),
+        });
+        let node_index = node.as_ref().node.unwrap();
+        if let Some(weight) = self.dag.node_weight_mut(node_index) {
+            *weight = new_weight;
+        }
+
+        // Update self.op_names
+        self.decrement_op(old_packed.op.name());
+        self.increment_op(new_op.operation.name());
+
+        if inplace {
+            Ok(node.into_py(py))
+        } else {
+            self.get_node(py, node_index)
+        }
+    }
+
+    /// Decompose the circuit into sets of qubits with no gates connecting them.
+    ///
+    /// Args:
+    ///     remove_idle_qubits (bool): Flag denoting whether to remove idle qubits from
+    ///         the separated circuits. If ``False``, each output circuit will contain the
+    ///         same number of qubits as ``self``.
+    ///
+    /// Returns:
+    ///     List[DAGCircuit]: The circuits resulting from separating ``self`` into sets
+    ///         of disconnected qubits
+    ///
+    /// Each :class:`~.DAGCircuit` instance returned by this method will contain the same number of
+    /// clbits as ``self``. The global phase information in ``self`` will not be maintained
+    /// in the subcircuits returned by this method.
+    #[pyo3(signature = (remove_idle_qubits=false, *, vars_mode="alike"))]
+    fn separable_circuits(
+        &self,
+        py: Python,
+        remove_idle_qubits: bool,
+        vars_mode: &str,
+    ) -> PyResult<Py<PyList>> {
+        let connected_components = rustworkx_core::connectivity::connected_components(&self.dag);
+        let dags = PyList::empty_bound(py);
+
+        for comp_nodes in connected_components.iter() {
+            let mut new_dag = self.copy_empty_like(py, vars_mode)?;
+            new_dag.global_phase = Param::Float(0.);
+
+            // A map from nodes in the this DAGCircuit to nodes in the new dag. Used for adding edges
+            let mut node_map: HashMap<NodeIndex, NodeIndex> =
+                HashMap::with_capacity(comp_nodes.len());
+
+            // Adding the nodes to the new dag
+            let mut non_classical = false;
+            for node in comp_nodes {
+                match self.dag.node_weight(*node) {
+                    Some(w) => match w {
+                        NodeType::ClbitIn(b) => {
+                            let clbit_in = new_dag.clbit_io_map[b.0 as usize][0];
+                            node_map.insert(*node, clbit_in);
+                        }
+                        NodeType::ClbitOut(b) => {
+                            let clbit_out = new_dag.clbit_io_map[b.0 as usize][1];
+                            node_map.insert(*node, clbit_out);
+                        }
+                        NodeType::QubitIn(q) => {
+                            let qbit_in = new_dag.qubit_io_map[q.0 as usize][0];
+                            node_map.insert(*node, qbit_in);
+                            non_classical = true;
+                        }
+                        NodeType::QubitOut(q) => {
+                            let qbit_out = new_dag.qubit_io_map[q.0 as usize][1];
+                            node_map.insert(*node, qbit_out);
+                            non_classical = true;
+                        }
+                        NodeType::VarIn(v) => {
+                            let var_in = new_dag.var_input_map.get(py, v).unwrap();
+                            node_map.insert(*node, var_in);
+                        }
+                        NodeType::VarOut(v) => {
+                            let var_out = new_dag.var_output_map.get(py, v).unwrap();
+                            node_map.insert(*node, var_out);
+                        }
+                        NodeType::Operation(pi) => {
+                            let new_node = new_dag.dag.add_node(NodeType::Operation(pi.clone()));
+                            new_dag.increment_op(pi.op.name());
+                            node_map.insert(*node, new_node);
+                            non_classical = true;
+                        }
+                    },
+                    None => panic!("DAG node without payload!"),
+                }
+            }
+            if !non_classical {
+                continue;
+            }
+            let node_filter = |node: NodeIndex| -> bool { node_map.contains_key(&node) };
+
+            let filtered = NodeFiltered(&self.dag, node_filter);
+
+            // Remove the edges added by copy_empty_like (as idle wires) to avoid duplication
+            new_dag.dag.clear_edges();
+            for edge in filtered.edge_references() {
+                let new_source = node_map[&edge.source()];
+                let new_target = node_map[&edge.target()];
+                new_dag
+                    .dag
+                    .add_edge(new_source, new_target, edge.weight().clone());
+            }
+            // Add back any edges for idle wires
+            for (qubit, [in_node, out_node]) in new_dag
+                .qubit_io_map
+                .iter()
+                .enumerate()
+                .map(|(idx, indices)| (Qubit(idx as u32), indices))
+            {
+                if new_dag.dag.edges(*in_node).next().is_none() {
+                    new_dag
+                        .dag
+                        .add_edge(*in_node, *out_node, Wire::Qubit(qubit));
+                }
+            }
+            for (clbit, [in_node, out_node]) in new_dag
+                .clbit_io_map
+                .iter()
+                .enumerate()
+                .map(|(idx, indices)| (Clbit(idx as u32), indices))
+            {
+                if new_dag.dag.edges(*in_node).next().is_none() {
+                    new_dag
+                        .dag
+                        .add_edge(*in_node, *out_node, Wire::Clbit(clbit));
+                }
+            }
+            for (var, in_node) in new_dag.var_input_map.iter(py) {
+                if new_dag.dag.edges(in_node).next().is_none() {
+                    let out_node = new_dag.var_output_map.get(py, &var).unwrap();
+                    new_dag
+                        .dag
+                        .add_edge(in_node, out_node, Wire::Var(var.clone_ref(py)));
+                }
+            }
+            if remove_idle_qubits {
+                let idle_wires: Vec<Bound<PyAny>> = new_dag
+                    .idle_wires(py, None)?
+                    .into_bound(py)
+                    .map(|q| q.unwrap())
+                    .filter(|e| e.is_instance(imports::QUBIT.get_bound(py)).unwrap())
+                    .collect();
+
+                let qubits = PyTuple::new_bound(py, idle_wires);
+                new_dag.remove_qubits(py, &qubits)?; // TODO: this does not really work, some issue with remove_qubits itself
+            }
+
+            dags.append(pyo3::Py::new(py, new_dag)?)?;
+        }
+
+        Ok(dags.unbind())
+    }
+
+    /// Swap connected nodes e.g. due to commutation.
+    ///
+    /// Args:
+    ///     node1 (OpNode): predecessor node
+    ///     node2 (OpNode): successor node
+    ///
+    /// Raises:
+    ///     DAGCircuitError: if either node is not an OpNode or nodes are not connected
+    fn swap_nodes(&mut self, node1: &DAGNode, node2: &DAGNode) -> PyResult<()> {
+        let node1 = node1.node.unwrap();
+        let node2 = node2.node.unwrap();
+
+        // Check that both nodes correspond to operations
+        if !matches!(self.dag.node_weight(node1).unwrap(), NodeType::Operation(_))
+            || !matches!(self.dag.node_weight(node2).unwrap(), NodeType::Operation(_))
+        {
+            return Err(DAGCircuitError::new_err(
+                "Nodes to swap are not both DAGOpNodes",
+            ));
+        }
+
+        // Gather all wires connecting node1 and node2.
+        // This functionality was extracted from rustworkx's 'get_edge_data'
+        let wires: Vec<Wire> = self
+            .dag
+            .edges(node1)
+            .filter(|edge| edge.target() == node2)
+            .map(|edge| edge.weight().clone())
+            .collect();
+
+        if wires.is_empty() {
+            return Err(DAGCircuitError::new_err(
+                "Attempt to swap unconnected nodes",
+            ));
+        };
+
+        // Closure that finds the first parent/child node connected to a reference node by given wire
+        // and returns relevant edge information depending on the specified direction:
+        //  - Incoming -> parent -> outputs (parent_edge_id, parent_source_node_id)
+        //  - Outgoing -> child -> outputs (child_edge_id, child_target_node_id)
+        // This functionality was inspired in rustworkx's 'find_predecessors_by_edge' and 'find_successors_by_edge'.
+        let directed_edge_for_wire = |node: NodeIndex, direction: Direction, wire: &Wire| {
+            for edge in self.dag.edges_directed(node, direction) {
+                if wire == edge.weight() {
+                    match direction {
+                        Incoming => return Some((edge.id(), edge.source())),
+                        Outgoing => return Some((edge.id(), edge.target())),
+                    }
+                }
+            }
+            None
+        };
+
+        // Vector that contains a tuple of (wire, edge_info, parent_info, child_info) per wire in wires
+        let relevant_edges = wires
+            .iter()
+            .rev()
+            .map(|wire| {
+                (
+                    wire,
+                    directed_edge_for_wire(node1, Outgoing, wire).unwrap(),
+                    directed_edge_for_wire(node1, Incoming, wire).unwrap(),
+                    directed_edge_for_wire(node2, Outgoing, wire).unwrap(),
+                )
+            })
+            .collect::<Vec<_>>();
+
+        // Iterate over relevant edges and modify self.dag
+        for (wire, (node1_to_node2, _), (parent_to_node1, parent), (node2_to_child, child)) in
+            relevant_edges
+        {
+            self.dag.remove_edge(parent_to_node1);
+            self.dag.add_edge(parent, node2, wire.clone());
+            self.dag.remove_edge(node1_to_node2);
+            self.dag.add_edge(node2, node1, wire.clone());
+            self.dag.remove_edge(node2_to_child);
+            self.dag.add_edge(node1, child, wire.clone());
+        }
+        Ok(())
+    }
+
+    /// Get the node in the dag.
+    ///
+    /// Args:
+    ///     node_id(int): Node identifier.
+    ///
+    /// Returns:
+    ///     node: the node.
+    fn node(&self, py: Python, node_id: isize) -> PyResult<Py<PyAny>> {
+        self.get_node(py, NodeIndex::new(node_id as usize))
+    }
+
+    /// Iterator for node values.
+    ///
+    /// Yield:
+    ///     node: the node.
+    fn nodes(&self, py: Python) -> PyResult<Py<PyIterator>> {
+        let result: PyResult<Vec<_>> = self
+            .dag
+            .node_references()
+            .map(|(node, weight)| self.unpack_into(py, node, weight))
+            .collect();
+        let tup = PyTuple::new_bound(py, result?);
+        Ok(tup.into_any().iter().unwrap().unbind())
+    }
+
+    /// Iterator for edge values with source and destination node.
+    ///
+    /// This works by returning the outgoing edges from the specified nodes. If
+    /// no nodes are specified all edges from the graph are returned.
+    ///
+    /// Args:
+    ///     nodes(DAGOpNode, DAGInNode, or DAGOutNode|list(DAGOpNode, DAGInNode, or DAGOutNode):
+    ///         Either a list of nodes or a single input node. If none is specified,
+    ///         all edges are returned from the graph.
+    ///
+    /// Yield:
+    ///     edge: the edge as a tuple with the format
+    ///         (source node, destination node, edge wire)
+    fn edges(&self, nodes: Option<Bound<PyAny>>, py: Python) -> PyResult<Py<PyIterator>> {
+        let get_node_index = |obj: &Bound<PyAny>| -> PyResult<NodeIndex> {
+            Ok(obj.downcast::<DAGNode>()?.borrow().node.unwrap())
+        };
+
+        let actual_nodes: Vec<_> = match nodes {
+            None => self.dag.node_indices().collect(),
+            Some(nodes) => {
+                let mut out = Vec::new();
+                if let Ok(node) = get_node_index(&nodes) {
+                    out.push(node);
+                } else {
+                    for node in nodes.iter()? {
+                        out.push(get_node_index(&node?)?);
+                    }
+                }
+                out
+            }
+        };
+
+        let mut edges = Vec::new();
+        for node in actual_nodes {
+            for edge in self.dag.edges_directed(node, Outgoing) {
+                edges.push((
+                    self.get_node(py, edge.source())?,
+                    self.get_node(py, edge.target())?,
+                    match edge.weight() {
+                        Wire::Qubit(qubit) => self.qubits.get(*qubit).unwrap(),
+                        Wire::Clbit(clbit) => self.clbits.get(*clbit).unwrap(),
+                        Wire::Var(var) => var,
+                    },
+                ))
+            }
+        }
+
+        Ok(PyTuple::new_bound(py, edges)
+            .into_any()
+            .iter()
+            .unwrap()
+            .unbind())
+    }
+
+    /// Get the list of "op" nodes in the dag.
+    ///
+    /// Args:
+    ///     op (Type): :class:`qiskit.circuit.Operation` subclass op nodes to
+    ///         return. If None, return all op nodes.
+    ///     include_directives (bool): include `barrier`, `snapshot` etc.
+    ///
+    /// Returns:
+    ///     list[DAGOpNode]: the list of node ids containing the given op.
+    #[pyo3(name= "op_nodes", signature=(op=None, include_directives=true))]
+    fn py_op_nodes(
+        &self,
+        py: Python,
+        op: Option<&Bound<PyType>>,
+        include_directives: bool,
+    ) -> PyResult<Vec<Py<PyAny>>> {
+        let mut nodes = Vec::new();
+        let filter_is_nonstandard = if let Some(op) = op {
+            op.getattr(intern!(py, "_standard_gate")).ok().is_none()
+        } else {
+            true
+        };
+        for (node, weight) in self.dag.node_references() {
+            if let NodeType::Operation(packed) = &weight {
+                if !include_directives && packed.op.directive() {
+                    continue;
+                }
+                if let Some(op_type) = op {
+                    // This middle catch is to avoid Python-space operation creation for most uses of
+                    // `op`; we're usually just looking for control-flow ops, and standard gates
+                    // aren't control-flow ops.
+                    if !(filter_is_nonstandard && packed.op.try_standard_gate().is_some())
+                        && packed.op.py_op_is_instance(op_type)?
+                    {
+                        nodes.push(self.unpack_into(py, node, weight)?);
+                    }
+                } else {
+                    nodes.push(self.unpack_into(py, node, weight)?);
+                }
+            }
+        }
+        Ok(nodes)
+    }
+
+    /// Get the list of gate nodes in the dag.
+    ///
+    /// Returns:
+    ///     list[DAGOpNode]: the list of DAGOpNodes that represent gates.
+    fn gate_nodes(&self, py: Python) -> PyResult<Vec<Py<PyAny>>> {
+        self.dag
+            .node_references()
+            .filter_map(|(node, weight)| match weight {
+                NodeType::Operation(ref packed) => match packed.op.view() {
+                    OperationRef::Gate(_) | OperationRef::Standard(_) => {
+                        Some(self.unpack_into(py, node, weight))
+                    }
+                    _ => None,
+                },
+                _ => None,
+            })
+            .collect()
+    }
+
+    /// Get the set of "op" nodes with the given name.
+    #[pyo3(signature = (*names))]
+    fn named_nodes(&self, py: Python<'_>, names: &Bound<PyTuple>) -> PyResult<Vec<Py<PyAny>>> {
+        let mut names_set: HashSet<String> = HashSet::with_capacity(names.len());
+        for name_obj in names.iter() {
+            names_set.insert(name_obj.extract::<String>()?);
+        }
+        let mut result: Vec<Py<PyAny>> = Vec::new();
+        for (id, weight) in self.dag.node_references() {
+            if let NodeType::Operation(ref packed) = weight {
+                if names_set.contains(packed.op.name()) {
+                    result.push(self.unpack_into(py, id, weight)?);
+                }
+            }
+        }
+        Ok(result)
+    }
+
+    /// Get list of 2 qubit operations. Ignore directives like snapshot and barrier.
+    fn two_qubit_ops(&self, py: Python) -> PyResult<Vec<Py<PyAny>>> {
+        let mut nodes = Vec::new();
+        for (node, weight) in self.dag.node_references() {
+            if let NodeType::Operation(ref packed) = weight {
+                if packed.op.directive() {
+                    continue;
+                }
+
+                let qargs = self.qargs_cache.intern(packed.qubits);
+                if qargs.len() == 2 {
+                    nodes.push(self.unpack_into(py, node, weight)?);
+                }
+            }
+        }
+        Ok(nodes)
+    }
+
+    /// Get list of 3+ qubit operations. Ignore directives like snapshot and barrier.
+    fn multi_qubit_ops(&self, py: Python) -> PyResult<Vec<Py<PyAny>>> {
+        let mut nodes = Vec::new();
+        for (node, weight) in self.dag.node_references() {
+            if let NodeType::Operation(ref packed) = weight {
+                if packed.op.directive() {
+                    continue;
+                }
+
+                let qargs = self.qargs_cache.intern(packed.qubits);
+                if qargs.len() >= 3 {
+                    nodes.push(self.unpack_into(py, node, weight)?);
+                }
+            }
+        }
+        Ok(nodes)
+    }
+
+    /// Returns the longest path in the dag as a list of DAGOpNodes, DAGInNodes, and DAGOutNodes.
+    fn longest_path(&self, py: Python) -> PyResult<Vec<PyObject>> {
+        let weight_fn = |_| -> Result<usize, Infallible> { Ok(1) };
+        match rustworkx_core::dag_algo::longest_path(&self.dag, weight_fn).unwrap() {
+            Some(res) => res.0,
+            None => return Err(DAGCircuitError::new_err("not a DAG")),
+        }
+        .into_iter()
+        .map(|node_index| self.get_node(py, node_index))
+        .collect()
+    }
+
+    /// Returns iterator of the successors of a node as DAGOpNodes and DAGOutNodes."""
+    fn successors(&self, py: Python, node: &DAGNode) -> PyResult<Py<PyIterator>> {
+        let successors: PyResult<Vec<_>> = self
+            .dag
+            .neighbors_directed(node.node.unwrap(), Outgoing)
+            .unique()
+            .map(|i| self.get_node(py, i))
+            .collect();
+        Ok(PyTuple::new_bound(py, successors?)
+            .into_any()
+            .iter()
+            .unwrap()
+            .unbind())
+    }
+
+    /// Returns iterator of the predecessors of a node as DAGOpNodes and DAGInNodes.
+    fn predecessors(&self, py: Python, node: &DAGNode) -> PyResult<Py<PyIterator>> {
+        let predecessors: PyResult<Vec<_>> = self
+            .dag
+            .neighbors_directed(node.node.unwrap(), Incoming)
+            .unique()
+            .map(|i| self.get_node(py, i))
+            .collect();
+        Ok(PyTuple::new_bound(py, predecessors?)
+            .into_any()
+            .iter()
+            .unwrap()
+            .unbind())
+    }
+
+    /// Returns iterator of "op" successors of a node in the dag.
+    fn op_successors(&self, py: Python, node: &DAGNode) -> PyResult<Py<PyIterator>> {
+        let predecessors: PyResult<Vec<_>> = self
+            .dag
+            .neighbors_directed(node.node.unwrap(), Outgoing)
+            .unique()
+            .filter_map(|i| match self.dag[i] {
+                NodeType::Operation(_) => Some(self.get_node(py, i)),
+                _ => None,
+            })
+            .collect();
+        Ok(PyTuple::new_bound(py, predecessors?)
+            .into_any()
+            .iter()
+            .unwrap()
+            .unbind())
+    }
+
+    /// Returns the iterator of "op" predecessors of a node in the dag.
+    fn op_predecessors(&self, py: Python, node: &DAGNode) -> PyResult<Py<PyIterator>> {
+        let predecessors: PyResult<Vec<_>> = self
+            .dag
+            .neighbors_directed(node.node.unwrap(), Incoming)
+            .unique()
+            .filter_map(|i| match self.dag[i] {
+                NodeType::Operation(_) => Some(self.get_node(py, i)),
+                _ => None,
+            })
+            .collect();
+        Ok(PyTuple::new_bound(py, predecessors?)
+            .into_any()
+            .iter()
+            .unwrap()
+            .unbind())
+    }
+
+    /// Checks if a second node is in the successors of node.
+    fn is_successor(&self, node: &DAGNode, node_succ: &DAGNode) -> bool {
+        self.dag
+            .find_edge(node.node.unwrap(), node_succ.node.unwrap())
+            .is_some()
+    }
+
+    /// Checks if a second node is in the predecessors of node.
+    fn is_predecessor(&self, node: &DAGNode, node_pred: &DAGNode) -> bool {
+        self.dag
+            .find_edge(node_pred.node.unwrap(), node.node.unwrap())
+            .is_some()
+    }
+
+    /// Returns iterator of the predecessors of a node that are
+    /// connected by a quantum edge as DAGOpNodes and DAGInNodes.
+    #[pyo3(name = "quantum_predecessors")]
+    fn py_quantum_predecessors(&self, py: Python, node: &DAGNode) -> PyResult<Py<PyIterator>> {
+        let predecessors: PyResult<Vec<_>> = self
+            .quantum_predecessors(node.node.unwrap())
+            .map(|i| self.get_node(py, i))
+            .collect();
+        Ok(PyTuple::new_bound(py, predecessors?)
+            .into_any()
+            .iter()
+            .unwrap()
+            .unbind())
+    }
+
+    /// Returns iterator of the successors of a node that are
+    /// connected by a quantum edge as DAGOpNodes and DAGOutNodes.
+    #[pyo3(name = "quantum_successors")]
+    fn py_quantum_successors(&self, py: Python, node: &DAGNode) -> PyResult<Py<PyIterator>> {
+        let successors: PyResult<Vec<_>> = self
+            .quantum_successors(node.node.unwrap())
+            .map(|i| self.get_node(py, i))
+            .collect();
+        Ok(PyTuple::new_bound(py, successors?)
+            .into_any()
+            .iter()
+            .unwrap()
+            .unbind())
+    }
+
+    /// Returns iterator of the predecessors of a node that are
+    /// connected by a classical edge as DAGOpNodes and DAGInNodes.
+    fn classical_predecessors(&self, py: Python, node: &DAGNode) -> PyResult<Py<PyIterator>> {
+        let edges = self.dag.edges_directed(node.node.unwrap(), Incoming);
+        let filtered = edges.filter_map(|e| match e.weight() {
+            Wire::Qubit(_) => None,
+            _ => Some(e.source()),
+        });
+        let predecessors: PyResult<Vec<_>> =
+            filtered.unique().map(|i| self.get_node(py, i)).collect();
+        Ok(PyTuple::new_bound(py, predecessors?)
+            .into_any()
+            .iter()
+            .unwrap()
+            .unbind())
+    }
+
+    /// Returns set of the ancestors of a node as DAGOpNodes and DAGInNodes.
+    #[pyo3(name = "ancestors")]
+    fn py_ancestors(&self, py: Python, node: &DAGNode) -> PyResult<Py<PySet>> {
+        let ancestors: PyResult<Vec<PyObject>> = self
+            .ancestors(node.node.unwrap())
+            .map(|node| self.get_node(py, node))
+            .collect();
+        Ok(PySet::new_bound(py, &ancestors?)?.unbind())
+    }
+
+    /// Returns set of the descendants of a node as DAGOpNodes and DAGOutNodes.
+    #[pyo3(name = "descendants")]
+    fn py_descendants(&self, py: Python, node: &DAGNode) -> PyResult<Py<PySet>> {
+        let descendants: PyResult<Vec<PyObject>> = self
+            .descendants(node.node.unwrap())
+            .map(|node| self.get_node(py, node))
+            .collect();
+        Ok(PySet::new_bound(py, &descendants?)?.unbind())
+    }
+
+    /// Returns an iterator of tuples of (DAGNode, [DAGNodes]) where the DAGNode is the current node
+    /// and [DAGNode] is its successors in  BFS order.
+    #[pyo3(name = "bfs_successors")]
+    fn py_bfs_successors(&self, py: Python, node: &DAGNode) -> PyResult<Py<PyIterator>> {
+        let successor_index: PyResult<Vec<(PyObject, Vec<PyObject>)>> = self
+            .bfs_successors(node.node.unwrap())
+            .map(|(node, nodes)| -> PyResult<(PyObject, Vec<PyObject>)> {
+                Ok((
+                    self.get_node(py, node)?,
+                    nodes
+                        .iter()
+                        .map(|sub_node| self.get_node(py, *sub_node))
+                        .collect::<PyResult<Vec<_>>>()?,
+                ))
+            })
+            .collect();
+        Ok(PyList::new_bound(py, successor_index?)
+            .into_any()
+            .iter()?
+            .unbind())
+    }
+
+    /// Returns iterator of the successors of a node that are
+    /// connected by a classical edge as DAGOpNodes and DAGOutNodes.
+    fn classical_successors(&self, py: Python, node: &DAGNode) -> PyResult<Py<PyIterator>> {
+        let edges = self.dag.edges_directed(node.node.unwrap(), Outgoing);
+        let filtered = edges.filter_map(|e| match e.weight() {
+            Wire::Qubit(_) => None,
+            _ => Some(e.target()),
+        });
+        let predecessors: PyResult<Vec<_>> =
+            filtered.unique().map(|i| self.get_node(py, i)).collect();
+        Ok(PyTuple::new_bound(py, predecessors?)
+            .into_any()
+            .iter()
+            .unwrap()
+            .unbind())
+    }
+
+    /// Remove an operation node n.
+    ///
+    /// Add edges from predecessors to successors.
+    #[pyo3(name = "remove_op_node")]
+    fn py_remove_op_node(&mut self, node: &Bound<PyAny>) -> PyResult<()> {
+        let node: PyRef<DAGOpNode> = match node.downcast::<DAGOpNode>() {
+            Ok(node) => node.borrow(),
+            Err(_) => return Err(DAGCircuitError::new_err("Node not an DAGOpNode")),
+        };
+        let index = node.as_ref().node.unwrap();
+        if self.dag.node_weight(index).is_none() {
+            return Err(DAGCircuitError::new_err("Node not in DAG"));
+        }
+        self.remove_op_node(index);
+        Ok(())
+    }
+
+    /// Remove all of the ancestor operation nodes of node.
+    fn remove_ancestors_of(&mut self, node: &DAGNode) -> PyResult<()> {
+        let ancestors: Vec<_> = core_ancestors(&self.dag, node.node.unwrap())
+            .filter(|next| {
+                next != &node.node.unwrap()
+                    && matches!(self.dag.node_weight(*next), Some(NodeType::Operation(_)))
+            })
+            .collect();
+        for a in ancestors {
+            self.dag.remove_node(a);
+        }
+        Ok(())
+    }
+
+    /// Remove all of the descendant operation nodes of node.
+    fn remove_descendants_of(&mut self, node: &DAGNode) -> PyResult<()> {
+        let descendants: Vec<_> = core_descendants(&self.dag, node.node.unwrap())
+            .filter(|next| {
+                next != &node.node.unwrap()
+                    && matches!(self.dag.node_weight(*next), Some(NodeType::Operation(_)))
+            })
+            .collect();
+        for d in descendants {
+            self.dag.remove_node(d);
+        }
+        Ok(())
+    }
+
+    /// Remove all of the non-ancestors operation nodes of node.
+    fn remove_nonancestors_of(&mut self, node: &DAGNode) -> PyResult<()> {
+        let ancestors: HashSet<_> = core_ancestors(&self.dag, node.node.unwrap())
+            .filter(|next| {
+                next != &node.node.unwrap()
+                    && matches!(self.dag.node_weight(*next), Some(NodeType::Operation(_)))
+            })
+            .collect();
+        let non_ancestors: Vec<_> = self
+            .dag
+            .node_indices()
+            .filter(|node_id| !ancestors.contains(node_id))
+            .collect();
+        for na in non_ancestors {
+            self.dag.remove_node(na);
+        }
+        Ok(())
+    }
+
+    /// Remove all of the non-descendants operation nodes of node.
+    fn remove_nondescendants_of(&mut self, node: &DAGNode) -> PyResult<()> {
+        let descendants: HashSet<_> = core_descendants(&self.dag, node.node.unwrap())
+            .filter(|next| {
+                next != &node.node.unwrap()
+                    && matches!(self.dag.node_weight(*next), Some(NodeType::Operation(_)))
+            })
+            .collect();
+        let non_descendants: Vec<_> = self
+            .dag
+            .node_indices()
+            .filter(|node_id| !descendants.contains(node_id))
+            .collect();
+        for nd in non_descendants {
+            self.dag.remove_node(nd);
+        }
+        Ok(())
+    }
+
+    /// Return a list of op nodes in the first layer of this dag.
+    #[pyo3(name = "front_layer")]
+    fn py_front_layer(&self, py: Python) -> PyResult<Py<PyList>> {
+        let native_front_layer = self.front_layer(py);
+        let front_layer_list = PyList::empty_bound(py);
+        for node in native_front_layer {
+            front_layer_list.append(self.get_node(py, node)?)?;
+        }
+        Ok(front_layer_list.into())
+    }
+
+    /// Yield a shallow view on a layer of this DAGCircuit for all d layers of this circuit.
+    ///
+    /// A layer is a circuit whose gates act on disjoint qubits, i.e.,
+    /// a layer has depth 1. The total number of layers equals the
+    /// circuit depth d. The layers are indexed from 0 to d-1 with the
+    /// earliest layer at index 0. The layers are constructed using a
+    /// greedy algorithm. Each returned layer is a dict containing
+    /// {"graph": circuit graph, "partition": list of qubit lists}.
+    ///
+    /// The returned layer contains new (but semantically equivalent) DAGOpNodes, DAGInNodes,
+    /// and DAGOutNodes. These are not the same as nodes of the original dag, but are equivalent
+    /// via DAGNode.semantic_eq(node1, node2).
+    ///
+    /// TODO: Gates that use the same cbits will end up in different
+    /// layers as this is currently implemented. This may not be
+    /// the desired behavior.
+    #[pyo3(signature = (*, vars_mode="captures"))]
+    fn layers(&self, py: Python, vars_mode: &str) -> PyResult<Py<PyIterator>> {
+        let layer_list = PyList::empty_bound(py);
+        let mut graph_layers = self.multigraph_layers(py);
+        if graph_layers.next().is_none() {
+            return Ok(PyIterator::from_bound_object(&layer_list)?.into());
+        }
+
+        for graph_layer in graph_layers {
+            let layer_dict = PyDict::new_bound(py);
+            // Sort to make sure they are in the order they were added to the original DAG
+            // It has to be done by node_id as graph_layer is just a list of nodes
+            // with no implied topology
+            // Drawing tools rely on _node_id to infer order of node creation
+            // so we need this to be preserved by layers()
+            // Get the op nodes from the layer, removing any input and output nodes.
+            let mut op_nodes: Vec<(&PackedInstruction, &NodeIndex)> = graph_layer
+                .iter()
+                .filter_map(|node| self.dag.node_weight(*node).map(|dag_node| (dag_node, node)))
+                .filter_map(|(node, index)| match node {
+                    NodeType::Operation(oper) => Some((oper, index)),
+                    _ => None,
+                })
+                .collect();
+            op_nodes.sort_by_key(|(_, node_index)| **node_index);
+
+            if op_nodes.is_empty() {
+                return Ok(PyIterator::from_bound_object(&layer_list)?.into());
+            }
+
+            let mut new_layer = self.copy_empty_like(py, vars_mode)?;
+
+            for (node, _) in op_nodes {
+                new_layer.push_back(py, node.clone())?;
+            }
+
+            let new_layer_op_nodes = new_layer.op_nodes(false).filter_map(|node_index| {
+                match new_layer.dag.node_weight(node_index) {
+                    Some(NodeType::Operation(ref node)) => Some(node),
+                    _ => None,
+                }
+            });
+            let support_iter = new_layer_op_nodes.into_iter().map(|node| {
+                PyTuple::new_bound(
+                    py,
+                    new_layer
+                        .qubits
+                        .map_indices(new_layer.qargs_cache.intern(node.qubits)),
+                )
+            });
+            let support_list = PyList::empty_bound(py);
+            for support_qarg in support_iter {
+                support_list.append(support_qarg)?;
+            }
+            layer_dict.set_item("graph", new_layer.into_py(py))?;
+            layer_dict.set_item("partition", support_list)?;
+            layer_list.append(layer_dict)?;
+        }
+        Ok(layer_list.into_any().iter()?.into())
+    }
+
+    /// Yield a layer for all gates of this circuit.
+    ///
+    /// A serial layer is a circuit with one gate. The layers have the
+    /// same structure as in layers().
+    #[pyo3(signature = (*, vars_mode="captures"))]
+    fn serial_layers(&self, py: Python, vars_mode: &str) -> PyResult<Py<PyIterator>> {
+        let layer_list = PyList::empty_bound(py);
+        for next_node in self.topological_op_nodes()? {
+            let retrieved_node: &PackedInstruction = match self.dag.node_weight(next_node) {
+                Some(NodeType::Operation(node)) => node,
+                _ => unreachable!("A non-operation node was obtained from topological_op_nodes."),
+            };
+            let mut new_layer = self.copy_empty_like(py, vars_mode)?;
+
+            // Save the support of the operation we add to the layer
+            let support_list = PyList::empty_bound(py);
+            let qubits = PyTuple::new_bound(
+                py,
+                self.qargs_cache
+                    .intern(retrieved_node.qubits)
+                    .iter()
+                    .map(|qubit| self.qubits.get(*qubit)),
+            )
+            .unbind();
+            new_layer.push_back(py, retrieved_node.clone())?;
+
+            if !retrieved_node.op.directive() {
+                support_list.append(qubits)?;
+            }
+
+            let layer_dict = [
+                ("graph", new_layer.into_py(py)),
+                ("partition", support_list.into_any().unbind()),
+            ]
+            .into_py_dict_bound(py);
+            layer_list.append(layer_dict)?;
+        }
+
+        Ok(layer_list.into_any().iter()?.into())
+    }
+
+    /// Yield layers of the multigraph.
+    #[pyo3(name = "multigraph_layers")]
+    fn py_multigraph_layers(&self, py: Python) -> PyResult<Py<PyIterator>> {
+        let graph_layers = self.multigraph_layers(py).map(|layer| -> Vec<PyObject> {
+            layer
+                .into_iter()
+                .filter_map(|index| self.get_node(py, index).ok())
+                .collect()
+        });
+        let list: Bound<PyList> =
+            PyList::new_bound(py, graph_layers.collect::<Vec<Vec<PyObject>>>());
+        Ok(PyIterator::from_bound_object(&list)?.unbind())
+    }
+
+    /// Return a set of non-conditional runs of "op" nodes with the given names.
+    ///
+    /// For example, "... h q[0]; cx q[0],q[1]; cx q[0],q[1]; h q[1]; .."
+    /// would produce the tuple of cx nodes as an element of the set returned
+    /// from a call to collect_runs(["cx"]). If instead the cx nodes were
+    /// "cx q[0],q[1]; cx q[1],q[0];", the method would still return the
+    /// pair in a tuple. The namelist can contain names that are not
+    /// in the circuit's basis.
+    ///
+    /// Nodes must have only one successor to continue the run.
+    #[pyo3(name = "collect_runs")]
+    fn py_collect_runs(&self, py: Python, namelist: &Bound<PyList>) -> PyResult<Py<PySet>> {
+        let mut name_list_set = HashSet::with_capacity(namelist.len());
+        for name in namelist.iter() {
+            name_list_set.insert(name.extract::<String>()?);
+        }
+        match self.collect_runs(name_list_set) {
+            Some(runs) => {
+                let run_iter = runs.map(|node_indices| {
+                    PyTuple::new_bound(
+                        py,
+                        node_indices
+                            .into_iter()
+                            .map(|node_index| self.get_node(py, node_index).unwrap()),
+                    )
+                    .unbind()
+                });
+                let out_set = PySet::empty_bound(py)?;
+                for run_tuple in run_iter {
+                    out_set.add(run_tuple)?;
+                }
+                Ok(out_set.unbind())
+            }
+            None => Err(PyRuntimeError::new_err(
+                "Invalid DAGCircuit, cycle encountered",
+            )),
+        }
+    }
+
+    /// Return a set of non-conditional runs of 1q "op" nodes.
+    #[pyo3(name = "collect_1q_runs")]
+    fn py_collect_1q_runs(&self, py: Python) -> PyResult<Py<PyList>> {
+        match self.collect_1q_runs() {
+            Some(runs) => {
+                let runs_iter = runs.map(|node_indices| {
+                    PyList::new_bound(
+                        py,
+                        node_indices
+                            .into_iter()
+                            .map(|node_index| self.get_node(py, node_index).unwrap()),
+                    )
+                    .unbind()
+                });
+                let out_list = PyList::empty_bound(py);
+                for run_list in runs_iter {
+                    out_list.append(run_list)?;
+                }
+                Ok(out_list.unbind())
+            }
+            None => Err(PyRuntimeError::new_err(
+                "Invalid DAGCircuit, cycle encountered",
+            )),
+        }
+    }
+
+    /// Return a set of non-conditional runs of 2q "op" nodes.
+    #[pyo3(name = "collect_2q_runs")]
+    fn py_collect_2q_runs(&self, py: Python) -> PyResult<Py<PyList>> {
+        match self.collect_2q_runs() {
+            Some(runs) => {
+                let runs_iter = runs.into_iter().map(|node_indices| {
+                    PyList::new_bound(
+                        py,
+                        node_indices
+                            .into_iter()
+                            .map(|node_index| self.get_node(py, node_index).unwrap()),
+                    )
+                    .unbind()
+                });
+                let out_list = PyList::empty_bound(py);
+                for run_list in runs_iter {
+                    out_list.append(run_list)?;
+                }
+                Ok(out_list.unbind())
+            }
+            None => Err(PyRuntimeError::new_err(
+                "Invalid DAGCircuit, cycle encountered",
+            )),
+        }
+    }
+
+    /// Iterator for nodes that affect a given wire.
+    ///
+    /// Args:
+    ///     wire (Bit): the wire to be looked at.
+    ///     only_ops (bool): True if only the ops nodes are wanted;
+    ///                 otherwise, all nodes are returned.
+    /// Yield:
+    ///      Iterator: the successive nodes on the given wire
+    ///
+    /// Raises:
+    ///     DAGCircuitError: if the given wire doesn't exist in the DAG
+    #[pyo3(name = "nodes_on_wire", signature = (wire, only_ops=false))]
+    fn py_nodes_on_wire(
+        &self,
+        py: Python,
+        wire: &Bound<PyAny>,
+        only_ops: bool,
+    ) -> PyResult<Py<PyIterator>> {
+        let wire = if wire.is_instance(imports::QUBIT.get_bound(py))? {
+            self.qubits.find(wire).map(Wire::Qubit)
+        } else if wire.is_instance(imports::CLBIT.get_bound(py))? {
+            self.clbits.find(wire).map(Wire::Clbit)
+        } else if self.var_input_map.contains_key(py, &wire.clone().unbind()) {
+            Some(Wire::Var(wire.clone().unbind()))
+        } else {
+            None
+        }
+        .ok_or_else(|| {
+            DAGCircuitError::new_err(format!(
+                "The given wire {:?} is not present in the circuit",
+                wire
+            ))
+        })?;
+
+        let nodes = self
+            .nodes_on_wire(py, &wire, only_ops)
+            .into_iter()
+            .map(|n| self.get_node(py, n))
+            .collect::<PyResult<Vec<_>>>()?;
+        Ok(PyTuple::new_bound(py, nodes).into_any().iter()?.unbind())
+    }
+
+    /// Count the occurrences of operation names.
+    ///
+    /// Args:
+    ///     recurse: if ``True`` (default), then recurse into control-flow operations.  In all
+    ///         cases, this counts only the number of times the operation appears in any possible
+    ///         block; both branches of if-elses are counted, and for- and while-loop blocks are
+    ///         only counted once.
+    ///
+    /// Returns:
+    ///     Mapping[str, int]: a mapping of operation names to the number of times it appears.
+    #[pyo3(signature = (*, recurse=true))]
+    fn count_ops(&self, py: Python, recurse: bool) -> PyResult<PyObject> {
+        if !recurse
+            || !CONTROL_FLOW_OP_NAMES
+                .iter()
+                .any(|x| self.op_names.contains_key(*x))
+        {
+            Ok(self.op_names.to_object(py))
+        } else {
+            fn inner(
+                py: Python,
+                dag: &DAGCircuit,
+                counts: &mut HashMap<String, usize>,
+            ) -> PyResult<()> {
+                for (key, value) in dag.op_names.iter() {
+                    counts
+                        .entry(key.clone())
+                        .and_modify(|count| *count += value)
+                        .or_insert(*value);
+                }
+                let circuit_to_dag = imports::CIRCUIT_TO_DAG.get_bound(py);
+                for node in dag.py_op_nodes(
+                    py,
+                    Some(imports::CONTROL_FLOW_OP.get_bound(py).downcast()?),
+                    true,
+                )? {
+                    let raw_blocks = node.getattr(py, "op")?.getattr(py, "blocks")?;
+                    let blocks: &Bound<PyTuple> = raw_blocks.downcast_bound::<PyTuple>(py)?;
+                    for block in blocks.iter() {
+                        let inner_dag: &DAGCircuit =
+                            &circuit_to_dag.call1((block.clone(),))?.extract()?;
+                        inner(py, inner_dag, counts)?;
+                    }
+                }
+                Ok(())
+            }
+            let mut counts = HashMap::with_capacity(self.op_names.len());
+            inner(py, self, &mut counts)?;
+            Ok(counts.to_object(py))
+        }
+    }
+
+    /// Count the occurrences of operation names on the longest path.
+    ///
+    /// Returns a dictionary of counts keyed on the operation name.
+    fn count_ops_longest_path(&self) -> PyResult<HashMap<&str, usize>> {
+        if self.dag.node_count() == 0 {
+            return Ok(HashMap::new());
+        }
+        let weight_fn = |_| -> Result<usize, Infallible> { Ok(1) };
+        let longest_path =
+            match rustworkx_core::dag_algo::longest_path(&self.dag, weight_fn).unwrap() {
+                Some(res) => res.0,
+                None => return Err(DAGCircuitError::new_err("not a DAG")),
+            };
+        // Allocate for worst case where all operations are unique
+        let mut op_counts: HashMap<&str, usize> = HashMap::with_capacity(longest_path.len() - 2);
+        for node_index in &longest_path[1..longest_path.len() - 1] {
+            if let NodeType::Operation(ref packed) = self.dag[*node_index] {
+                let name = packed.op.name();
+                op_counts
+                    .entry(name)
+                    .and_modify(|count| *count += 1)
+                    .or_insert(1);
+            }
+        }
+        Ok(op_counts)
+    }
+
+    /// Returns causal cone of a qubit.
+    ///
+    /// A qubit's causal cone is the set of qubits that can influence the output of that
+    /// qubit through interactions, whether through multi-qubit gates or operations. Knowing
+    /// the causal cone of a qubit can be useful when debugging faulty circuits, as it can
+    /// help identify which wire(s) may be causing the problem.
+    ///
+    /// This method does not consider any classical data dependency in the ``DAGCircuit``,
+    /// classical bit wires are ignored for the purposes of building the causal cone.
+    ///
+    /// Args:
+    ///     qubit (~qiskit.circuit.Qubit): The output qubit for which we want to find the causal cone.
+    ///
+    /// Returns:
+    ///     Set[~qiskit.circuit.Qubit]: The set of qubits whose interactions affect ``qubit``.
+    fn quantum_causal_cone(&self, py: Python, qubit: &Bound<PyAny>) -> PyResult<Py<PySet>> {
+        // Retrieve the output node from the qubit
+        let output_qubit = self.qubits.find(qubit).ok_or_else(|| {
+            DAGCircuitError::new_err(format!(
+                "The given qubit {:?} is not present in the circuit",
+                qubit
+            ))
+        })?;
+        let output_node_index = self
+            .qubit_io_map
+            .get(output_qubit.0 as usize)
+            .map(|x| x[1])
+            .ok_or_else(|| {
+                DAGCircuitError::new_err(format!(
+                    "The given qubit {:?} is not present in qubit_output_map",
+                    qubit
+                ))
+            })?;
+
+        let mut qubits_in_cone: HashSet<&Qubit> = HashSet::from([&output_qubit]);
+        let mut queue: VecDeque<NodeIndex> = self.quantum_predecessors(output_node_index).collect();
+
+        // The processed_non_directive_nodes stores the set of processed non-directive nodes.
+        // This is an optimization to avoid considering the same non-directive node multiple
+        // times when reached from different paths.
+        // The directive nodes (such as barriers or measures) are trickier since when processing
+        // them we only add their predecessors that intersect qubits_in_cone. Hence, directive
+        // nodes have to be considered multiple times.
+        let mut processed_non_directive_nodes: HashSet<NodeIndex> = HashSet::new();
+
+        while !queue.is_empty() {
+            let cur_index = queue.pop_front().unwrap();
+
+            if let NodeType::Operation(packed) = self.dag.node_weight(cur_index).unwrap() {
+                if !packed.op.directive() {
+                    // If the operation is not a directive (in particular not a barrier nor a measure),
+                    // we do not do anything if it was already processed. Otherwise, we add its qubits
+                    // to qubits_in_cone, and append its predecessors to queue.
+                    if processed_non_directive_nodes.contains(&cur_index) {
+                        continue;
+                    }
+                    qubits_in_cone.extend(self.qargs_cache.intern(packed.qubits).iter());
+                    processed_non_directive_nodes.insert(cur_index);
+
+                    for pred_index in self.quantum_predecessors(cur_index) {
+                        if let NodeType::Operation(_pred_packed) =
+                            self.dag.node_weight(pred_index).unwrap()
+                        {
+                            queue.push_back(pred_index);
+                        }
+                    }
+                } else {
+                    // Directives (such as barriers and measures) may be defined over all the qubits,
+                    // yet not all of these qubits should be considered in the causal cone. So we
+                    // only add those predecessors that have qubits in common with qubits_in_cone.
+                    for pred_index in self.quantum_predecessors(cur_index) {
+                        if let NodeType::Operation(pred_packed) =
+                            self.dag.node_weight(pred_index).unwrap()
+                        {
+                            if self
+                                .qargs_cache
+                                .intern(pred_packed.qubits)
+                                .iter()
+                                .any(|x| qubits_in_cone.contains(x))
+                            {
+                                queue.push_back(pred_index);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        let qubits_in_cone_vec: Vec<_> = qubits_in_cone.iter().map(|&&qubit| qubit).collect();
+        let elements = self.qubits.map_indices(&qubits_in_cone_vec[..]);
+        Ok(PySet::new_bound(py, elements)?.unbind())
+    }
+
+    /// Return a dictionary of circuit properties.
+    fn properties(&self, py: Python) -> PyResult<HashMap<&str, PyObject>> {
+        Ok(HashMap::from_iter([
+            ("size", self.size(py, false)?.into_py(py)),
+            ("depth", self.depth(py, false)?.into_py(py)),
+            ("width", self.width().into_py(py)),
+            ("qubits", self.num_qubits().into_py(py)),
+            ("bits", self.num_clbits().into_py(py)),
+            ("factors", self.num_tensor_factors().into_py(py)),
+            ("operations", self.count_ops(py, true)?),
+        ]))
+    }
+
+    /// Draws the dag circuit.
+    ///
+    /// This function needs `Graphviz <https://www.graphviz.org/>`_ to be
+    /// installed. Graphviz is not a python package and can't be pip installed
+    /// (the ``graphviz`` package on PyPI is a Python interface library for
+    /// Graphviz and does not actually install Graphviz). You can refer to
+    /// `the Graphviz documentation <https://www.graphviz.org/download/>`__ on
+    /// how to install it.
+    ///
+    /// Args:
+    ///     scale (float): scaling factor
+    ///     filename (str): file path to save image to (format inferred from name)
+    ///     style (str):
+    ///         'plain': B&W graph;
+    ///         'color' (default): color input/output/op nodes
+    ///
+    /// Returns:
+    ///     Ipython.display.Image: if in Jupyter notebook and not saving to file,
+    ///     otherwise None.
+    #[pyo3(signature=(scale=0.7, filename=None, style="color"))]
+    fn draw<'py>(
+        slf: PyRef<'py, Self>,
+        py: Python<'py>,
+        scale: f64,
+        filename: Option<&str>,
+        style: &str,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        let module = PyModule::import_bound(py, "qiskit.visualization.dag_visualization")?;
+        module.call_method1("dag_drawer", (slf, scale, filename, style))
+    }
+
+    fn _to_dot<'py>(
+        &self,
+        py: Python<'py>,
+        graph_attrs: Option<BTreeMap<String, String>>,
+        node_attrs: Option<PyObject>,
+        edge_attrs: Option<PyObject>,
+    ) -> PyResult<Bound<'py, PyString>> {
+        let mut buffer = Vec::<u8>::new();
+        build_dot(py, self, &mut buffer, graph_attrs, node_attrs, edge_attrs)?;
+        Ok(PyString::new_bound(py, std::str::from_utf8(&buffer)?))
+    }
+
+    /// Add an input variable to the circuit.
+    ///
+    /// Args:
+    ///     var: the variable to add.
+    fn add_input_var(&mut self, py: Python, var: &Bound<PyAny>) -> PyResult<()> {
+        if !self.vars_by_type[DAGVarType::Capture as usize]
+            .bind(py)
+            .is_empty()
+        {
+            return Err(DAGCircuitError::new_err(
+                "cannot add inputs to a circuit with captures",
+            ));
+        }
+        self.add_var(py, var, DAGVarType::Input)
+    }
+
+    /// Add a captured variable to the circuit.
+    ///
+    /// Args:
+    ///     var: the variable to add.
+    fn add_captured_var(&mut self, py: Python, var: &Bound<PyAny>) -> PyResult<()> {
+        if !self.vars_by_type[DAGVarType::Input as usize]
+            .bind(py)
+            .is_empty()
+        {
+            return Err(DAGCircuitError::new_err(
+                "cannot add captures to a circuit with inputs",
+            ));
+        }
+        self.add_var(py, var, DAGVarType::Capture)
+    }
+
+    /// Add a declared local variable to the circuit.
+    ///
+    /// Args:
+    ///     var: the variable to add.
+    fn add_declared_var(&mut self, py: Python, var: &Bound<PyAny>) -> PyResult<()> {
+        self.add_var(py, var, DAGVarType::Declare)
+    }
+
+    /// Total number of classical variables tracked by the circuit.
+    #[getter]
+    fn num_vars(&self) -> usize {
+        self.vars_info.len()
+    }
+
+    /// Number of input classical variables tracked by the circuit.
+    #[getter]
+    fn num_input_vars(&self, py: Python) -> usize {
+        self.vars_by_type[DAGVarType::Input as usize].bind(py).len()
+    }
+
+    /// Number of captured classical variables tracked by the circuit.
+    #[getter]
+    fn num_captured_vars(&self, py: Python) -> usize {
+        self.vars_by_type[DAGVarType::Capture as usize]
+            .bind(py)
+            .len()
+    }
+
+    /// Number of declared local classical variables tracked by the circuit.
+    #[getter]
+    fn num_declared_vars(&self, py: Python) -> usize {
+        self.vars_by_type[DAGVarType::Declare as usize]
+            .bind(py)
+            .len()
+    }
+
+    /// Is this realtime variable in the DAG?
+    ///
+    /// Args:
+    ///     var: the variable or name to check.
+    fn has_var(&self, var: &Bound<PyAny>) -> PyResult<bool> {
+        match var.extract::<String>() {
+            Ok(name) => Ok(self.vars_info.contains_key(&name)),
+            Err(_) => {
+                let raw_name = var.getattr("name")?;
+                let var_name: String = raw_name.extract()?;
+                match self.vars_info.get(&var_name) {
+                    Some(var_in_dag) => Ok(var_in_dag.var.is(var)),
+                    None => Ok(false),
+                }
+            }
+        }
+    }
+
+    /// Iterable over the input classical variables tracked by the circuit.
+    fn iter_input_vars(&self, py: Python) -> PyResult<Py<PyIterator>> {
+        Ok(self.vars_by_type[DAGVarType::Input as usize]
+            .bind(py)
+            .clone()
+            .into_any()
+            .iter()?
+            .unbind())
+    }
+
+    /// Iterable over the captured classical variables tracked by the circuit.
+    fn iter_captured_vars(&self, py: Python) -> PyResult<Py<PyIterator>> {
+        Ok(self.vars_by_type[DAGVarType::Capture as usize]
+            .bind(py)
+            .clone()
+            .into_any()
+            .iter()?
+            .unbind())
+    }
+
+    /// Iterable over the declared classical variables tracked by the circuit.
+    fn iter_declared_vars(&self, py: Python) -> PyResult<Py<PyIterator>> {
+        Ok(self.vars_by_type[DAGVarType::Declare as usize]
+            .bind(py)
+            .clone()
+            .into_any()
+            .iter()?
+            .unbind())
+    }
+
+    /// Iterable over all the classical variables tracked by the circuit.
+    fn iter_vars(&self, py: Python) -> PyResult<Py<PyIterator>> {
+        let out_set = PySet::empty_bound(py)?;
+        for var_type_set in &self.vars_by_type {
+            for var in var_type_set.bind(py).iter() {
+                out_set.add(var)?;
+            }
+        }
+        Ok(out_set.into_any().iter()?.unbind())
+    }
+
+    fn _has_edge(&self, source: usize, target: usize) -> bool {
+        self.dag
+            .contains_edge(NodeIndex::new(source), NodeIndex::new(target))
+    }
+
+    fn _is_dag(&self) -> bool {
+        rustworkx_core::petgraph::algo::toposort(&self.dag, None).is_ok()
+    }
+
+    fn _in_edges(&self, py: Python, node_index: usize) -> Vec<Py<PyTuple>> {
+        self.dag
+            .edges_directed(NodeIndex::new(node_index), Incoming)
+            .map(|wire| {
+                (
+                    wire.source().index(),
+                    wire.target().index(),
+                    match wire.weight() {
+                        Wire::Qubit(qubit) => self.qubits.get(*qubit).unwrap(),
+                        Wire::Clbit(clbit) => self.clbits.get(*clbit).unwrap(),
+                        Wire::Var(var) => var,
+                    },
+                )
+                    .into_py(py)
+            })
+            .collect()
+    }
+
+    fn _out_edges(&self, py: Python, node_index: usize) -> Vec<Py<PyTuple>> {
+        self.dag
+            .edges_directed(NodeIndex::new(node_index), Outgoing)
+            .map(|wire| {
+                (
+                    wire.source().index(),
+                    wire.target().index(),
+                    match wire.weight() {
+                        Wire::Qubit(qubit) => self.qubits.get(*qubit).unwrap(),
+                        Wire::Clbit(clbit) => self.clbits.get(*clbit).unwrap(),
+                        Wire::Var(var) => var,
+                    },
+                )
+                    .into_py(py)
+            })
+            .collect()
+    }
+
+    fn _in_wires(&self, node_index: usize) -> Vec<&PyObject> {
+        self.dag
+            .edges_directed(NodeIndex::new(node_index), Incoming)
+            .map(|wire| match wire.weight() {
+                Wire::Qubit(qubit) => self.qubits.get(*qubit).unwrap(),
+                Wire::Clbit(clbit) => self.clbits.get(*clbit).unwrap(),
+                Wire::Var(var) => var,
+            })
+            .collect()
+    }
+
+    fn _out_wires(&self, node_index: usize) -> Vec<&PyObject> {
+        self.dag
+            .edges_directed(NodeIndex::new(node_index), Outgoing)
+            .map(|wire| match wire.weight() {
+                Wire::Qubit(qubit) => self.qubits.get(*qubit).unwrap(),
+                Wire::Clbit(clbit) => self.clbits.get(*clbit).unwrap(),
+                Wire::Var(var) => var,
+            })
+            .collect()
+    }
+
+    fn _find_successors_by_edge(
+        &self,
+        py: Python,
+        node_index: usize,
+        edge_checker: &Bound<PyAny>,
+    ) -> PyResult<Vec<PyObject>> {
+        let mut result = Vec::new();
+        for e in self
+            .dag
+            .edges_directed(NodeIndex::new(node_index), Outgoing)
+            .unique_by(|e| e.id())
+        {
+            let weight = match e.weight() {
+                Wire::Qubit(q) => self.qubits.get(*q).unwrap(),
+                Wire::Clbit(c) => self.clbits.get(*c).unwrap(),
+                Wire::Var(v) => v,
+            };
+            if edge_checker.call1((weight,))?.extract::<bool>()? {
+                result.push(self.get_node(py, e.target())?);
+            }
+        }
+        Ok(result)
+    }
+
+    fn _insert_1q_on_incoming_qubit(
+        &mut self,
+        py: Python,
+        node: &Bound<PyAny>,
+        old_index: usize,
+    ) -> PyResult<()> {
+        if let NodeType::Operation(inst) = self.pack_into(py, node)? {
+            self.increment_op(inst.op.name());
+            let new_index = self.dag.add_node(NodeType::Operation(inst));
+            let old_index: NodeIndex = NodeIndex::new(old_index);
+            let (parent_index, edge_index, weight) = self
+                .dag
+                .edges_directed(old_index, Incoming)
+                .map(|edge| (edge.source(), edge.id(), edge.weight().clone()))
+                .next()
+                .unwrap();
+            self.dag.add_edge(parent_index, new_index, weight.clone());
+            self.dag.add_edge(new_index, old_index, weight);
+            self.dag.remove_edge(edge_index);
+            Ok(())
+        } else {
+            Err(PyTypeError::new_err("Invalid node type input"))
+        }
+    }
+
+    fn _edges(&self, py: Python) -> Vec<PyObject> {
+        self.dag
+            .edge_indices()
+            .map(|index| {
+                let wire = self.dag.edge_weight(index).unwrap();
+                match wire {
+                    Wire::Qubit(qubit) => self.qubits.get(*qubit).to_object(py),
+                    Wire::Clbit(clbit) => self.clbits.get(*clbit).to_object(py),
+                    Wire::Var(var) => var.clone_ref(py),
+                }
+            })
+            .collect()
+    }
+}
+
+impl DAGCircuit {
+    /// Return an iterator of gate runs with non-conditional op nodes of given names
+    pub fn collect_runs(
+        &self,
+        namelist: HashSet<String>,
+    ) -> Option<impl Iterator<Item = Vec<NodeIndex>> + '_> {
+        let filter_fn = move |node_index: NodeIndex| -> Result<bool, Infallible> {
+            let node = &self.dag[node_index];
+            match node {
+                NodeType::Operation(inst) => Ok(namelist.contains(inst.op.name())
+                    && match &inst.extra_attrs {
+                        None => true,
+                        Some(attrs) => attrs.condition.is_none(),
+                    }),
+                _ => Ok(false),
+            }
+        };
+        rustworkx_core::dag_algo::collect_runs(&self.dag, filter_fn)
+            .map(|node_iter| node_iter.map(|x| x.unwrap()))
+    }
+
+    /// Return a set of non-conditional runs of 1q "op" nodes.
+    pub fn collect_1q_runs(&self) -> Option<impl Iterator<Item = Vec<NodeIndex>> + '_> {
+        let filter_fn = move |node_index: NodeIndex| -> Result<bool, Infallible> {
+            let node = &self.dag[node_index];
+            match node {
+                NodeType::Operation(inst) => Ok(inst.op.num_qubits() == 1
+                    && inst.op.num_clbits() == 0
+                    && !inst.is_parameterized()
+                    && (inst.op.try_standard_gate().is_some()
+                        || inst.op.matrix(inst.params_view()).is_some())
+                    && inst.condition().is_none()),
+                _ => Ok(false),
+            }
+        };
+        rustworkx_core::dag_algo::collect_runs(&self.dag, filter_fn)
+            .map(|node_iter| node_iter.map(|x| x.unwrap()))
+    }
+
+    /// Return a set of non-conditional runs of 2q "op" nodes.
+    pub fn collect_2q_runs(&self) -> Option<Vec<Vec<NodeIndex>>> {
+        let filter_fn = move |node_index: NodeIndex| -> Result<Option<bool>, Infallible> {
+            let node = &self.dag[node_index];
+            match node {
+                NodeType::Operation(inst) => match inst.op.view() {
+                    OperationRef::Standard(gate) => Ok(Some(
+                        gate.num_qubits() <= 2
+                            && inst.condition().is_none()
+                            && !inst.is_parameterized(),
+                    )),
+                    OperationRef::Gate(gate) => Ok(Some(
+                        gate.num_qubits() <= 2
+                            && inst.condition().is_none()
+                            && !inst.is_parameterized(),
+                    )),
+                    _ => Ok(Some(false)),
+                },
+                _ => Ok(None),
+            }
+        };
+
+        let color_fn = move |edge_index: EdgeIndex| -> Result<Option<usize>, Infallible> {
+            let wire = self.dag.edge_weight(edge_index).unwrap();
+            match wire {
+                Wire::Qubit(index) => Ok(Some(index.0 as usize)),
+                _ => Ok(None),
+            }
+        };
+        rustworkx_core::dag_algo::collect_bicolor_runs(&self.dag, filter_fn, color_fn).unwrap()
+    }
+
+    fn increment_op(&mut self, op: &str) {
+        match self.op_names.get_mut(op) {
+            Some(count) => {
+                *count += 1;
+            }
+            None => {
+                self.op_names.insert(op.to_string(), 1);
+            }
+        }
+    }
+
+    fn decrement_op(&mut self, op: &str) {
+        match self.op_names.get_mut(op) {
+            Some(count) => {
+                if *count > 1 {
+                    *count -= 1;
+                } else {
+                    self.op_names.swap_remove(op);
+                }
+            }
+            None => panic!("Cannot decrement something not added!"),
+        }
+    }
+
+    fn quantum_predecessors(&self, node: NodeIndex) -> impl Iterator<Item = NodeIndex> + '_ {
+        self.dag
+            .edges_directed(node, Incoming)
+            .filter_map(|e| match e.weight() {
+                Wire::Qubit(_) => Some(e.source()),
+                _ => None,
+            })
+            .unique()
+    }
+
+    fn quantum_successors(&self, node: NodeIndex) -> impl Iterator<Item = NodeIndex> + '_ {
+        self.dag
+            .edges_directed(node, Outgoing)
+            .filter_map(|e| match e.weight() {
+                Wire::Qubit(_) => Some(e.target()),
+                _ => None,
+            })
+            .unique()
+    }
+
+    /// Apply a [PackedInstruction] to the back of the circuit.
+    ///
+    /// The provided `instr` MUST be valid for this DAG, e.g. its
+    /// bits, registers, vars, and interner IDs must be valid in
+    /// this DAG.
+    ///
+    /// This is mostly used to apply operations from one DAG to
+    /// another that was created from the first via
+    /// [DAGCircuit::copy_empty_like].
+    fn push_back(&mut self, py: Python, instr: PackedInstruction) -> PyResult<NodeIndex> {
+        let op_name = instr.op.name();
+        let (all_cbits, vars): (Vec<Clbit>, Option<Vec<PyObject>>) = {
+            if self.may_have_additional_wires(py, &instr) {
+                let mut clbits: HashSet<Clbit> =
+                    HashSet::from_iter(self.cargs_cache.intern(instr.clbits).iter().copied());
+                let (additional_clbits, additional_vars) =
+                    self.additional_wires(py, instr.op.view(), instr.condition())?;
+                for clbit in additional_clbits {
+                    clbits.insert(clbit);
+                }
+                (clbits.into_iter().collect(), Some(additional_vars))
+            } else {
+                (self.cargs_cache.intern(instr.clbits).to_vec(), None)
+            }
+        };
+
+        self.increment_op(op_name);
+
+        let qubits_id = instr.qubits;
+        let new_node = self.dag.add_node(NodeType::Operation(instr));
+
+        // Put the new node in-between the previously "last" nodes on each wire
+        // and the output map.
+        let output_nodes: HashSet<NodeIndex> = self
+            .qargs_cache
+            .intern(qubits_id)
+            .iter()
+            .map(|q| self.qubit_io_map.get(q.0 as usize).map(|x| x[1]).unwrap())
+            .chain(
+                all_cbits
+                    .iter()
+                    .map(|c| self.clbit_io_map.get(c.0 as usize).map(|x| x[1]).unwrap()),
+            )
+            .chain(
+                vars.iter()
+                    .flatten()
+                    .map(|v| self.var_output_map.get(py, v).unwrap()),
+            )
+            .collect();
+
+        for output_node in output_nodes {
+            let last_edges: Vec<_> = self
+                .dag
+                .edges_directed(output_node, Incoming)
+                .map(|e| (e.source(), e.id(), e.weight().clone()))
+                .collect();
+            for (source, old_edge, weight) in last_edges.into_iter() {
+                self.dag.add_edge(source, new_node, weight.clone());
+                self.dag.add_edge(new_node, output_node, weight);
+                self.dag.remove_edge(old_edge);
+            }
+        }
+
+        Ok(new_node)
+    }
+
+    /// Apply a [PackedInstruction] to the front of the circuit.
+    ///
+    /// The provided `instr` MUST be valid for this DAG, e.g. its
+    /// bits, registers, vars, and interner IDs must be valid in
+    /// this DAG.
+    ///
+    /// This is mostly used to apply operations from one DAG to
+    /// another that was created from the first via
+    /// [DAGCircuit::copy_empty_like].
+    fn push_front(&mut self, py: Python, inst: PackedInstruction) -> PyResult<NodeIndex> {
+        let op_name = inst.op.name();
+        let (all_cbits, vars): (Vec<Clbit>, Option<Vec<PyObject>>) = {
+            if self.may_have_additional_wires(py, &inst) {
+                let mut clbits: HashSet<Clbit> =
+                    HashSet::from_iter(self.cargs_cache.intern(inst.clbits).iter().cloned());
+                let (additional_clbits, additional_vars) =
+                    self.additional_wires(py, inst.op.view(), inst.condition())?;
+                for clbit in additional_clbits {
+                    clbits.insert(clbit);
+                }
+                (clbits.into_iter().collect(), Some(additional_vars))
+            } else {
+                (self.cargs_cache.intern(inst.clbits).to_vec(), None)
+            }
+        };
+
+        self.increment_op(op_name);
+
+        let qubits_id = inst.qubits;
+        let new_node = self.dag.add_node(NodeType::Operation(inst));
+
+        // Put the new node in-between the input map and the previously
+        // "first" nodes on each wire.
+        let mut input_nodes: Vec<NodeIndex> = self
+            .qargs_cache
+            .intern(qubits_id)
+            .iter()
+            .map(|q| self.qubit_io_map[q.0 as usize][0])
+            .chain(all_cbits.iter().map(|c| self.clbit_io_map[c.0 as usize][0]))
+            .collect();
+        if let Some(vars) = vars {
+            for var in vars {
+                input_nodes.push(self.var_input_map.get(py, &var).unwrap());
+            }
+        }
+
+        for input_node in input_nodes {
+            let first_edges: Vec<_> = self
+                .dag
+                .edges_directed(input_node, Outgoing)
+                .map(|e| (e.target(), e.id(), e.weight().clone()))
+                .collect();
+            for (target, old_edge, weight) in first_edges.into_iter() {
+                self.dag.add_edge(input_node, new_node, weight.clone());
+                self.dag.add_edge(new_node, target, weight);
+                self.dag.remove_edge(old_edge);
+            }
+        }
+
+        Ok(new_node)
+    }
+
+    fn sort_key(&self, node: NodeIndex) -> SortKeyType {
+        match &self.dag[node] {
+            NodeType::Operation(packed) => (
+                self.qargs_cache.intern(packed.qubits).as_slice(),
+                self.cargs_cache.intern(packed.clbits).as_slice(),
+            ),
+            NodeType::QubitIn(q) => (std::slice::from_ref(q), &[Clbit(u32::MAX)]),
+            NodeType::QubitOut(_q) => (&[Qubit(u32::MAX)], &[Clbit(u32::MAX)]),
+            NodeType::ClbitIn(c) => (&[Qubit(u32::MAX)], std::slice::from_ref(c)),
+            NodeType::ClbitOut(_c) => (&[Qubit(u32::MAX)], &[Clbit(u32::MAX)]),
+            _ => (&[], &[]),
+        }
+    }
+
+    fn topological_nodes(&self) -> PyResult<impl Iterator<Item = NodeIndex>> {
+        let key = |node: NodeIndex| -> Result<SortKeyType, Infallible> { Ok(self.sort_key(node)) };
+        let nodes =
+            rustworkx_core::dag_algo::lexicographical_topological_sort(&self.dag, key, false, None)
+                .map_err(|e| match e {
+                    rustworkx_core::dag_algo::TopologicalSortError::CycleOrBadInitialState => {
+                        PyValueError::new_err(format!("{}", e))
+                    }
+                    rustworkx_core::dag_algo::TopologicalSortError::KeyError(_) => {
+                        unreachable!()
+                    }
+                })?;
+        Ok(nodes.into_iter())
+    }
+
+    fn topological_op_nodes(&self) -> PyResult<impl Iterator<Item = NodeIndex> + '_> {
+        Ok(self.topological_nodes()?.filter(|node: &NodeIndex| {
+            matches!(self.dag.node_weight(*node), Some(NodeType::Operation(_)))
+        }))
+    }
+
+    fn topological_key_sort(
+        &self,
+        py: Python,
+        key: &Bound<PyAny>,
+    ) -> PyResult<impl Iterator<Item = NodeIndex>> {
+        // This path (user provided key func) is not ideal, since we no longer
+        // use a string key after moving to Rust, in favor of using a tuple
+        // of the qargs and cargs interner IDs of the node.
+        let key = |node: NodeIndex| -> PyResult<String> {
+            let node = self.get_node(py, node)?;
+            key.call1((node,))?.extract()
+        };
+        Ok(
+            rustworkx_core::dag_algo::lexicographical_topological_sort(&self.dag, key, false, None)
+                .map_err(|e| match e {
+                    rustworkx_core::dag_algo::TopologicalSortError::CycleOrBadInitialState => {
+                        PyValueError::new_err(format!("{}", e))
+                    }
+                    rustworkx_core::dag_algo::TopologicalSortError::KeyError(ref e) => {
+                        e.clone_ref(py)
+                    }
+                })?
+                .into_iter(),
+        )
+    }
+
+    fn is_wire_idle(&self, py: Python, wire: &Wire) -> PyResult<bool> {
+        let (input_node, output_node) = match wire {
+            Wire::Qubit(qubit) => (
+                self.qubit_io_map[qubit.0 as usize][0],
+                self.qubit_io_map[qubit.0 as usize][1],
+            ),
+            Wire::Clbit(clbit) => (
+                self.clbit_io_map[clbit.0 as usize][0],
+                self.clbit_io_map[clbit.0 as usize][1],
+            ),
+            Wire::Var(var) => (
+                self.var_input_map.get(py, var).unwrap(),
+                self.var_output_map.get(py, var).unwrap(),
+            ),
+        };
+
+        let child = self
+            .dag
+            .neighbors_directed(input_node, Outgoing)
+            .next()
+            .ok_or_else(|| {
+                DAGCircuitError::new_err(format!(
+                    "Invalid dagcircuit input node {:?} has no output",
+                    input_node
+                ))
+            })?;
+
+        Ok(child == output_node)
+    }
+
+    fn may_have_additional_wires(&self, py: Python, instr: &PackedInstruction) -> bool {
+        if instr.condition().is_some() {
+            return true;
+        }
+        let OperationRef::Instruction(inst) = instr.op.view() else {
+            return false;
+        };
+        inst.control_flow()
+            || inst
+                .instruction
+                .bind(py)
+                .is_instance(imports::STORE_OP.get_bound(py))
+                .unwrap()
+    }
+
+    fn additional_wires(
+        &self,
+        py: Python,
+        op: OperationRef,
+        condition: Option<&PyObject>,
+    ) -> PyResult<(Vec<Clbit>, Vec<PyObject>)> {
+        let wires_from_expr = |node: &Bound<PyAny>| -> PyResult<(Vec<Clbit>, Vec<PyObject>)> {
+            let mut clbits = Vec::new();
+            let mut vars = Vec::new();
+            for var in imports::ITER_VARS.get_bound(py).call1((node,))?.iter()? {
+                let var = var?;
+                let var_var = var.getattr("var")?;
+                if var_var.is_instance(imports::CLBIT.get_bound(py))? {
+                    clbits.push(self.clbits.find(&var_var).unwrap());
+                } else if var_var.is_instance(imports::CLASSICAL_REGISTER.get_bound(py))? {
+                    for bit in var_var.iter().unwrap() {
+                        clbits.push(self.clbits.find(&bit?).unwrap());
+                    }
+                } else {
+                    vars.push(var.unbind());
+                }
+            }
+            Ok((clbits, vars))
+        };
+
+        let mut clbits = Vec::new();
+        let mut vars = Vec::new();
+        if let Some(condition) = condition {
+            let condition = condition.bind(py);
+            if !condition.is_none() {
+                if condition.is_instance(imports::EXPR.get_bound(py)).unwrap() {
+                    let (expr_clbits, expr_vars) = wires_from_expr(condition)?;
+                    for bit in expr_clbits {
+                        clbits.push(bit);
+                    }
+                    for var in expr_vars {
+                        vars.push(var);
+                    }
+                } else {
+                    for bit in self
+                        .control_flow_module
+                        .condition_resources(condition)?
+                        .clbits
+                        .bind(py)
+                    {
+                        clbits.push(self.clbits.find(&bit).unwrap());
+                    }
+                }
+            }
+        }
+
+        if let OperationRef::Instruction(inst) = op {
+            let op = inst.instruction.bind(py);
+            if inst.control_flow() {
+                for var in op.call_method0("iter_captured_vars")?.iter()? {
+                    vars.push(var?.unbind())
+                }
+                if op.is_instance(imports::SWITCH_CASE_OP.get_bound(py))? {
+                    let target = op.getattr(intern!(py, "target"))?;
+                    if target.is_instance(imports::CLBIT.get_bound(py))? {
+                        clbits.push(self.clbits.find(&target).unwrap());
+                    } else if target.is_instance(imports::CLASSICAL_REGISTER.get_bound(py))? {
+                        for bit in target.iter()? {
+                            clbits.push(self.clbits.find(&bit?).unwrap());
+                        }
+                    } else {
+                        let (expr_clbits, expr_vars) = wires_from_expr(&target)?;
+                        for bit in expr_clbits {
+                            clbits.push(bit);
+                        }
+                        for var in expr_vars {
+                            vars.push(var);
+                        }
+                    }
+                }
+            } else if op.is_instance(imports::STORE_OP.get_bound(py))? {
+                let (expr_clbits, expr_vars) = wires_from_expr(&op.getattr("lvalue")?)?;
+                for bit in expr_clbits {
+                    clbits.push(bit);
+                }
+                for var in expr_vars {
+                    vars.push(var);
+                }
+                let (expr_clbits, expr_vars) = wires_from_expr(&op.getattr("rvalue")?)?;
+                for bit in expr_clbits {
+                    clbits.push(bit);
+                }
+                for var in expr_vars {
+                    vars.push(var);
+                }
+            }
+        }
+        Ok((clbits, vars))
+    }
+
+    /// Add a qubit or bit to the circuit.
+    ///
+    /// Args:
+    ///     wire: the wire to be added
+    ///
+    ///     This adds a pair of in and out nodes connected by an edge.
+    ///
+    /// Raises:
+    ///     DAGCircuitError: if trying to add duplicate wire
+    fn add_wire(&mut self, py: Python, wire: Wire) -> PyResult<()> {
+        let (in_node, out_node) = match wire {
+            Wire::Qubit(qubit) => {
+                if (qubit.0 as usize) >= self.qubit_io_map.len() {
+                    let input_node = self.dag.add_node(NodeType::QubitIn(qubit));
+                    let output_node = self.dag.add_node(NodeType::QubitOut(qubit));
+                    self.qubit_io_map.push([input_node, output_node]);
+                    Ok((input_node, output_node))
+                } else {
+                    Err(DAGCircuitError::new_err("qubit wire already exists!"))
+                }
+            }
+            Wire::Clbit(clbit) => {
+                if (clbit.0 as usize) >= self.clbit_io_map.len() {
+                    let input_node = self.dag.add_node(NodeType::ClbitIn(clbit));
+                    let output_node = self.dag.add_node(NodeType::ClbitOut(clbit));
+                    self.clbit_io_map.push([input_node, output_node]);
+                    Ok((input_node, output_node))
+                } else {
+                    Err(DAGCircuitError::new_err("classical wire already exists!"))
+                }
+            }
+            Wire::Var(ref var) => {
+                if self.var_input_map.contains_key(py, var)
+                    || self.var_output_map.contains_key(py, var)
+                {
+                    return Err(DAGCircuitError::new_err("var wire already exists!"));
+                }
+                let in_node = self.dag.add_node(NodeType::VarIn(var.clone_ref(py)));
+                let out_node = self.dag.add_node(NodeType::VarOut(var.clone_ref(py)));
+                self.var_input_map.insert(py, var.clone_ref(py), in_node);
+                self.var_output_map.insert(py, var.clone_ref(py), out_node);
+                Ok((in_node, out_node))
+            }
+        }?;
+
+        self.dag.add_edge(in_node, out_node, wire);
+        Ok(())
+    }
+
+    /// Get the nodes on the given wire.
+    ///
+    /// Note: result is empty if the wire is not in the DAG.
+    fn nodes_on_wire(&self, py: Python, wire: &Wire, only_ops: bool) -> Vec<NodeIndex> {
+        let mut nodes = Vec::new();
+        let mut current_node = match wire {
+            Wire::Qubit(qubit) => self.qubit_io_map.get(qubit.0 as usize).map(|x| x[0]),
+            Wire::Clbit(clbit) => self.clbit_io_map.get(clbit.0 as usize).map(|x| x[0]),
+            Wire::Var(var) => self.var_input_map.get(py, var),
+        };
+
+        while let Some(node) = current_node {
+            if only_ops {
+                let node_weight = self.dag.node_weight(node).unwrap();
+                if let NodeType::Operation(_) = node_weight {
+                    nodes.push(node);
+                }
+            } else {
+                nodes.push(node);
+            }
+
+            let edges = self.dag.edges_directed(node, Outgoing);
+            current_node = edges.into_iter().find_map(|edge| {
+                if edge.weight() == wire {
+                    Some(edge.target())
+                } else {
+                    None
+                }
+            });
+        }
+        nodes
+    }
+
+    fn remove_idle_wire(&mut self, py: Python, wire: Wire) -> PyResult<()> {
+        let [in_node, out_node] = match wire {
+            Wire::Qubit(qubit) => self.qubit_io_map[qubit.0 as usize],
+            Wire::Clbit(clbit) => self.clbit_io_map[clbit.0 as usize],
+            Wire::Var(var) => [
+                self.var_input_map.remove(py, &var).unwrap(),
+                self.var_output_map.remove(py, &var).unwrap(),
+            ],
+        };
+        self.dag.remove_node(in_node);
+        self.dag.remove_node(out_node);
+        Ok(())
+    }
+
+    fn add_qubit_unchecked(&mut self, py: Python, bit: &Bound<PyAny>) -> PyResult<Qubit> {
+        let qubit = self.qubits.add(py, bit, false)?;
+        self.qubit_locations.bind(py).set_item(
+            bit,
+            Py::new(
+                py,
+                BitLocations {
+                    index: (self.qubits.len() - 1),
+                    registers: PyList::empty_bound(py).unbind(),
+                },
+            )?,
+        )?;
+        self.add_wire(py, Wire::Qubit(qubit))?;
+        Ok(qubit)
+    }
+
+    fn add_clbit_unchecked(&mut self, py: Python, bit: &Bound<PyAny>) -> PyResult<Clbit> {
+        let clbit = self.clbits.add(py, bit, false)?;
+        self.clbit_locations.bind(py).set_item(
+            bit,
+            Py::new(
+                py,
+                BitLocations {
+                    index: (self.clbits.len() - 1),
+                    registers: PyList::empty_bound(py).unbind(),
+                },
+            )?,
+        )?;
+        self.add_wire(py, Wire::Clbit(clbit))?;
+        Ok(clbit)
+    }
+
+    pub fn get_node(&self, py: Python, node: NodeIndex) -> PyResult<Py<PyAny>> {
+        self.unpack_into(py, node, self.dag.node_weight(node).unwrap())
+    }
+
+    /// Remove an operation node n.
+    ///
+    /// Add edges from predecessors to successors.
+    fn remove_op_node(&mut self, index: NodeIndex) {
+        let mut edge_list: Vec<(NodeIndex, NodeIndex, Wire)> = Vec::new();
+        for (source, in_weight) in self
+            .dag
+            .edges_directed(index, Incoming)
+            .map(|x| (x.source(), x.weight()))
+        {
+            for (target, out_weight) in self
+                .dag
+                .edges_directed(index, Outgoing)
+                .map(|x| (x.target(), x.weight()))
+            {
+                if in_weight == out_weight {
+                    edge_list.push((source, target, in_weight.clone()));
+                }
+            }
+        }
+        for (source, target, weight) in edge_list {
+            self.dag.add_edge(source, target, weight);
+        }
+
+        match self.dag.remove_node(index) {
+            Some(NodeType::Operation(packed)) => {
+                let op_name = packed.op.name();
+                self.decrement_op(op_name);
+            }
+            _ => panic!("Must be called with valid operation node!"),
+        }
+    }
+
+    /// Returns an iterator of the ancestors indices of a node.
+    pub fn ancestors(&self, node: NodeIndex) -> impl Iterator<Item = NodeIndex> + '_ {
+        core_ancestors(&self.dag, node).filter(move |next| next != &node)
+    }
+
+    /// Returns an iterator of the descendants of a node as DAGOpNodes and DAGOutNodes.
+    pub fn descendants(&self, node: NodeIndex) -> impl Iterator<Item = NodeIndex> + '_ {
+        core_descendants(&self.dag, node).filter(move |next| next != &node)
+    }
+
+    /// Returns an iterator of tuples of (DAGNode, [DAGNodes]) where the DAGNode is the current node
+    /// and [DAGNode] is its successors in  BFS order.
+    pub fn bfs_successors(
+        &self,
+        node: NodeIndex,
+    ) -> impl Iterator<Item = (NodeIndex, Vec<NodeIndex>)> + '_ {
+        core_bfs_successors(&self.dag, node).filter(move |(_, others)| !others.is_empty())
+    }
+
+    fn pack_into(&mut self, py: Python, b: &Bound<PyAny>) -> Result<NodeType, PyErr> {
+        Ok(if let Ok(in_node) = b.downcast::<DAGInNode>() {
+            let in_node = in_node.borrow();
+            let wire = in_node.wire.bind(py);
+            if wire.is_instance(imports::QUBIT.get_bound(py))? {
+                NodeType::QubitIn(self.qubits.find(wire).unwrap())
+            } else if wire.is_instance(imports::CLBIT.get_bound(py))? {
+                NodeType::ClbitIn(self.clbits.find(wire).unwrap())
+            } else {
+                NodeType::VarIn(wire.clone().unbind())
+            }
+        } else if let Ok(out_node) = b.downcast::<DAGOutNode>() {
+            let out_node = out_node.borrow();
+            let wire = out_node.wire.bind(py);
+            if wire.is_instance(imports::QUBIT.get_bound(py))? {
+                NodeType::QubitOut(self.qubits.find(wire).unwrap())
+            } else if wire.is_instance(imports::CLBIT.get_bound(py))? {
+                NodeType::ClbitOut(self.clbits.find(wire).unwrap())
+            } else {
+                NodeType::VarIn(wire.clone().unbind())
+            }
+        } else if let Ok(op_node) = b.downcast::<DAGOpNode>() {
+            let op_node = op_node.borrow();
+            let qubits = Interner::intern(
+                &mut self.qargs_cache,
+                self.qubits
+                    .map_bits(op_node.instruction.qubits.bind(py))?
+                    .collect(),
+            )?;
+            let clbits = Interner::intern(
+                &mut self.cargs_cache,
+                self.clbits
+                    .map_bits(op_node.instruction.clbits.bind(py))?
+                    .collect(),
+            )?;
+            let params = (!op_node.instruction.params.is_empty())
+                .then(|| Box::new(op_node.instruction.params.clone()));
+            let inst = PackedInstruction {
+                op: op_node.instruction.operation.clone(),
+                qubits,
+                clbits,
+                params,
+                extra_attrs: op_node.instruction.extra_attrs.clone(),
+                #[cfg(feature = "cache_pygates")]
+                py_op: op_node.instruction.py_op.clone(),
+            };
+            NodeType::Operation(inst)
+        } else {
+            return Err(PyTypeError::new_err("Invalid type for DAGNode"));
+        })
+    }
+
+    fn unpack_into(&self, py: Python, id: NodeIndex, weight: &NodeType) -> PyResult<Py<PyAny>> {
+        let dag_node = match weight {
+            NodeType::QubitIn(qubit) => Py::new(
+                py,
+                DAGInNode::new(py, id, self.qubits.get(*qubit).unwrap().clone_ref(py)),
+            )?
+            .into_any(),
+            NodeType::QubitOut(qubit) => Py::new(
+                py,
+                DAGOutNode::new(py, id, self.qubits.get(*qubit).unwrap().clone_ref(py)),
+            )?
+            .into_any(),
+            NodeType::ClbitIn(clbit) => Py::new(
+                py,
+                DAGInNode::new(py, id, self.clbits.get(*clbit).unwrap().clone_ref(py)),
+            )?
+            .into_any(),
+            NodeType::ClbitOut(clbit) => Py::new(
+                py,
+                DAGOutNode::new(py, id, self.clbits.get(*clbit).unwrap().clone_ref(py)),
+            )?
+            .into_any(),
+            NodeType::Operation(packed) => {
+                let qubits = self.qargs_cache.intern(packed.qubits);
+                let clbits = self.cargs_cache.intern(packed.clbits);
+                Py::new(
+                    py,
+                    (
+                        DAGOpNode {
+                            instruction: CircuitInstruction {
+                                operation: packed.op.clone(),
+                                qubits: PyTuple::new_bound(py, self.qubits.map_indices(qubits))
+                                    .unbind(),
+                                clbits: PyTuple::new_bound(py, self.clbits.map_indices(clbits))
+                                    .unbind(),
+                                params: packed.params_view().iter().cloned().collect(),
+                                extra_attrs: packed.extra_attrs.clone(),
+                                #[cfg(feature = "cache_pygates")]
+                                py_op: packed.py_op.clone(),
+                            },
+                            sort_key: format!("{:?}", self.sort_key(id)).into_py(py),
+                        },
+                        DAGNode { node: Some(id) },
+                    ),
+                )?
+                .into_any()
+            }
+            NodeType::VarIn(var) => {
+                Py::new(py, DAGInNode::new(py, id, var.clone_ref(py)))?.into_any()
+            }
+            NodeType::VarOut(var) => {
+                Py::new(py, DAGOutNode::new(py, id, var.clone_ref(py)))?.into_any()
+            }
+        };
+        Ok(dag_node)
+    }
+
+    /// Returns an iterator over all the indices that refer to an `Operation` node in the `DAGCircuit.`
+    pub fn op_nodes<'a>(
+        &'a self,
+        include_directives: bool,
+    ) -> Box<dyn Iterator<Item = NodeIndex> + 'a> {
+        let node_ops_iter = self
+            .dag
+            .node_references()
+            .filter_map(|(node_index, node_type)| match node_type {
+                NodeType::Operation(ref node) => Some((node_index, node)),
+                _ => None,
+            });
+        if !include_directives {
+            Box::new(node_ops_iter.filter_map(|(index, node)| {
+                if !node.op.directive() {
+                    Some(index)
+                } else {
+                    None
+                }
+            }))
+        } else {
+            Box::new(node_ops_iter.map(|(index, _)| index))
+        }
+    }
+
+    pub fn op_nodes_by_py_type<'a>(
+        &'a self,
+        op: &'a Bound<PyType>,
+        include_directives: bool,
+    ) -> impl Iterator<Item = NodeIndex> + 'a {
+        self.dag
+            .node_references()
+            .filter_map(move |(node, weight)| {
+                if let NodeType::Operation(ref packed) = weight {
+                    if !include_directives && packed.op.directive() {
+                        None
+                    } else if packed.op.py_op_is_instance(op).unwrap() {
+                        Some(node)
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                }
+            })
+    }
+
+    /// Returns an iterator over a list layers of the `DAGCircuit``.
+    pub fn multigraph_layers(&self, py: Python) -> impl Iterator<Item = Vec<NodeIndex>> + '_ {
+        let mut first_layer: Vec<_> = self.qubit_io_map.iter().map(|x| x[0]).collect();
+        first_layer.extend(self.clbit_io_map.iter().map(|x| x[0]));
+        first_layer.extend(self.var_input_map.values(py));
+        // A DAG is by definition acyclical, therefore unwrapping the layer should never fail.
+        layers(&self.dag, first_layer).map(|layer| match layer {
+            Ok(layer) => layer,
+            Err(_) => unreachable!("Not a DAG."),
+        })
+    }
+
+    /// Returns an iterator over the first layer of the `DAGCircuit``.
+    pub fn front_layer<'a>(&'a self, py: Python) -> Box<dyn Iterator<Item = NodeIndex> + 'a> {
+        let mut graph_layers = self.multigraph_layers(py);
+        graph_layers.next();
+
+        let next_layer = graph_layers.next();
+        match next_layer {
+            Some(layer) => Box::new(layer.into_iter().filter(|node| {
+                matches!(self.dag.node_weight(*node).unwrap(), NodeType::Operation(_))
+            })),
+            None => Box::new(vec![].into_iter()),
+        }
+    }
+
+    fn substitute_node_with_subgraph(
+        &mut self,
+        py: Python,
+        node: NodeIndex,
+        other: &DAGCircuit,
+        qubit_map: &HashMap<Qubit, Qubit>,
+        clbit_map: &HashMap<Clbit, Clbit>,
+        var_map: &Py<PyDict>,
+    ) -> PyResult<IndexMap<NodeIndex, NodeIndex, RandomState>> {
+        if self.dag.node_weight(node).is_none() {
+            return Err(PyIndexError::new_err(format!(
+                "Specified node {} is not in this graph",
+                node.index()
+            )));
+        }
+
+        // Add wire from pred to succ if no ops on mapped wire on ``other``
+        for (in_dag_wire, self_wire) in qubit_map.iter() {
+            let [input_node, out_node] = other.qubit_io_map[in_dag_wire.0 as usize];
+            if other.dag.find_edge(input_node, out_node).is_some() {
+                let pred = self
+                    .dag
+                    .edges_directed(node, Incoming)
+                    .find(|edge| {
+                        if let Wire::Qubit(bit) = edge.weight() {
+                            bit == self_wire
+                        } else {
+                            false
+                        }
+                    })
+                    .unwrap();
+                let succ = self
+                    .dag
+                    .edges_directed(node, Outgoing)
+                    .find(|edge| {
+                        if let Wire::Qubit(bit) = edge.weight() {
+                            bit == self_wire
+                        } else {
+                            false
+                        }
+                    })
+                    .unwrap();
+                self.dag
+                    .add_edge(pred.source(), succ.target(), Wire::Qubit(*self_wire));
+            }
+        }
+        for (in_dag_wire, self_wire) in clbit_map.iter() {
+            let [input_node, out_node] = other.clbit_io_map[in_dag_wire.0 as usize];
+            if other.dag.find_edge(input_node, out_node).is_some() {
+                let pred = self
+                    .dag
+                    .edges_directed(node, Incoming)
+                    .find(|edge| {
+                        if let Wire::Clbit(bit) = edge.weight() {
+                            bit == self_wire
+                        } else {
+                            false
+                        }
+                    })
+                    .unwrap();
+                let succ = self
+                    .dag
+                    .edges_directed(node, Outgoing)
+                    .find(|edge| {
+                        if let Wire::Clbit(bit) = edge.weight() {
+                            bit == self_wire
+                        } else {
+                            false
+                        }
+                    })
+                    .unwrap();
+                self.dag
+                    .add_edge(pred.source(), succ.target(), Wire::Clbit(*self_wire));
+            }
+        }
+
+        let bound_var_map = var_map.bind(py);
+        let node_filter = |node: NodeIndex| -> bool {
+            match other.dag[node] {
+                NodeType::Operation(_) => !other
+                    .dag
+                    .edges_directed(node, petgraph::Direction::Outgoing)
+                    .any(|edge| match edge.weight() {
+                        Wire::Qubit(qubit) => !qubit_map.contains_key(qubit),
+                        Wire::Clbit(clbit) => !clbit_map.contains_key(clbit),
+                        Wire::Var(var) => !bound_var_map.contains(var).unwrap(),
+                    }),
+                _ => false,
+            }
+        };
+        let reverse_qubit_map: HashMap<Qubit, Qubit> =
+            qubit_map.iter().map(|(x, y)| (*y, *x)).collect();
+        let reverse_clbit_map: HashMap<Clbit, Clbit> =
+            clbit_map.iter().map(|(x, y)| (*y, *x)).collect();
+        let reverse_var_map = PyDict::new_bound(py);
+        for (k, v) in bound_var_map.iter() {
+            reverse_var_map.set_item(v, k)?;
+        }
+        // Copy nodes from other to self
+        let mut out_map: IndexMap<NodeIndex, NodeIndex, RandomState> =
+            IndexMap::with_capacity_and_hasher(other.dag.node_count(), RandomState::default());
+        for old_index in other.dag.node_indices() {
+            if !node_filter(old_index) {
+                continue;
+            }
+            let mut new_node = other.dag[old_index].clone();
+            if let NodeType::Operation(ref mut new_inst) = new_node {
+                let new_qubit_indices: Vec<Qubit> = other
+                    .qargs_cache
+                    .intern(new_inst.qubits)
+                    .iter()
+                    .map(|old_qubit| qubit_map[old_qubit])
+                    .collect();
+                let new_clbit_indices: Vec<Clbit> = other
+                    .cargs_cache
+                    .intern(new_inst.clbits)
+                    .iter()
+                    .map(|old_clbit| clbit_map[old_clbit])
+                    .collect();
+                new_inst.qubits = Interner::intern(&mut self.qargs_cache, new_qubit_indices)?;
+                new_inst.clbits = Interner::intern(&mut self.cargs_cache, new_clbit_indices)?;
+                self.increment_op(new_inst.op.name());
+            }
+            let new_index = self.dag.add_node(new_node);
+            out_map.insert(old_index, new_index);
+        }
+        // If no nodes are copied bail here since there is nothing left
+        // to do.
+        if out_map.is_empty() {
+            match self.dag.remove_node(node) {
+                Some(NodeType::Operation(packed)) => {
+                    let op_name = packed.op.name();
+                    self.decrement_op(op_name);
+                }
+                _ => unreachable!("Must be called with valid operation node!"),
+            }
+            // Return a new empty map to clear allocation from out_map
+            return Ok(IndexMap::default());
+        }
+        // Copy edges from other to self
+        for edge in other.dag.edge_references().filter(|edge| {
+            out_map.contains_key(&edge.target()) && out_map.contains_key(&edge.source())
+        }) {
+            self.dag.add_edge(
+                out_map[&edge.source()],
+                out_map[&edge.target()],
+                match edge.weight() {
+                    Wire::Qubit(qubit) => Wire::Qubit(qubit_map[qubit]),
+                    Wire::Clbit(clbit) => Wire::Clbit(clbit_map[clbit]),
+                    Wire::Var(var) => Wire::Var(bound_var_map.get_item(var)?.unwrap().unbind()),
+                },
+            );
+        }
+        // Add edges to/from node to nodes in other
+        let edges: Vec<(NodeIndex, NodeIndex, Wire)> = self
+            .dag
+            .edges_directed(node, Incoming)
+            .map(|x| (x.source(), x.target(), x.weight().clone()))
+            .collect();
+        for (source, _target, weight) in edges {
+            let wire_input_id = match weight {
+                Wire::Qubit(qubit) => other
+                    .qubit_io_map
+                    .get(reverse_qubit_map[&qubit].0 as usize)
+                    .map(|x| x[0]),
+                Wire::Clbit(clbit) => other
+                    .clbit_io_map
+                    .get(reverse_clbit_map[&clbit].0 as usize)
+                    .map(|x| x[0]),
+                Wire::Var(ref var) => {
+                    let index = &reverse_var_map.get_item(var)?.unwrap().unbind();
+                    other.var_input_map.get(py, index)
+                }
+            };
+            let old_index =
+                wire_input_id.and_then(|x| other.dag.neighbors_directed(x, Outgoing).next());
+            let target_out = match old_index {
+                Some(old_index) => match out_map.get(&old_index) {
+                    Some(new_index) => *new_index,
+                    None => {
+                        // If the index isn't in the node map we've already added the edges as
+                        // part of the idle wire handling at the top of this method so just
+                        // move on.
+                        continue;
+                    }
+                },
+                None => continue,
+            };
+            self.dag.add_edge(source, target_out, weight);
+        }
+        let edges: Vec<(NodeIndex, NodeIndex, Wire)> = self
+            .dag
+            .edges_directed(node, Outgoing)
+            .map(|x| (x.source(), x.target(), x.weight().clone()))
+            .collect();
+        for (_source, target, weight) in edges {
+            let wire_output_id = match weight {
+                Wire::Qubit(qubit) => other
+                    .qubit_io_map
+                    .get(reverse_qubit_map[&qubit].0 as usize)
+                    .map(|x| x[1]),
+                Wire::Clbit(clbit) => other
+                    .clbit_io_map
+                    .get(reverse_clbit_map[&clbit].0 as usize)
+                    .map(|x| x[1]),
+                Wire::Var(ref var) => {
+                    let index = &reverse_var_map.get_item(var)?.unwrap().unbind();
+                    other.var_output_map.get(py, index)
+                }
+            };
+            let old_index =
+                wire_output_id.and_then(|x| other.dag.neighbors_directed(x, Incoming).next());
+            let source_out = match old_index {
+                Some(old_index) => match out_map.get(&old_index) {
+                    Some(new_index) => *new_index,
+                    None => {
+                        // If the index isn't in the node map we've already added the edges as
+                        // part of the idle wire handling at the top of this method so just
+                        // move on.
+                        continue;
+                    }
+                },
+                None => continue,
+            };
+            self.dag.add_edge(source_out, target, weight);
+        }
+        // Remove node
+        if let NodeType::Operation(inst) = &self.dag[node] {
+            self.decrement_op(inst.op.name().to_string().as_str());
+        }
+        self.dag.remove_node(node);
+        Ok(out_map)
+    }
+
+    fn add_var(&mut self, py: Python, var: &Bound<PyAny>, type_: DAGVarType) -> PyResult<()> {
+        // The setup of the initial graph structure between an "in" and an "out" node is the same as
+        // the bit-related `_add_wire`, but this logically needs to do different bookkeeping around
+        // tracking the properties
+        if !var.getattr("standalone")?.extract::<bool>()? {
+            return Err(DAGCircuitError::new_err(
+                "cannot add variables that wrap `Clbit` or `ClassicalRegister` instances",
+            ));
+        }
+        let var_name: String = var.getattr("name")?.extract::<String>()?;
+        if let Some(previous) = self.vars_info.get(&var_name) {
+            if var.eq(previous.var.clone_ref(py))? {
+                return Err(DAGCircuitError::new_err("already present in the circuit"));
+            }
+            return Err(DAGCircuitError::new_err(
+                "cannot add var as its name shadows an existing var",
+            ));
+        }
+        let in_node = NodeType::VarIn(var.clone().unbind());
+        let out_node = NodeType::VarOut(var.clone().unbind());
+        let in_index = self.dag.add_node(in_node);
+        let out_index = self.dag.add_node(out_node);
+        self.dag
+            .add_edge(in_index, out_index, Wire::Var(var.clone().unbind()));
+        self.var_input_map
+            .insert(py, var.clone().unbind(), in_index);
+        self.var_output_map
+            .insert(py, var.clone().unbind(), out_index);
+        self.vars_by_type[type_ as usize]
+            .bind(py)
+            .add(var.clone().unbind())?;
+        self.vars_info.insert(
+            var_name,
+            DAGVarInfo {
+                var: var.clone().unbind(),
+                type_,
+                in_node: in_index,
+                out_node: out_index,
+            },
+        );
+        Ok(())
+    }
+
+    fn check_op_addition(&self, py: Python, inst: &PackedInstruction) -> PyResult<()> {
+        if let Some(condition) = inst.condition() {
+            self._check_condition(py, inst.op.name(), condition.bind(py))?;
+        }
+
+        for b in self.qargs_cache.intern(inst.qubits) {
+            if self.qubit_io_map.len() - 1 < b.0 as usize {
+                return Err(DAGCircuitError::new_err(format!(
+                    "qubit {} not found in output map",
+                    self.qubits.get(*b).unwrap()
+                )));
+            }
+        }
+
+        for b in self.cargs_cache.intern(inst.clbits) {
+            if !self.clbit_io_map.len() - 1 < b.0 as usize {
+                return Err(DAGCircuitError::new_err(format!(
+                    "clbit {} not found in output map",
+                    self.clbits.get(*b).unwrap()
+                )));
+            }
+        }
+
+        if self.may_have_additional_wires(py, inst) {
+            let (clbits, vars) = self.additional_wires(py, inst.op.view(), inst.condition())?;
+            for b in clbits {
+                if !self.clbit_io_map.len() - 1 < b.0 as usize {
+                    return Err(DAGCircuitError::new_err(format!(
+                        "clbit {} not found in output map",
+                        self.clbits.get(b).unwrap()
+                    )));
+                }
+            }
+            for v in vars {
+                if !self.var_output_map.contains_key(py, &v) {
+                    return Err(DAGCircuitError::new_err(format!(
+                        "var {} not found in output map",
+                        v
+                    )));
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+/// Add to global phase. Global phase can only be Float or ParameterExpression so this
+/// does not handle the full possibility of parameter values.
+fn add_global_phase(py: Python, phase: &Param, other: &Param) -> PyResult<Param> {
+    Ok(match [phase, other] {
+        [Param::Float(a), Param::Float(b)] => Param::Float(a + b),
+        [Param::Float(a), Param::ParameterExpression(b)] => Param::ParameterExpression(
+            b.clone_ref(py)
+                .call_method1(py, intern!(py, "__radd__"), (*a,))?,
+        ),
+        [Param::ParameterExpression(a), Param::Float(b)] => Param::ParameterExpression(
+            a.clone_ref(py)
+                .call_method1(py, intern!(py, "__add__"), (*b,))?,
+        ),
+        [Param::ParameterExpression(a), Param::ParameterExpression(b)] => {
+            Param::ParameterExpression(a.clone_ref(py).call_method1(
+                py,
+                intern!(py, "__add__"),
+                (b,),
+            )?)
+        }
+        _ => panic!("Invalid global phase"),
+    })
+}
+
+type SortKeyType<'a> = (&'a [Qubit], &'a [Clbit]);
diff --git a/crates/circuit/src/dag_node.rs b/crates/circuit/src/dag_node.rs
index 9af82b74fa5a..ccae7a8c5d82 100644
--- a/crates/circuit/src/dag_node.rs
+++ b/crates/circuit/src/dag_node.rs
@@ -12,47 +12,89 @@
 
 #[cfg(feature = "cache_pygates")]
 use std::cell::OnceCell;
+use std::hash::Hasher;
 
 use crate::circuit_instruction::{CircuitInstruction, OperationFromPython};
 use crate::imports::QUANTUM_CIRCUIT;
-use crate::operations::Operation;
+use crate::operations::{Operation, Param};
+use crate::TupleLikeArg;
 
-use numpy::IntoPyArray;
+use ahash::AHasher;
+use approx::relative_eq;
+use rustworkx_core::petgraph::stable_graph::NodeIndex;
 
+use numpy::IntoPyArray;
+use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyList, PySequence, PyString, PyTuple};
+use pyo3::types::{PyString, PyTuple};
 use pyo3::{intern, IntoPy, PyObject, PyResult, ToPyObject};
 
 /// Parent class for DAGOpNode, DAGInNode, and DAGOutNode.
 #[pyclass(module = "qiskit._accelerate.circuit", subclass)]
 #[derive(Clone, Debug)]
 pub struct DAGNode {
-    #[pyo3(get, set)]
-    pub _node_id: isize,
+    pub node: Option<NodeIndex>,
+}
+
+impl DAGNode {
+    #[inline]
+    pub fn py_nid(&self) -> isize {
+        self.node
+            .map(|node| node.index().try_into().unwrap())
+            .unwrap_or(-1)
+    }
 }
 
 #[pymethods]
 impl DAGNode {
     #[new]
     #[pyo3(signature=(nid=-1))]
-    fn new(nid: isize) -> Self {
-        DAGNode { _node_id: nid }
+    fn py_new(nid: isize) -> PyResult<Self> {
+        Ok(DAGNode {
+            node: match nid {
+                -1 => None,
+                nid => {
+                    let index: usize = match nid.try_into() {
+                        Ok(index) => index,
+                        Err(_) => {
+                            return Err(PyValueError::new_err(
+                                "Invalid node index, must be -1 or a non-negative integer",
+                            ))
+                        }
+                    };
+                    Some(NodeIndex::new(index))
+                }
+            },
+        })
     }
 
-    fn __getstate__(&self) -> isize {
-        self._node_id
+    #[getter(_node_id)]
+    fn get_py_node_id(&self) -> isize {
+        self.py_nid()
     }
 
-    fn __setstate__(&mut self, nid: isize) {
-        self._node_id = nid;
+    #[setter(_node_id)]
+    fn set_py_node_id(&mut self, nid: isize) {
+        self.node = match nid {
+            -1 => None,
+            nid => Some(NodeIndex::new(nid.try_into().unwrap())),
+        }
+    }
+
+    fn __getstate__(&self) -> Option<usize> {
+        self.node.map(|node| node.index())
+    }
+
+    fn __setstate__(&mut self, index: Option<usize>) {
+        self.node = index.map(NodeIndex::new);
     }
 
     fn __lt__(&self, other: &DAGNode) -> bool {
-        self._node_id < other._node_id
+        self.py_nid() < other.py_nid()
     }
 
     fn __gt__(&self, other: &DAGNode) -> bool {
-        self._node_id > other._node_id
+        self.py_nid() > other.py_nid()
     }
 
     fn __str__(_self: &Bound<DAGNode>) -> String {
@@ -60,7 +102,7 @@ impl DAGNode {
     }
 
     fn __hash__(&self, py: Python) -> PyResult<isize> {
-        self._node_id.into_py(py).bind(py).hash()
+        self.py_nid().into_py(py).bind(py).hash()
     }
 }
 
@@ -76,96 +118,124 @@ pub struct DAGOpNode {
 impl DAGOpNode {
     #[new]
     #[pyo3(signature = (op, qargs=None, cargs=None, *, dag=None))]
-    fn new(
+    pub fn py_new(
         py: Python,
-        op: &Bound<PyAny>,
-        qargs: Option<&Bound<PySequence>>,
-        cargs: Option<&Bound<PySequence>>,
-        dag: Option<&Bound<PyAny>>,
-    ) -> PyResult<(Self, DAGNode)> {
-        let qargs =
-            qargs.map_or_else(|| Ok(PyTuple::empty_bound(py)), PySequenceMethods::to_tuple)?;
-        let cargs =
-            cargs.map_or_else(|| Ok(PyTuple::empty_bound(py)), PySequenceMethods::to_tuple)?;
-
-        let sort_key = match dag {
-            Some(dag) => {
-                let cache = dag
-                    .getattr(intern!(py, "_key_cache"))?
-                    .downcast_into_exact::<PyDict>()?;
-                let cache_key = PyTuple::new_bound(py, [&qargs, &cargs]);
-                match cache.get_item(&cache_key)? {
-                    Some(key) => key,
-                    None => {
-                        let indices: PyResult<Vec<_>> = qargs
-                            .iter()
-                            .chain(cargs.iter())
-                            .map(|bit| {
-                                dag.call_method1(intern!(py, "find_bit"), (bit,))?
-                                    .getattr(intern!(py, "index"))
-                            })
-                            .collect();
-                        let index_strs: Vec<_> =
-                            indices?.into_iter().map(|i| format!("{:04}", i)).collect();
-                        let key = PyString::new_bound(py, index_strs.join(",").as_str());
-                        cache.set_item(&cache_key, &key)?;
-                        key.into_any()
+        op: Bound<PyAny>,
+        qargs: Option<TupleLikeArg>,
+        cargs: Option<TupleLikeArg>,
+        #[allow(unused_variables)] dag: Option<Bound<PyAny>>,
+    ) -> PyResult<Py<Self>> {
+        let py_op = op.extract::<OperationFromPython>()?;
+        let qargs = qargs.map_or_else(|| PyTuple::empty_bound(py), |q| q.value);
+        let sort_key = qargs.str().unwrap().into();
+        let cargs = cargs.map_or_else(|| PyTuple::empty_bound(py), |c| c.value);
+        let instruction = CircuitInstruction {
+            operation: py_op.operation,
+            qubits: qargs.unbind(),
+            clbits: cargs.unbind(),
+            params: py_op.params,
+            extra_attrs: py_op.extra_attrs,
+            #[cfg(feature = "cache_pygates")]
+            py_op: op.unbind().into(),
+        };
+
+        Py::new(
+            py,
+            (
+                DAGOpNode {
+                    instruction,
+                    sort_key,
+                },
+                DAGNode { node: None },
+            ),
+        )
+    }
+
+    fn __hash__(slf: PyRef<'_, Self>) -> PyResult<u64> {
+        let super_ = slf.as_ref();
+        let mut hasher = AHasher::default();
+        hasher.write_isize(super_.py_nid());
+        hasher.write(slf.instruction.operation.name().as_bytes());
+        Ok(hasher.finish())
+    }
+
+    fn __eq__(slf: PyRef<Self>, py: Python, other: &Bound<PyAny>) -> PyResult<bool> {
+        // This check is more restrictive by design as it's intended to replace
+        // object identitity for set/dict membership and not be a semantic equivalence
+        // check. We have an implementation of that as part of `DAGCircuit.__eq__` and
+        // this method is specifically to ensure nodes are the same. This means things
+        // like parameter equality are stricter to reject things like
+        // Param::Float(0.1) == Param::ParameterExpression(0.1) (if the expression was
+        // a python parameter equivalent to a bound value).
+        let Ok(other) = other.downcast::<Self>() else {
+            return Ok(false);
+        };
+        let borrowed_other = other.borrow();
+        let other_super = borrowed_other.as_ref();
+        let super_ = slf.as_ref();
+
+        if super_.py_nid() != other_super.py_nid() {
+            return Ok(false);
+        }
+        if !slf
+            .instruction
+            .operation
+            .py_eq(py, &borrowed_other.instruction.operation)?
+        {
+            return Ok(false);
+        }
+        let params_eq = if slf.instruction.operation.try_standard_gate().is_some() {
+            let mut params_eq = true;
+            for (a, b) in slf
+                .instruction
+                .params
+                .iter()
+                .zip(borrowed_other.instruction.params.iter())
+            {
+                let res = match [a, b] {
+                    [Param::Float(float_a), Param::Float(float_b)] => {
+                        relative_eq!(float_a, float_b, max_relative = 1e-10)
+                    }
+                    [Param::ParameterExpression(param_a), Param::ParameterExpression(param_b)] => {
+                        param_a.bind(py).eq(param_b)?
                     }
+                    [Param::Obj(param_a), Param::Obj(param_b)] => param_a.bind(py).eq(param_b)?,
+                    _ => false,
+                };
+                if !res {
+                    params_eq = false;
+                    break;
                 }
             }
-            None => qargs.str()?.into_any(),
+            params_eq
+        } else {
+            // We've already evaluated the parameters are equal here via the Python space equality
+            // check so if we're not comparing standard gates and we've reached this point we know
+            // the parameters are already equal.
+            true
         };
-        Ok((
-            DAGOpNode {
-                instruction: CircuitInstruction::py_new(
-                    op,
-                    Some(qargs.into_any()),
-                    Some(cargs.into_any()),
-                )?,
-                sort_key: sort_key.unbind(),
-            },
-            DAGNode { _node_id: -1 },
-        ))
+
+        Ok(params_eq
+            && slf
+                .instruction
+                .qubits
+                .bind(py)
+                .eq(borrowed_other.instruction.qubits.clone_ref(py))?
+            && slf
+                .instruction
+                .clbits
+                .bind(py)
+                .eq(borrowed_other.instruction.clbits.clone_ref(py))?)
     }
 
-    #[pyo3(signature = (instruction, /, *, dag=None, deepcopy=false))]
+    #[pyo3(signature = (instruction, /, *, deepcopy=false))]
     #[staticmethod]
     fn from_instruction(
         py: Python,
         mut instruction: CircuitInstruction,
-        dag: Option<&Bound<PyAny>>,
         deepcopy: bool,
     ) -> PyResult<PyObject> {
-        let qargs = instruction.qubits.bind(py);
-        let cargs = instruction.clbits.bind(py);
-
-        let sort_key = match dag {
-            Some(dag) => {
-                let cache = dag
-                    .getattr(intern!(py, "_key_cache"))?
-                    .downcast_into_exact::<PyDict>()?;
-                let cache_key = PyTuple::new_bound(py, [&qargs, &cargs]);
-                match cache.get_item(&cache_key)? {
-                    Some(key) => key,
-                    None => {
-                        let indices: PyResult<Vec<_>> = qargs
-                            .iter()
-                            .chain(cargs.iter())
-                            .map(|bit| {
-                                dag.call_method1(intern!(py, "find_bit"), (bit,))?
-                                    .getattr(intern!(py, "index"))
-                            })
-                            .collect();
-                        let index_strs: Vec<_> =
-                            indices?.into_iter().map(|i| format!("{:04}", i)).collect();
-                        let key = PyString::new_bound(py, index_strs.join(",").as_str());
-                        cache.set_item(&cache_key, &key)?;
-                        key.into_any()
-                    }
-                }
-            }
-            None => qargs.str()?.into_any(),
-        };
+        let sort_key = instruction.qubits.bind(py).str().unwrap().into();
         if deepcopy {
             instruction.operation = instruction.operation.py_deepcopy(py, None)?;
             #[cfg(feature = "cache_pygates")]
@@ -173,17 +243,16 @@ impl DAGOpNode {
                 instruction.py_op = OnceCell::new();
             }
         }
-        let base = PyClassInitializer::from(DAGNode { _node_id: -1 });
+        let base = PyClassInitializer::from(DAGNode { node: None });
         let sub = base.add_subclass(DAGOpNode {
             instruction,
-            sort_key: sort_key.unbind(),
+            sort_key,
         });
         Ok(Py::new(py, sub)?.to_object(py))
     }
 
-    fn __reduce__(slf: PyRef<Self>) -> PyResult<PyObject> {
-        let py = slf.py();
-        let state = (slf.as_ref()._node_id, &slf.sort_key);
+    fn __reduce__(slf: PyRef<Self>, py: Python) -> PyResult<PyObject> {
+        let state = (slf.as_ref().node.map(|node| node.index()), &slf.sort_key);
         Ok((
             py.get_type_bound::<Self>(),
             (
@@ -197,8 +266,8 @@ impl DAGOpNode {
     }
 
     fn __setstate__(mut slf: PyRefMut<Self>, state: &Bound<PyAny>) -> PyResult<()> {
-        let (nid, sort_key): (isize, PyObject) = state.extract()?;
-        slf.as_mut()._node_id = nid;
+        let (index, sort_key): (Option<usize>, PyObject) = state.extract()?;
+        slf.as_mut().node = index.map(NodeIndex::new);
         slf.sort_key = sort_key;
         Ok(())
     }
@@ -247,16 +316,16 @@ impl DAGOpNode {
 
     #[getter]
     fn num_qubits(&self) -> u32 {
-        self.instruction.op().num_qubits()
+        self.instruction.operation.num_qubits()
     }
 
     #[getter]
     fn num_clbits(&self) -> u32 {
-        self.instruction.op().num_clbits()
+        self.instruction.operation.num_clbits()
     }
 
     #[getter]
-    fn get_qargs(&self, py: Python) -> Py<PyTuple> {
+    pub fn get_qargs(&self, py: Python) -> Py<PyTuple> {
         self.instruction.qubits.clone_ref(py)
     }
 
@@ -266,7 +335,7 @@ impl DAGOpNode {
     }
 
     #[getter]
-    fn get_cargs(&self, py: Python) -> Py<PyTuple> {
+    pub fn get_cargs(&self, py: Python) -> Py<PyTuple> {
         self.instruction.clbits.clone_ref(py)
     }
 
@@ -278,7 +347,7 @@ impl DAGOpNode {
     /// Returns the Instruction name corresponding to the op for this node
     #[getter]
     fn get_name(&self, py: Python) -> Py<PyString> {
-        self.instruction.op().name().into_py(py)
+        self.instruction.operation.name().into_py(py)
     }
 
     #[getter]
@@ -293,7 +362,7 @@ impl DAGOpNode {
 
     #[getter]
     fn matrix(&self, py: Python) -> Option<PyObject> {
-        let matrix = self.instruction.op().matrix(&self.instruction.params);
+        let matrix = self.instruction.operation.matrix(&self.instruction.params);
         matrix.map(|mat| mat.into_pyarray_bound(py).into())
     }
 
@@ -386,7 +455,7 @@ impl DAGOpNode {
     #[getter]
     fn definition<'py>(&self, py: Python<'py>) -> PyResult<Option<Bound<'py, PyAny>>> {
         self.instruction
-            .op()
+            .operation
             .definition(&self.instruction.params)
             .map(|data| {
                 QUANTUM_CIRCUIT
@@ -420,36 +489,69 @@ impl DAGOpNode {
 #[pyclass(module = "qiskit._accelerate.circuit", extends=DAGNode)]
 pub struct DAGInNode {
     #[pyo3(get)]
-    wire: PyObject,
+    pub wire: PyObject,
     #[pyo3(get)]
     sort_key: PyObject,
 }
 
+impl DAGInNode {
+    pub fn new(py: Python, node: NodeIndex, wire: PyObject) -> (Self, DAGNode) {
+        (
+            DAGInNode {
+                wire,
+                sort_key: intern!(py, "[]").clone().into(),
+            },
+            DAGNode { node: Some(node) },
+        )
+    }
+}
+
 #[pymethods]
 impl DAGInNode {
     #[new]
-    fn new(py: Python, wire: PyObject) -> PyResult<(Self, DAGNode)> {
+    fn py_new(py: Python, wire: PyObject) -> PyResult<(Self, DAGNode)> {
         Ok((
             DAGInNode {
                 wire,
-                sort_key: PyList::empty_bound(py).str()?.into_any().unbind(),
+                sort_key: intern!(py, "[]").clone().into(),
             },
-            DAGNode { _node_id: -1 },
+            DAGNode { node: None },
         ))
     }
 
     fn __reduce__(slf: PyRef<Self>, py: Python) -> PyObject {
-        let state = (slf.as_ref()._node_id, &slf.sort_key);
+        let state = (slf.as_ref().node.map(|node| node.index()), &slf.sort_key);
         (py.get_type_bound::<Self>(), (&slf.wire,), state).into_py(py)
     }
 
     fn __setstate__(mut slf: PyRefMut<Self>, state: &Bound<PyAny>) -> PyResult<()> {
-        let (nid, sort_key): (isize, PyObject) = state.extract()?;
-        slf.as_mut()._node_id = nid;
+        let (index, sort_key): (Option<usize>, PyObject) = state.extract()?;
+        slf.as_mut().node = index.map(NodeIndex::new);
         slf.sort_key = sort_key;
         Ok(())
     }
 
+    fn __hash__(slf: PyRef<'_, Self>, py: Python) -> PyResult<u64> {
+        let super_ = slf.as_ref();
+        let mut hasher = AHasher::default();
+        hasher.write_isize(super_.py_nid());
+        hasher.write_isize(slf.wire.bind(py).hash()?);
+        Ok(hasher.finish())
+    }
+
+    fn __eq__(slf: PyRef<Self>, py: Python, other: &Bound<PyAny>) -> PyResult<bool> {
+        match other.downcast::<Self>() {
+            Ok(other) => {
+                let borrowed_other = other.borrow();
+                let other_super = borrowed_other.as_ref();
+                let super_ = slf.as_ref();
+                Ok(super_.py_nid() == other_super.py_nid()
+                    && slf.wire.bind(py).eq(borrowed_other.wire.clone_ref(py))?)
+            }
+            Err(_) => Ok(false),
+        }
+    }
+
     /// Returns a representation of the DAGInNode
     fn __repr__(&self, py: Python) -> PyResult<String> {
         Ok(format!("DAGInNode(wire={})", self.wire.bind(py).repr()?))
@@ -460,38 +562,71 @@ impl DAGInNode {
 #[pyclass(module = "qiskit._accelerate.circuit", extends=DAGNode)]
 pub struct DAGOutNode {
     #[pyo3(get)]
-    wire: PyObject,
+    pub wire: PyObject,
     #[pyo3(get)]
     sort_key: PyObject,
 }
 
+impl DAGOutNode {
+    pub fn new(py: Python, node: NodeIndex, wire: PyObject) -> (Self, DAGNode) {
+        (
+            DAGOutNode {
+                wire,
+                sort_key: intern!(py, "[]").clone().into(),
+            },
+            DAGNode { node: Some(node) },
+        )
+    }
+}
+
 #[pymethods]
 impl DAGOutNode {
     #[new]
-    fn new(py: Python, wire: PyObject) -> PyResult<(Self, DAGNode)> {
+    fn py_new(py: Python, wire: PyObject) -> PyResult<(Self, DAGNode)> {
         Ok((
             DAGOutNode {
                 wire,
-                sort_key: PyList::empty_bound(py).str()?.into_any().unbind(),
+                sort_key: intern!(py, "[]").clone().into(),
             },
-            DAGNode { _node_id: -1 },
+            DAGNode { node: None },
         ))
     }
 
     fn __reduce__(slf: PyRef<Self>, py: Python) -> PyObject {
-        let state = (slf.as_ref()._node_id, &slf.sort_key);
+        let state = (slf.as_ref().node.map(|node| node.index()), &slf.sort_key);
         (py.get_type_bound::<Self>(), (&slf.wire,), state).into_py(py)
     }
 
     fn __setstate__(mut slf: PyRefMut<Self>, state: &Bound<PyAny>) -> PyResult<()> {
-        let (nid, sort_key): (isize, PyObject) = state.extract()?;
-        slf.as_mut()._node_id = nid;
+        let (index, sort_key): (Option<usize>, PyObject) = state.extract()?;
+        slf.as_mut().node = index.map(NodeIndex::new);
         slf.sort_key = sort_key;
         Ok(())
     }
 
+    fn __hash__(slf: PyRef<'_, Self>, py: Python) -> PyResult<u64> {
+        let super_ = slf.as_ref();
+        let mut hasher = AHasher::default();
+        hasher.write_isize(super_.py_nid());
+        hasher.write_isize(slf.wire.bind(py).hash()?);
+        Ok(hasher.finish())
+    }
+
     /// Returns a representation of the DAGOutNode
     fn __repr__(&self, py: Python) -> PyResult<String> {
         Ok(format!("DAGOutNode(wire={})", self.wire.bind(py).repr()?))
     }
+
+    fn __eq__(slf: PyRef<Self>, py: Python, other: &Bound<PyAny>) -> PyResult<bool> {
+        match other.downcast::<Self>() {
+            Ok(other) => {
+                let borrowed_other = other.borrow();
+                let other_super = borrowed_other.as_ref();
+                let super_ = slf.as_ref();
+                Ok(super_.py_nid() == other_super.py_nid()
+                    && slf.wire.bind(py).eq(borrowed_other.wire.clone_ref(py))?)
+            }
+            Err(_) => Ok(false),
+        }
+    }
 }
diff --git a/crates/circuit/src/dot_utils.rs b/crates/circuit/src/dot_utils.rs
new file mode 100644
index 000000000000..f6769c6cad11
--- /dev/null
+++ b/crates/circuit/src/dot_utils.rs
@@ -0,0 +1,109 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2022
+//
+// 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.
+
+// This module is forked from rustworkx at:
+// https://github.com/Qiskit/rustworkx/blob/c4256daf96fc3c08c392450ed33bc0987cdb15ff/src/dot_utils.rs
+// and has been modified to generate a dot file from a Rust DAGCircuit instead
+// of a rustworkx PyGraph object
+
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+
+use crate::dag_circuit::{DAGCircuit, Wire};
+use pyo3::prelude::*;
+use rustworkx_core::petgraph::visit::{
+    EdgeRef, IntoEdgeReferences, IntoNodeReferences, NodeIndexable, NodeRef,
+};
+
+static TYPE: [&str; 2] = ["graph", "digraph"];
+static EDGE: [&str; 2] = ["--", "->"];
+
+pub fn build_dot<T>(
+    py: Python,
+    dag: &DAGCircuit,
+    file: &mut T,
+    graph_attrs: Option<BTreeMap<String, String>>,
+    node_attrs: Option<PyObject>,
+    edge_attrs: Option<PyObject>,
+) -> PyResult<()>
+where
+    T: Write,
+{
+    let graph = &dag.dag;
+    writeln!(file, "{} {{", TYPE[graph.is_directed() as usize])?;
+    if let Some(graph_attr_map) = graph_attrs {
+        for (key, value) in graph_attr_map.iter() {
+            writeln!(file, "{}={} ;", key, value)?;
+        }
+    }
+
+    for node in graph.node_references() {
+        let node_weight = dag.get_node(py, node.id())?;
+        writeln!(
+            file,
+            "{} {};",
+            graph.to_index(node.id()),
+            attr_map_to_string(py, node_attrs.as_ref(), node_weight)?
+        )?;
+    }
+    for edge in graph.edge_references() {
+        let edge_weight = match edge.weight() {
+            Wire::Qubit(qubit) => dag.qubits.get(*qubit).unwrap(),
+            Wire::Clbit(clbit) => dag.clbits.get(*clbit).unwrap(),
+            Wire::Var(var) => var,
+        };
+        writeln!(
+            file,
+            "{} {} {} {};",
+            graph.to_index(edge.source()),
+            EDGE[graph.is_directed() as usize],
+            graph.to_index(edge.target()),
+            attr_map_to_string(py, edge_attrs.as_ref(), edge_weight)?
+        )?;
+    }
+    writeln!(file, "}}")?;
+    Ok(())
+}
+
+static ATTRS_TO_ESCAPE: [&str; 2] = ["label", "tooltip"];
+
+/// Convert an attr map to an output string
+fn attr_map_to_string<T: ToPyObject>(
+    py: Python,
+    attrs: Option<&PyObject>,
+    weight: T,
+) -> PyResult<String> {
+    if attrs.is_none() {
+        return Ok("".to_string());
+    }
+    let attr_callable = |node: T| -> PyResult<BTreeMap<String, String>> {
+        let res = attrs.unwrap().call1(py, (node.to_object(py),))?;
+        res.extract(py)
+    };
+
+    let attrs = attr_callable(weight)?;
+    if attrs.is_empty() {
+        return Ok("".to_string());
+    }
+    let attr_string = attrs
+        .iter()
+        .map(|(key, value)| {
+            if ATTRS_TO_ESCAPE.contains(&key.as_str()) {
+                format!("{}=\"{}\"", key, value)
+            } else {
+                format!("{}={}", key, value)
+            }
+        })
+        .collect::<Vec<String>>()
+        .join(", ");
+    Ok(format!("[{}]", attr_string))
+}
diff --git a/crates/circuit/src/error.rs b/crates/circuit/src/error.rs
new file mode 100644
index 000000000000..b28e6b8f513b
--- /dev/null
+++ b/crates/circuit/src/error.rs
@@ -0,0 +1,16 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// 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.
+
+use pyo3::import_exception;
+
+import_exception!(qiskit.dagcircuit.exceptions, DAGCircuitError);
+import_exception!(qiskit.dagcircuit.exceptions, DAGDependencyError);
diff --git a/crates/circuit/src/imports.rs b/crates/circuit/src/imports.rs
index d9d439bb4745..588471546273 100644
--- a/crates/circuit/src/imports.rs
+++ b/crates/circuit/src/imports.rs
@@ -57,6 +57,7 @@ impl ImportOnceCell {
 }
 
 pub static BUILTIN_LIST: ImportOnceCell = ImportOnceCell::new("builtins", "list");
+pub static BUILTIN_SET: ImportOnceCell = ImportOnceCell::new("builtins", "set");
 pub static OPERATION: ImportOnceCell = ImportOnceCell::new("qiskit.circuit.operation", "Operation");
 pub static INSTRUCTION: ImportOnceCell =
     ImportOnceCell::new("qiskit.circuit.instruction", "Instruction");
@@ -65,6 +66,10 @@ pub static CONTROL_FLOW_OP: ImportOnceCell =
     ImportOnceCell::new("qiskit.circuit.controlflow", "ControlFlowOp");
 pub static QUBIT: ImportOnceCell = ImportOnceCell::new("qiskit.circuit.quantumregister", "Qubit");
 pub static CLBIT: ImportOnceCell = ImportOnceCell::new("qiskit.circuit.classicalregister", "Clbit");
+pub static QUANTUM_REGISTER: ImportOnceCell =
+    ImportOnceCell::new("qiskit.circuit.quantumregister", "QuantumRegister");
+pub static CLASSICAL_REGISTER: ImportOnceCell =
+    ImportOnceCell::new("qiskit.circuit.classicalregister", "ClassicalRegister");
 pub static PARAMETER_EXPRESSION: ImportOnceCell =
     ImportOnceCell::new("qiskit.circuit.parameterexpression", "ParameterExpression");
 pub static QUANTUM_CIRCUIT: ImportOnceCell =
@@ -73,6 +78,17 @@ pub static SINGLETON_GATE: ImportOnceCell =
     ImportOnceCell::new("qiskit.circuit.singleton", "SingletonGate");
 pub static SINGLETON_CONTROLLED_GATE: ImportOnceCell =
     ImportOnceCell::new("qiskit.circuit.singleton", "SingletonControlledGate");
+pub static VARIABLE_MAPPER: ImportOnceCell =
+    ImportOnceCell::new("qiskit.circuit._classical_resource_map", "VariableMapper");
+pub static IF_ELSE_OP: ImportOnceCell = ImportOnceCell::new("qiskit.circuit", "IfElseOp");
+pub static FOR_LOOP_OP: ImportOnceCell = ImportOnceCell::new("qiskit.circuit", "ForLoopOp");
+pub static SWITCH_CASE_OP: ImportOnceCell = ImportOnceCell::new("qiskit.circuit", "SwitchCaseOp");
+pub static WHILE_LOOP_OP: ImportOnceCell = ImportOnceCell::new("qiskit.circuit", "WhileLoopOp");
+pub static STORE_OP: ImportOnceCell = ImportOnceCell::new("qiskit.circuit", "Store");
+pub static EXPR: ImportOnceCell = ImportOnceCell::new("qiskit.circuit.classical.expr", "Expr");
+pub static ITER_VARS: ImportOnceCell =
+    ImportOnceCell::new("qiskit.circuit.classical.expr", "iter_vars");
+pub static DAG_NODE: ImportOnceCell = ImportOnceCell::new("qiskit.dagcircuit", "DAGNode");
 pub static CONTROLLED_GATE: ImportOnceCell =
     ImportOnceCell::new("qiskit.circuit", "ControlledGate");
 pub static ANNOTATED_OPERATION: ImportOnceCell =
@@ -80,6 +96,18 @@ pub static ANNOTATED_OPERATION: ImportOnceCell =
 pub static DEEPCOPY: ImportOnceCell = ImportOnceCell::new("copy", "deepcopy");
 pub static QI_OPERATOR: ImportOnceCell = ImportOnceCell::new("qiskit.quantum_info", "Operator");
 pub static WARNINGS_WARN: ImportOnceCell = ImportOnceCell::new("warnings", "warn");
+pub static CIRCUIT_TO_DAG: ImportOnceCell =
+    ImportOnceCell::new("qiskit.converters", "circuit_to_dag");
+pub static DAG_TO_CIRCUIT: ImportOnceCell =
+    ImportOnceCell::new("qiskit.converters", "dag_to_circuit");
+pub static LEGACY_CONDITION_CHECK: ImportOnceCell =
+    ImportOnceCell::new("qiskit.dagcircuit.dagnode", "_legacy_condition_eq");
+pub static CONDITION_OP_CHECK: ImportOnceCell =
+    ImportOnceCell::new("qiskit.dagcircuit.dagnode", "_condition_op_eq");
+pub static SWITCH_CASE_OP_CHECK: ImportOnceCell =
+    ImportOnceCell::new("qiskit.dagcircuit.dagnode", "_switch_case_eq");
+pub static FOR_LOOP_OP_CHECK: ImportOnceCell =
+    ImportOnceCell::new("qiskit.dagcircuit.dagnode", "_for_loop_eq");
 pub static UUID: ImportOnceCell = ImportOnceCell::new("uuid", "UUID");
 
 /// A mapping from the enum variant in crate::operations::StandardGate to the python
diff --git a/crates/circuit/src/interner.rs b/crates/circuit/src/interner.rs
index f22bb80ae052..e19f56e87a7d 100644
--- a/crates/circuit/src/interner.rs
+++ b/crates/circuit/src/interner.rs
@@ -17,39 +17,15 @@ use hashbrown::HashMap;
 use pyo3::exceptions::PyRuntimeError;
 use pyo3::prelude::*;
 
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub struct Index(u32);
 
-pub enum InternerKey<T> {
-    Index(Index),
-    Value(T),
-}
-
-impl<T> From<Index> for InternerKey<T> {
-    fn from(value: Index) -> Self {
-        InternerKey::Index(value)
-    }
-}
-
-pub struct InternerValue<'a, T> {
-    pub index: Index,
-    pub value: &'a T,
-}
-
 impl IntoPy<PyObject> for Index {
     fn into_py(self, py: Python<'_>) -> PyObject {
         self.0.into_py(py)
     }
 }
 
-pub struct CacheFullError;
-
-impl From<CacheFullError> for PyErr {
-    fn from(_: CacheFullError) -> Self {
-        PyRuntimeError::new_err("The bit operands cache is full!")
-    }
-}
-
 /// An append-only data structure for interning generic
 /// Rust types.
 #[derive(Clone, Debug)]
@@ -58,25 +34,20 @@ pub struct IndexedInterner<T> {
     index_lookup: HashMap<Arc<T>, Index>,
 }
 
-pub trait Interner<T> {
-    type Key;
+pub trait Interner<K> {
     type Output;
 
     /// Takes ownership of the provided key and returns the interned
     /// type.
-    fn intern(self, value: Self::Key) -> Self::Output;
+    fn intern(self, value: K) -> Self::Output;
 }
 
-impl<'a, T> Interner<T> for &'a IndexedInterner<T> {
-    type Key = Index;
-    type Output = InternerValue<'a, T>;
+impl<'a, T> Interner<Index> for &'a IndexedInterner<T> {
+    type Output = &'a T;
 
     fn intern(self, index: Index) -> Self::Output {
         let value = self.entries.get(index.0 as usize).unwrap();
-        InternerValue {
-            index,
-            value: value.as_ref(),
-        }
+        value.as_ref()
     }
 }
 
@@ -84,35 +55,19 @@ impl<'a, T> Interner<T> for &'a mut IndexedInterner<T>
 where
     T: Eq + Hash,
 {
-    type Key = InternerKey<T>;
-    type Output = Result<InternerValue<'a, T>, CacheFullError>;
-
-    fn intern(self, key: Self::Key) -> Self::Output {
-        match key {
-            InternerKey::Index(index) => {
-                let value = self.entries.get(index.0 as usize).unwrap();
-                Ok(InternerValue {
-                    index,
-                    value: value.as_ref(),
-                })
-            }
-            InternerKey::Value(value) => {
-                if let Some(index) = self.index_lookup.get(&value).copied() {
-                    Ok(InternerValue {
-                        index,
-                        value: self.entries.get(index.0 as usize).unwrap(),
-                    })
-                } else {
-                    let args = Arc::new(value);
-                    let index: Index =
-                        Index(self.entries.len().try_into().map_err(|_| CacheFullError)?);
-                    self.entries.push(args.clone());
-                    Ok(InternerValue {
-                        index,
-                        value: self.index_lookup.insert_unique_unchecked(args, index).0,
-                    })
-                }
-            }
+    type Output = PyResult<Index>;
+
+    fn intern(self, key: T) -> Self::Output {
+        if let Some(index) = self.index_lookup.get(&key).copied() {
+            Ok(index)
+        } else {
+            let args = Arc::new(key);
+            let index: Index = Index(self.entries.len().try_into().map_err(|_| {
+                PyRuntimeError::new_err("The interner has run out of indices (cache is full)!")
+            })?);
+            self.entries.push(args.clone());
+            self.index_lookup.insert_unique_unchecked(args, index);
+            Ok(index)
         }
     }
 }
diff --git a/crates/circuit/src/lib.rs b/crates/circuit/src/lib.rs
index 739bf998a611..4ca86c2ca83c 100644
--- a/crates/circuit/src/lib.rs
+++ b/crates/circuit/src/lib.rs
@@ -13,18 +13,23 @@
 pub mod bit_data;
 pub mod circuit_data;
 pub mod circuit_instruction;
+pub mod dag_circuit;
 pub mod dag_node;
+mod dot_utils;
+mod error;
 pub mod gate_matrix;
 pub mod imports;
+mod interner;
 pub mod operations;
 pub mod packed_instruction;
 pub mod parameter_table;
 pub mod slice;
 pub mod util;
 
-mod interner;
+mod rustworkx_core_vnext;
 
 use pyo3::prelude::*;
+use pyo3::types::{PySequence, PyTuple};
 
 pub type BitType = u32;
 #[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
@@ -32,6 +37,25 @@ pub struct Qubit(pub BitType);
 #[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
 pub struct Clbit(pub BitType);
 
+pub struct TupleLikeArg<'py> {
+    value: Bound<'py, PyTuple>,
+}
+
+impl<'py> FromPyObject<'py> for TupleLikeArg<'py> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
+        let value = match ob.downcast::<PySequence>() {
+            Ok(seq) => seq.to_tuple()?,
+            Err(_) => PyTuple::new_bound(
+                ob.py(),
+                ob.iter()?
+                    .map(|o| Ok(o?.unbind()))
+                    .collect::<PyResult<Vec<PyObject>>>()?,
+            ),
+        };
+        Ok(TupleLikeArg { value })
+    }
+}
+
 impl From<BitType> for Qubit {
     fn from(value: BitType) -> Self {
         Qubit(value)
@@ -58,11 +82,12 @@ impl From<Clbit> for BitType {
 
 pub fn circuit(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_class::<circuit_data::CircuitData>()?;
+    m.add_class::<circuit_instruction::CircuitInstruction>()?;
+    m.add_class::<dag_circuit::DAGCircuit>()?;
     m.add_class::<dag_node::DAGNode>()?;
     m.add_class::<dag_node::DAGInNode>()?;
     m.add_class::<dag_node::DAGOutNode>()?;
     m.add_class::<dag_node::DAGOpNode>()?;
-    m.add_class::<circuit_instruction::CircuitInstruction>()?;
     m.add_class::<operations::StandardGate>()?;
     Ok(())
 }
diff --git a/crates/circuit/src/operations.rs b/crates/circuit/src/operations.rs
index 7134662e1ac6..ccf41d7eefb2 100644
--- a/crates/circuit/src/operations.rs
+++ b/crates/circuit/src/operations.rs
@@ -10,6 +10,7 @@
 // copyright notice, and modified files need to carry a notice indicating
 // that they have been altered from the originals.
 
+use approx::relative_eq;
 use std::f64::consts::PI;
 
 use crate::circuit_data::CircuitData;
@@ -35,6 +36,29 @@ pub enum Param {
     Obj(PyObject),
 }
 
+impl Param {
+    pub fn eq(&self, py: Python, other: &Param) -> PyResult<bool> {
+        match [self, other] {
+            [Self::Float(a), Self::Float(b)] => Ok(a == b),
+            [Self::Float(a), Self::ParameterExpression(b)] => b.bind(py).eq(a),
+            [Self::ParameterExpression(a), Self::Float(b)] => a.bind(py).eq(b),
+            [Self::ParameterExpression(a), Self::ParameterExpression(b)] => a.bind(py).eq(b),
+            [Self::Obj(_), Self::Float(_)] => Ok(false),
+            [Self::Float(_), Self::Obj(_)] => Ok(false),
+            [Self::Obj(a), Self::ParameterExpression(b)] => a.bind(py).eq(b),
+            [Self::Obj(a), Self::Obj(b)] => a.bind(py).eq(b),
+            [Self::ParameterExpression(a), Self::Obj(b)] => a.bind(py).eq(b),
+        }
+    }
+
+    pub fn is_close(&self, py: Python, other: &Param, max_relative: f64) -> PyResult<bool> {
+        match [self, other] {
+            [Self::Float(a), Self::Float(b)] => Ok(relative_eq!(a, b, max_relative = max_relative)),
+            _ => self.eq(py, other),
+        }
+    }
+}
+
 impl<'py> FromPyObject<'py> for Param {
     fn extract_bound(b: &Bound<'py, PyAny>) -> Result<Self, PyErr> {
         Ok(if b.is_instance(PARAMETER_EXPRESSION.get_bound(b.py()))? {
@@ -131,6 +155,7 @@ pub trait Operation {
 /// `PackedInstruction::op`, and in turn is a view object onto a `PackedOperation`.
 ///
 /// This is the main way that we interact immutably with general circuit operations from Rust space.
+#[derive(Debug)]
 pub enum OperationRef<'a> {
     Standard(StandardGate),
     Gate(&'a PyGate),
diff --git a/crates/circuit/src/packed_instruction.rs b/crates/circuit/src/packed_instruction.rs
index 9c4f19aa1ba3..7619ecb9c525 100644
--- a/crates/circuit/src/packed_instruction.rs
+++ b/crates/circuit/src/packed_instruction.rs
@@ -16,13 +16,18 @@ use std::ptr::NonNull;
 
 use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::PyDict;
+use pyo3::types::{PyDict, PyType};
 
+use ndarray::Array2;
+use num_complex::Complex64;
 use smallvec::SmallVec;
 
+use crate::circuit_data::CircuitData;
 use crate::circuit_instruction::ExtraInstructionAttributes;
-use crate::imports::DEEPCOPY;
-use crate::operations::{OperationRef, Param, PyGate, PyInstruction, PyOperation, StandardGate};
+use crate::imports::{get_std_gate_class, DEEPCOPY};
+use crate::operations::{
+    Operation, OperationRef, Param, PyGate, PyInstruction, PyOperation, StandardGate,
+};
 
 /// The logical discriminant of `PackedOperation`.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -331,6 +336,78 @@ impl PackedOperation {
             .into()),
         }
     }
+
+    /// Whether the Python class that we would use to represent the inner `Operation` object in
+    /// Python space would be an instance of the given Python type.  This does not construct the
+    /// Python-space `Operator` instance if it can be avoided (i.e. for standard gates).
+    pub fn py_op_is_instance(&self, py_type: &Bound<PyType>) -> PyResult<bool> {
+        let py = py_type.py();
+        let py_op = match self.view() {
+            OperationRef::Standard(standard) => {
+                return get_std_gate_class(py, standard)?
+                    .bind(py)
+                    .downcast::<PyType>()?
+                    .is_subclass(py_type)
+            }
+            OperationRef::Gate(gate) => gate.gate.bind(py),
+            OperationRef::Instruction(instruction) => instruction.instruction.bind(py),
+            OperationRef::Operation(operation) => operation.operation.bind(py),
+        };
+        py_op.is_instance(py_type)
+    }
+}
+
+impl Operation for PackedOperation {
+    fn name(&self) -> &str {
+        let view = self.view();
+        let name = match view {
+            OperationRef::Standard(ref standard) => standard.name(),
+            OperationRef::Gate(gate) => gate.name(),
+            OperationRef::Instruction(instruction) => instruction.name(),
+            OperationRef::Operation(operation) => operation.name(),
+        };
+        // SAFETY: all of the inner parts of the view are owned by `self`, so it's valid for us to
+        // forcibly reborrowing up to our own lifetime. We avoid using `<OperationRef as Operation>`
+        // just to avoid a further _potential_ unsafeness, were its implementation to start doing
+        // something weird with the lifetimes.  `str::from_utf8_unchecked` and
+        // `slice::from_raw_parts` are both trivially safe because they're being called on immediate
+        // values from a validated `str`.
+        unsafe {
+            ::std::str::from_utf8_unchecked(::std::slice::from_raw_parts(name.as_ptr(), name.len()))
+        }
+    }
+    #[inline]
+    fn num_qubits(&self) -> u32 {
+        self.view().num_qubits()
+    }
+    #[inline]
+    fn num_clbits(&self) -> u32 {
+        self.view().num_clbits()
+    }
+    #[inline]
+    fn num_params(&self) -> u32 {
+        self.view().num_params()
+    }
+    #[inline]
+    fn control_flow(&self) -> bool {
+        self.view().control_flow()
+    }
+    #[inline]
+    fn matrix(&self, params: &[Param]) -> Option<Array2<Complex64>> {
+        self.view().matrix(params)
+    }
+    #[inline]
+    fn definition(&self, params: &[Param]) -> Option<CircuitData> {
+        self.view().definition(params)
+    }
+    #[inline]
+    fn standard_gate(&self) -> Option<StandardGate> {
+        self.view().standard_gate()
+    }
+    #[inline]
+    fn directive(&self) -> bool {
+        self.view().directive()
+    }
 }
 
 impl From<StandardGate> for PackedOperation {
@@ -435,15 +512,6 @@ pub struct PackedInstruction {
 }
 
 impl PackedInstruction {
-    /// Immutably view the contained operation.
-    ///
-    /// If you only care whether the contained operation is a `StandardGate` or not, you can use
-    /// `PackedInstruction::standard_gate`, which is a bit cheaper than this function.
-    #[inline]
-    pub fn op(&self) -> OperationRef {
-        self.op.view()
-    }
-
     /// Access the standard gate in this `PackedInstruction`, if it is one.  If the instruction
     /// refers to a Python-space object, `None` is returned.
     #[inline]
@@ -469,6 +537,20 @@ impl PackedInstruction {
             .unwrap_or(&mut [])
     }
 
+    /// Does this instruction contain any compile-time symbolic `ParameterExpression`s?
+    pub fn is_parameterized(&self) -> bool {
+        self.params_view()
+            .iter()
+            .any(|x| matches!(x, Param::ParameterExpression(_)))
+    }
+
+    #[inline]
+    pub fn condition(&self) -> Option<&Py<PyAny>> {
+        self.extra_attrs
+            .as_ref()
+            .and_then(|extra| extra.condition.as_ref())
+    }
+
     /// Build a reference to the Python-space operation object (the `Gate`, etc) packed into this
     /// instruction.  This may construct the reference if the `PackedInstruction` is a standard
     /// gate with no already stored operation.
@@ -510,4 +592,30 @@ impl PackedInstruction {
         }
         Ok(out)
     }
+
+    /// Check equality of the operation, including Python-space checks, if appropriate.
+    pub fn py_op_eq(&self, py: Python, other: &Self) -> PyResult<bool> {
+        match (self.op.view(), other.op.view()) {
+            (OperationRef::Standard(left), OperationRef::Standard(right)) => Ok(left == right),
+            (OperationRef::Gate(left), OperationRef::Gate(right)) => {
+                left.gate.bind(py).eq(&right.gate)
+            }
+            (OperationRef::Instruction(left), OperationRef::Instruction(right)) => {
+                left.instruction.bind(py).eq(&right.instruction)
+            }
+            (OperationRef::Operation(left), OperationRef::Operation(right)) => {
+                left.operation.bind(py).eq(&right.operation)
+            }
+            // Handle the case we end up with a pygate for a standard gate
+            // this typically only happens if it's a ControlledGate in python
+            // and we have mutable state set.
+            (OperationRef::Standard(_left), OperationRef::Gate(right)) => {
+                self.unpack_py_op(py)?.bind(py).eq(&right.gate)
+            }
+            (OperationRef::Gate(left), OperationRef::Standard(_right)) => {
+                other.unpack_py_op(py)?.bind(py).eq(&left.gate)
+            }
+            _ => Ok(false),
+        }
+    }
 }
diff --git a/crates/circuit/src/rustworkx_core_vnext.rs b/crates/circuit/src/rustworkx_core_vnext.rs
new file mode 100644
index 000000000000..e69ee88a93e7
--- /dev/null
+++ b/crates/circuit/src/rustworkx_core_vnext.rs
@@ -0,0 +1,1417 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// 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.
+
+// TODO: delete once we move to a version of Rustworkx which includes
+//   this implementation as part of rustworkx-core.
+//   PR: https://github.com/Qiskit/rustworkx/pull/1235
+pub mod isomorphism {
+    pub mod vf2 {
+        #![allow(clippy::too_many_arguments)]
+        // This module was originally forked from petgraph's isomorphism module @ v0.5.0
+        // to handle PyDiGraph inputs instead of petgraph's generic Graph. However it has
+        // since diverged significantly from the original petgraph implementation.
+
+        use std::cmp::{Ordering, Reverse};
+        use std::convert::Infallible;
+        use std::error::Error;
+        use std::fmt::{Debug, Display, Formatter};
+        use std::iter::Iterator;
+        use std::marker;
+        use std::ops::Deref;
+
+        use hashbrown::HashMap;
+        use rustworkx_core::dictmap::*;
+
+        use rustworkx_core::petgraph::data::{Build, Create, DataMap};
+        use rustworkx_core::petgraph::stable_graph::NodeIndex;
+        use rustworkx_core::petgraph::visit::{
+            Data, EdgeCount, EdgeRef, GraphBase, GraphProp, IntoEdgeReferences, IntoEdges,
+            IntoEdgesDirected, IntoNeighbors, IntoNeighborsDirected, IntoNodeIdentifiers,
+            NodeCount, NodeIndexable,
+        };
+        use rustworkx_core::petgraph::{Directed, Incoming, Outgoing};
+
+        use rayon::slice::ParallelSliceMut;
+
+        /// Returns `true` if we can map every element of `xs` to a unique
+        /// element of `ys` while using `matcher` func to compare two elements.
+        fn is_subset<T1: Copy, T2: Copy, F, E>(
+            xs: &[T1],
+            ys: &[T2],
+            matcher: &mut F,
+        ) -> Result<bool, E>
+        where
+            F: FnMut(T1, T2) -> Result<bool, E>,
+        {
+            let mut valid = vec![true; ys.len()];
+            for &a in xs {
+                let mut found = false;
+                for (&b, free) in ys.iter().zip(valid.iter_mut()) {
+                    if *free && matcher(a, b)? {
+                        found = true;
+                        *free = false;
+                        break;
+                    }
+                }
+
+                if !found {
+                    return Ok(false);
+                }
+            }
+
+            Ok(true)
+        }
+
+        #[inline]
+        fn sorted<N: std::cmp::PartialOrd>(x: &mut (N, N)) {
+            let (a, b) = x;
+            if b < a {
+                std::mem::swap(a, b)
+            }
+        }
+
+        /// Returns the adjacency matrix of a graph as a dictionary
+        /// with `(i, j)` entry equal to number of edges from node `i` to node `j`.
+        fn adjacency_matrix<G>(graph: G) -> HashMap<(NodeIndex, NodeIndex), usize>
+        where
+            G: GraphProp + GraphBase<NodeId = NodeIndex> + EdgeCount + IntoEdgeReferences,
+        {
+            let mut matrix = HashMap::with_capacity(graph.edge_count());
+            for edge in graph.edge_references() {
+                let mut item = (edge.source(), edge.target());
+                if !graph.is_directed() {
+                    sorted(&mut item);
+                }
+                let entry = matrix.entry(item).or_insert(0);
+                *entry += 1;
+            }
+            matrix
+        }
+
+        /// Returns the number of edges from node `a` to node `b`.
+        fn edge_multiplicity<G>(
+            graph: &G,
+            matrix: &HashMap<(NodeIndex, NodeIndex), usize>,
+            a: NodeIndex,
+            b: NodeIndex,
+        ) -> usize
+        where
+            G: GraphProp + GraphBase<NodeId = NodeIndex>,
+        {
+            let mut item = (a, b);
+            if !graph.is_directed() {
+                sorted(&mut item);
+            }
+            *matrix.get(&item).unwrap_or(&0)
+        }
+
+        /// Nodes `a`, `b` are adjacent if the number of edges
+        /// from node `a` to node `b` is greater than `val`.
+        fn is_adjacent<G>(
+            graph: &G,
+            matrix: &HashMap<(NodeIndex, NodeIndex), usize>,
+            a: NodeIndex,
+            b: NodeIndex,
+            val: usize,
+        ) -> bool
+        where
+            G: GraphProp + GraphBase<NodeId = NodeIndex>,
+        {
+            edge_multiplicity(graph, matrix, a, b) >= val
+        }
+
+        trait NodeSorter<G>
+        where
+            G: GraphBase<NodeId = NodeIndex> + DataMap + NodeCount + EdgeCount + IntoEdgeReferences,
+            G::NodeWeight: Clone,
+            G::EdgeWeight: Clone,
+        {
+            type OutputGraph: GraphBase<NodeId = NodeIndex>
+                + Create
+                + Data<NodeWeight = G::NodeWeight, EdgeWeight = G::EdgeWeight>;
+
+            fn sort(&self, _: G) -> Vec<NodeIndex>;
+
+            fn reorder(&self, graph: G) -> (Self::OutputGraph, HashMap<usize, usize>) {
+                let order = self.sort(graph);
+
+                let mut new_graph =
+                    Self::OutputGraph::with_capacity(graph.node_count(), graph.edge_count());
+                let mut id_map: HashMap<NodeIndex, NodeIndex> =
+                    HashMap::with_capacity(graph.node_count());
+                for node_index in order {
+                    let node_data = graph.node_weight(node_index).unwrap();
+                    let new_index = new_graph.add_node(node_data.clone());
+                    id_map.insert(node_index, new_index);
+                }
+                for edge in graph.edge_references() {
+                    let edge_w = edge.weight();
+                    let p_index = id_map[&edge.source()];
+                    let c_index = id_map[&edge.target()];
+                    new_graph.add_edge(p_index, c_index, edge_w.clone());
+                }
+                (
+                    new_graph,
+                    id_map.iter().map(|(k, v)| (v.index(), k.index())).collect(),
+                )
+            }
+        }
+
+        /// Sort nodes based on node ids.
+        struct DefaultIdSorter {}
+
+        impl DefaultIdSorter {
+            pub fn new() -> Self {
+                Self {}
+            }
+        }
+
+        impl<G> NodeSorter<G> for DefaultIdSorter
+        where
+            G: Deref
+                + GraphBase<NodeId = NodeIndex>
+                + DataMap
+                + NodeCount
+                + EdgeCount
+                + IntoEdgeReferences
+                + IntoNodeIdentifiers,
+            G::Target: GraphBase<NodeId = NodeIndex>
+                + Data<NodeWeight = G::NodeWeight, EdgeWeight = G::EdgeWeight>
+                + Create,
+            G::NodeWeight: Clone,
+            G::EdgeWeight: Clone,
+        {
+            type OutputGraph = G::Target;
+            fn sort(&self, graph: G) -> Vec<NodeIndex> {
+                graph.node_identifiers().collect()
+            }
+        }
+
+        /// Sort nodes based on VF2++ heuristic.
+        struct Vf2ppSorter {}
+
+        impl Vf2ppSorter {
+            pub fn new() -> Self {
+                Self {}
+            }
+        }
+
+        impl<G> NodeSorter<G> for Vf2ppSorter
+        where
+            G: Deref
+                + GraphProp
+                + GraphBase<NodeId = NodeIndex>
+                + DataMap
+                + NodeCount
+                + NodeIndexable
+                + EdgeCount
+                + IntoNodeIdentifiers
+                + IntoEdgesDirected,
+            G::Target: GraphBase<NodeId = NodeIndex>
+                + Data<NodeWeight = G::NodeWeight, EdgeWeight = G::EdgeWeight>
+                + Create,
+            G::NodeWeight: Clone,
+            G::EdgeWeight: Clone,
+        {
+            type OutputGraph = G::Target;
+            fn sort(&self, graph: G) -> Vec<NodeIndex> {
+                let n = graph.node_bound();
+
+                let dout: Vec<usize> = (0..n)
+                    .map(|idx| {
+                        graph
+                            .neighbors_directed(graph.from_index(idx), Outgoing)
+                            .count()
+                    })
+                    .collect();
+
+                let mut din: Vec<usize> = vec![0; n];
+                if graph.is_directed() {
+                    din = (0..n)
+                        .map(|idx| {
+                            graph
+                                .neighbors_directed(graph.from_index(idx), Incoming)
+                                .count()
+                        })
+                        .collect();
+                }
+
+                let mut conn_in: Vec<usize> = vec![0; n];
+                let mut conn_out: Vec<usize> = vec![0; n];
+
+                let mut order: Vec<NodeIndex> = Vec::with_capacity(n);
+
+                // Process BFS level
+                let mut process = |mut vd: Vec<usize>| -> Vec<usize> {
+                    // repeatedly bring largest element in front.
+                    for i in 0..vd.len() {
+                        let (index, &item) = vd[i..]
+                            .iter()
+                            .enumerate()
+                            .max_by_key(|&(_, &node)| {
+                                (
+                                    conn_in[node],
+                                    dout[node],
+                                    conn_out[node],
+                                    din[node],
+                                    Reverse(node),
+                                )
+                            })
+                            .unwrap();
+
+                        vd.swap(i, i + index);
+                        order.push(NodeIndex::new(item));
+
+                        for neigh in graph.neighbors_directed(graph.from_index(item), Outgoing) {
+                            conn_in[graph.to_index(neigh)] += 1;
+                        }
+
+                        if graph.is_directed() {
+                            for neigh in graph.neighbors_directed(graph.from_index(item), Incoming)
+                            {
+                                conn_out[graph.to_index(neigh)] += 1;
+                            }
+                        }
+                    }
+                    vd
+                };
+
+                let mut seen: Vec<bool> = vec![false; n];
+
+                // Create BFS Tree from root and process each level.
+                let mut bfs_tree = |root: usize| {
+                    if seen[root] {
+                        return;
+                    }
+
+                    let mut next_level: Vec<usize> = Vec::new();
+
+                    seen[root] = true;
+                    next_level.push(root);
+                    while !next_level.is_empty() {
+                        let this_level = next_level;
+                        let this_level = process(this_level);
+
+                        next_level = Vec::new();
+                        for bfs_node in this_level {
+                            for neighbor in
+                                graph.neighbors_directed(graph.from_index(bfs_node), Outgoing)
+                            {
+                                let neigh = graph.to_index(neighbor);
+                                if !seen[neigh] {
+                                    seen[neigh] = true;
+                                    next_level.push(neigh);
+                                }
+                            }
+                        }
+                    }
+                };
+
+                let mut sorted_nodes: Vec<usize> =
+                    graph.node_identifiers().map(|node| node.index()).collect();
+                sorted_nodes.par_sort_by_key(|&node| (dout[node], din[node], Reverse(node)));
+                sorted_nodes.reverse();
+
+                for node in sorted_nodes {
+                    bfs_tree(node);
+                }
+
+                order
+            }
+        }
+
+        #[derive(Debug)]
+        pub struct Vf2State<G> {
+            pub graph: G,
+            /// The current mapping M(s) of nodes from G0 → G1 and G1 → G0,
+            /// NodeIndex::end() for no mapping.
+            mapping: Vec<NodeIndex>,
+            /// out[i] is non-zero if i is in either M_0(s) or Tout_0(s)
+            /// These are all the next vertices that are not mapped yet, but
+            /// have an outgoing edge from the mapping.
+            out: Vec<usize>,
+            /// ins[i] is non-zero if i is in either M_0(s) or Tin_0(s)
+            /// These are all the incoming vertices, those not mapped yet, but
+            /// have an edge from them into the mapping.
+            /// Unused if graph is undirected -- it's identical with out in that case.
+            ins: Vec<usize>,
+            out_size: usize,
+            ins_size: usize,
+            adjacency_matrix: HashMap<(NodeIndex, NodeIndex), usize>,
+            generation: usize,
+            _etype: marker::PhantomData<Directed>,
+        }
+
+        impl<G> Vf2State<G>
+        where
+            G: GraphBase<NodeId = NodeIndex> + GraphProp + NodeCount + EdgeCount,
+            for<'a> &'a G: GraphBase<NodeId = NodeIndex>
+                + GraphProp
+                + NodeCount
+                + EdgeCount
+                + IntoEdgesDirected,
+        {
+            pub fn new(graph: G) -> Self {
+                let c0 = graph.node_count();
+                let is_directed = graph.is_directed();
+                let adjacency_matrix = adjacency_matrix(&graph);
+                Vf2State {
+                    graph,
+                    mapping: vec![NodeIndex::end(); c0],
+                    out: vec![0; c0],
+                    ins: vec![0; c0 * (is_directed as usize)],
+                    out_size: 0,
+                    ins_size: 0,
+                    adjacency_matrix,
+                    generation: 0,
+                    _etype: marker::PhantomData,
+                }
+            }
+
+            /// Return **true** if we have a complete mapping
+            pub fn is_complete(&self) -> bool {
+                self.generation == self.mapping.len()
+            }
+
+            /// Add mapping **from** <-> **to** to the state.
+            pub fn push_mapping(&mut self, from: NodeIndex, to: NodeIndex) {
+                self.generation += 1;
+                let s = self.generation;
+                self.mapping[from.index()] = to;
+                // update T0 & T1 ins/outs
+                // T0out: Node in G0 not in M0 but successor of a node in M0.
+                // st.out[0]: Node either in M0 or successor of M0
+                for ix in self.graph.neighbors(from) {
+                    if self.out[ix.index()] == 0 {
+                        self.out[ix.index()] = s;
+                        self.out_size += 1;
+                    }
+                }
+                if self.graph.is_directed() {
+                    for ix in self.graph.neighbors_directed(from, Incoming) {
+                        if self.ins[ix.index()] == 0 {
+                            self.ins[ix.index()] = s;
+                            self.ins_size += 1;
+                        }
+                    }
+                }
+            }
+
+            /// Restore the state to before the last added mapping
+            pub fn pop_mapping(&mut self, from: NodeIndex) {
+                let s = self.generation;
+                self.generation -= 1;
+
+                // undo (n, m) mapping
+                self.mapping[from.index()] = NodeIndex::end();
+
+                // unmark in ins and outs
+                for ix in self.graph.neighbors(from) {
+                    if self.out[ix.index()] == s {
+                        self.out[ix.index()] = 0;
+                        self.out_size -= 1;
+                    }
+                }
+                if self.graph.is_directed() {
+                    for ix in self.graph.neighbors_directed(from, Incoming) {
+                        if self.ins[ix.index()] == s {
+                            self.ins[ix.index()] = 0;
+                            self.ins_size -= 1;
+                        }
+                    }
+                }
+            }
+
+            /// Find the next (least) node in the Tout set.
+            pub fn next_out_index(&self, from_index: usize) -> Option<usize> {
+                self.out[from_index..]
+                    .iter()
+                    .enumerate()
+                    .find(move |&(index, elt)| {
+                        *elt > 0 && self.mapping[from_index + index] == NodeIndex::end()
+                    })
+                    .map(|(index, _)| index)
+            }
+
+            /// Find the next (least) node in the Tin set.
+            pub fn next_in_index(&self, from_index: usize) -> Option<usize> {
+                self.ins[from_index..]
+                    .iter()
+                    .enumerate()
+                    .find(move |&(index, elt)| {
+                        *elt > 0 && self.mapping[from_index + index] == NodeIndex::end()
+                    })
+                    .map(|(index, _)| index)
+            }
+
+            /// Find the next (least) node in the N - M set.
+            pub fn next_rest_index(&self, from_index: usize) -> Option<usize> {
+                self.mapping[from_index..]
+                    .iter()
+                    .enumerate()
+                    .find(|&(_, elt)| *elt == NodeIndex::end())
+                    .map(|(index, _)| index)
+            }
+        }
+
+        #[derive(Debug)]
+        pub enum IsIsomorphicError<NME, EME> {
+            NodeMatcherErr(NME),
+            EdgeMatcherErr(EME),
+        }
+
+        impl<NME: Error, EME: Error> Display for IsIsomorphicError<NME, EME> {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                match self {
+                    IsIsomorphicError::NodeMatcherErr(e) => {
+                        write!(f, "Node match callback failed with: {}", e)
+                    }
+                    IsIsomorphicError::EdgeMatcherErr(e) => {
+                        write!(f, "Edge match callback failed with: {}", e)
+                    }
+                }
+            }
+        }
+
+        impl<NME: Error, EME: Error> Error for IsIsomorphicError<NME, EME> {}
+
+        pub struct NoSemanticMatch;
+
+        pub trait NodeMatcher<G0: GraphBase, G1: GraphBase> {
+            type Error;
+            fn enabled(&self) -> bool;
+            fn eq(
+                &mut self,
+                _g0: &G0,
+                _g1: &G1,
+                _n0: G0::NodeId,
+                _n1: G1::NodeId,
+            ) -> Result<bool, Self::Error>;
+        }
+
+        impl<G0: GraphBase, G1: GraphBase> NodeMatcher<G0, G1> for NoSemanticMatch {
+            type Error = Infallible;
+            #[inline]
+            fn enabled(&self) -> bool {
+                false
+            }
+            #[inline]
+            fn eq(
+                &mut self,
+                _g0: &G0,
+                _g1: &G1,
+                _n0: G0::NodeId,
+                _n1: G1::NodeId,
+            ) -> Result<bool, Self::Error> {
+                Ok(true)
+            }
+        }
+
+        impl<G0, G1, F, E> NodeMatcher<G0, G1> for F
+        where
+            G0: GraphBase + DataMap,
+            G1: GraphBase + DataMap,
+            F: FnMut(&G0::NodeWeight, &G1::NodeWeight) -> Result<bool, E>,
+        {
+            type Error = E;
+            #[inline]
+            fn enabled(&self) -> bool {
+                true
+            }
+            #[inline]
+            fn eq(
+                &mut self,
+                g0: &G0,
+                g1: &G1,
+                n0: G0::NodeId,
+                n1: G1::NodeId,
+            ) -> Result<bool, Self::Error> {
+                if let (Some(x), Some(y)) = (g0.node_weight(n0), g1.node_weight(n1)) {
+                    self(x, y)
+                } else {
+                    Ok(false)
+                }
+            }
+        }
+
+        pub trait EdgeMatcher<G0: GraphBase, G1: GraphBase> {
+            type Error;
+            fn enabled(&self) -> bool;
+            fn eq(
+                &mut self,
+                _g0: &G0,
+                _g1: &G1,
+                e0: G0::EdgeId,
+                e1: G1::EdgeId,
+            ) -> Result<bool, Self::Error>;
+        }
+
+        impl<G0: GraphBase, G1: GraphBase> EdgeMatcher<G0, G1> for NoSemanticMatch {
+            type Error = Infallible;
+            #[inline]
+            fn enabled(&self) -> bool {
+                false
+            }
+            #[inline]
+            fn eq(
+                &mut self,
+                _g0: &G0,
+                _g1: &G1,
+                _e0: G0::EdgeId,
+                _e1: G1::EdgeId,
+            ) -> Result<bool, Self::Error> {
+                Ok(true)
+            }
+        }
+
+        impl<G0, G1, F, E> EdgeMatcher<G0, G1> for F
+        where
+            G0: GraphBase + DataMap,
+            G1: GraphBase + DataMap,
+            F: FnMut(&G0::EdgeWeight, &G1::EdgeWeight) -> Result<bool, E>,
+        {
+            type Error = E;
+            #[inline]
+            fn enabled(&self) -> bool {
+                true
+            }
+            #[inline]
+            fn eq(
+                &mut self,
+                g0: &G0,
+                g1: &G1,
+                e0: G0::EdgeId,
+                e1: G1::EdgeId,
+            ) -> Result<bool, Self::Error> {
+                if let (Some(x), Some(y)) = (g0.edge_weight(e0), g1.edge_weight(e1)) {
+                    self(x, y)
+                } else {
+                    Ok(false)
+                }
+            }
+        }
+
+        /// [Graph] Return `true` if the graphs `g0` and `g1` are (sub) graph isomorphic.
+        ///
+        /// Using the VF2 algorithm, examining both syntactic and semantic
+        /// graph isomorphism (graph structure and matching node and edge weights).
+        ///
+        /// The graphs should not be multigraphs.
+        pub fn is_isomorphic<G0, G1, NM, EM>(
+            g0: &G0,
+            g1: &G1,
+            node_match: NM,
+            edge_match: EM,
+            id_order: bool,
+            ordering: Ordering,
+            induced: bool,
+            call_limit: Option<usize>,
+        ) -> Result<bool, IsIsomorphicError<NM::Error, EM::Error>>
+        where
+            G0: GraphProp
+                + GraphBase<NodeId = NodeIndex>
+                + DataMap
+                + Create
+                + NodeCount
+                + EdgeCount,
+            for<'a> &'a G0: GraphBase<NodeId = G0::NodeId, EdgeId = G0::EdgeId>
+                + Data<NodeWeight = G0::NodeWeight, EdgeWeight = G0::EdgeWeight>
+                + NodeIndexable
+                + IntoEdgesDirected
+                + IntoNodeIdentifiers,
+            G0::NodeWeight: Clone,
+            G0::EdgeWeight: Clone,
+            G1: GraphProp
+                + GraphBase<NodeId = NodeIndex>
+                + DataMap
+                + Create
+                + NodeCount
+                + EdgeCount,
+            for<'a> &'a G1: GraphBase<NodeId = G1::NodeId, EdgeId = G1::EdgeId>
+                + Data<NodeWeight = G1::NodeWeight, EdgeWeight = G1::EdgeWeight>
+                + NodeIndexable
+                + IntoEdgesDirected
+                + IntoNodeIdentifiers,
+            G1::NodeWeight: Clone,
+            G1::EdgeWeight: Clone,
+            NM: NodeMatcher<G0, G1>,
+            EM: EdgeMatcher<G0, G1>,
+        {
+            if (g0.node_count().cmp(&g1.node_count()).then(ordering) != ordering)
+                || (g0.edge_count().cmp(&g1.edge_count()).then(ordering) != ordering)
+            {
+                return Ok(false);
+            }
+
+            let mut vf2 = Vf2Algorithm::new(
+                g0, g1, node_match, edge_match, id_order, ordering, induced, call_limit,
+            );
+
+            match vf2.next() {
+                Some(Ok(_)) => Ok(true),
+                Some(Err(e)) => Err(e),
+                None => Ok(false),
+            }
+        }
+
+        #[derive(Copy, Clone, PartialEq, Debug)]
+        enum OpenList {
+            Out,
+            In,
+            Other,
+        }
+
+        #[derive(Clone, PartialEq, Debug)]
+        enum Frame<N: marker::Copy> {
+            Outer,
+            Inner { nodes: [N; 2], open_list: OpenList },
+            Unwind { nodes: [N; 2], open_list: OpenList },
+        }
+
+        /// An iterator which uses the VF2(++) algorithm to produce isomorphic matches
+        /// between two graphs, examining both syntactic and semantic graph isomorphism
+        /// (graph structure and matching node and edge weights).
+        ///
+        /// The graphs should not be multigraphs.
+        pub struct Vf2Algorithm<G0, G1, NM, EM>
+        where
+            G0: GraphBase + Data,
+            G1: GraphBase + Data,
+            NM: NodeMatcher<G0, G1>,
+            EM: EdgeMatcher<G0, G1>,
+        {
+            pub st: (Vf2State<G0>, Vf2State<G1>),
+            pub node_match: NM,
+            pub edge_match: EM,
+            ordering: Ordering,
+            induced: bool,
+            node_map_g0: HashMap<usize, usize>,
+            node_map_g1: HashMap<usize, usize>,
+            stack: Vec<Frame<NodeIndex>>,
+            call_limit: Option<usize>,
+            _counter: usize,
+        }
+
+        impl<G0, G1, NM, EM> Vf2Algorithm<G0, G1, NM, EM>
+        where
+            G0: GraphProp
+                + GraphBase<NodeId = NodeIndex>
+                + DataMap
+                + Create
+                + NodeCount
+                + EdgeCount,
+            for<'a> &'a G0: GraphBase<NodeId = G0::NodeId, EdgeId = G0::EdgeId>
+                + Data<NodeWeight = G0::NodeWeight, EdgeWeight = G0::EdgeWeight>
+                + NodeIndexable
+                + IntoEdgesDirected
+                + IntoNodeIdentifiers,
+            G0::NodeWeight: Clone,
+            G0::EdgeWeight: Clone,
+            G1: GraphProp
+                + GraphBase<NodeId = NodeIndex>
+                + DataMap
+                + Create
+                + NodeCount
+                + EdgeCount,
+            for<'a> &'a G1: GraphBase<NodeId = G1::NodeId, EdgeId = G1::EdgeId>
+                + Data<NodeWeight = G1::NodeWeight, EdgeWeight = G1::EdgeWeight>
+                + NodeIndexable
+                + IntoEdgesDirected
+                + IntoNodeIdentifiers,
+            G1::NodeWeight: Clone,
+            G1::EdgeWeight: Clone,
+            NM: NodeMatcher<G0, G1>,
+            EM: EdgeMatcher<G0, G1>,
+        {
+            pub fn new(
+                g0: &G0,
+                g1: &G1,
+                node_match: NM,
+                edge_match: EM,
+                id_order: bool,
+                ordering: Ordering,
+                induced: bool,
+                call_limit: Option<usize>,
+            ) -> Self {
+                let (g0, node_map_g0) = if id_order {
+                    DefaultIdSorter::new().reorder(g0)
+                } else {
+                    Vf2ppSorter::new().reorder(g0)
+                };
+
+                let (g1, node_map_g1) = if id_order {
+                    DefaultIdSorter::new().reorder(g1)
+                } else {
+                    Vf2ppSorter::new().reorder(g1)
+                };
+
+                let st = (Vf2State::new(g0), Vf2State::new(g1));
+                Vf2Algorithm {
+                    st,
+                    node_match,
+                    edge_match,
+                    ordering,
+                    induced,
+                    node_map_g0,
+                    node_map_g1,
+                    stack: vec![Frame::Outer],
+                    call_limit,
+                    _counter: 0,
+                }
+            }
+
+            fn mapping(&self) -> DictMap<usize, usize> {
+                let mut mapping: DictMap<usize, usize> = DictMap::new();
+                self.st
+                    .1
+                    .mapping
+                    .iter()
+                    .enumerate()
+                    .for_each(|(index, val)| {
+                        mapping.insert(self.node_map_g0[&val.index()], self.node_map_g1[&index]);
+                    });
+
+                mapping
+            }
+
+            fn next_candidate(
+                st: &mut (Vf2State<G0>, Vf2State<G1>),
+            ) -> Option<(NodeIndex, NodeIndex, OpenList)> {
+                // Try the out list
+                let mut to_index = st.1.next_out_index(0);
+                let mut from_index = None;
+                let mut open_list = OpenList::Out;
+
+                if to_index.is_some() {
+                    from_index = st.0.next_out_index(0);
+                    open_list = OpenList::Out;
+                }
+                // Try the in list
+                if to_index.is_none() || from_index.is_none() {
+                    to_index = st.1.next_in_index(0);
+
+                    if to_index.is_some() {
+                        from_index = st.0.next_in_index(0);
+                        open_list = OpenList::In;
+                    }
+                }
+                // Try the other list -- disconnected graph
+                if to_index.is_none() || from_index.is_none() {
+                    to_index = st.1.next_rest_index(0);
+                    if to_index.is_some() {
+                        from_index = st.0.next_rest_index(0);
+                        open_list = OpenList::Other;
+                    }
+                }
+                match (from_index, to_index) {
+                    (Some(n), Some(m)) => Some((NodeIndex::new(n), NodeIndex::new(m), open_list)),
+                    // No more candidates
+                    _ => None,
+                }
+            }
+
+            fn next_from_ix(
+                st: &mut (Vf2State<G0>, Vf2State<G1>),
+                nx: NodeIndex,
+                open_list: OpenList,
+            ) -> Option<NodeIndex> {
+                // Find the next node index to try on the `from` side of the mapping
+                let start = nx.index() + 1;
+                let cand0 = match open_list {
+                    OpenList::Out => st.0.next_out_index(start),
+                    OpenList::In => st.0.next_in_index(start),
+                    OpenList::Other => st.0.next_rest_index(start),
+                }
+                .map(|c| c + start); // compensate for start offset.
+                match cand0 {
+                    None => None, // no more candidates
+                    Some(ix) => {
+                        debug_assert!(ix >= start);
+                        Some(NodeIndex::new(ix))
+                    }
+                }
+            }
+
+            fn pop_state(st: &mut (Vf2State<G0>, Vf2State<G1>), nodes: [NodeIndex; 2]) {
+                // Restore state.
+                st.0.pop_mapping(nodes[0]);
+                st.1.pop_mapping(nodes[1]);
+            }
+
+            fn push_state(st: &mut (Vf2State<G0>, Vf2State<G1>), nodes: [NodeIndex; 2]) {
+                // Add mapping nx <-> mx to the state
+                st.0.push_mapping(nodes[0], nodes[1]);
+                st.1.push_mapping(nodes[1], nodes[0]);
+            }
+
+            fn is_feasible(
+                st: &mut (Vf2State<G0>, Vf2State<G1>),
+                nodes: [NodeIndex; 2],
+                node_match: &mut NM,
+                edge_match: &mut EM,
+                ordering: Ordering,
+                induced: bool,
+            ) -> Result<bool, IsIsomorphicError<NM::Error, EM::Error>> {
+                // Check syntactic feasibility of mapping by ensuring adjacencies
+                // of nx map to adjacencies of mx.
+                //
+                // nx == map to => mx
+                //
+                // R_succ
+                //
+                // Check that every neighbor of nx is mapped to a neighbor of mx,
+                // then check the reverse, from mx to nx. Check that they have the same
+                // count of edges.
+                //
+                // Note: We want to check the lookahead measures here if we can,
+                // R_out: Equal for G0, G1: Card(Succ(G, n) ^ Tout); for both Succ and Pred
+                // R_in: Same with Tin
+                // R_new: Equal for G0, G1: Ñ n Pred(G, n); both Succ and Pred,
+                //      Ñ is G0 - M - Tin - Tout
+                let end = NodeIndex::end();
+                let mut succ_count = [0, 0];
+                for n_neigh in st.0.graph.neighbors(nodes[0]) {
+                    succ_count[0] += 1;
+                    if !induced {
+                        continue;
+                    }
+                    // handle the self loop case; it's not in the mapping (yet)
+                    let m_neigh = if nodes[0] != n_neigh {
+                        st.0.mapping[n_neigh.index()]
+                    } else {
+                        nodes[1]
+                    };
+                    if m_neigh == end {
+                        continue;
+                    }
+                    let val =
+                        edge_multiplicity(&st.0.graph, &st.0.adjacency_matrix, nodes[0], n_neigh);
+
+                    let has_edge =
+                        is_adjacent(&st.1.graph, &st.1.adjacency_matrix, nodes[1], m_neigh, val);
+                    if !has_edge {
+                        return Ok(false);
+                    }
+                }
+
+                for n_neigh in st.1.graph.neighbors(nodes[1]) {
+                    succ_count[1] += 1;
+                    // handle the self loop case; it's not in the mapping (yet)
+                    let m_neigh = if nodes[1] != n_neigh {
+                        st.1.mapping[n_neigh.index()]
+                    } else {
+                        nodes[0]
+                    };
+                    if m_neigh == end {
+                        continue;
+                    }
+                    let val =
+                        edge_multiplicity(&st.1.graph, &st.1.adjacency_matrix, nodes[1], n_neigh);
+
+                    let has_edge =
+                        is_adjacent(&st.0.graph, &st.0.adjacency_matrix, nodes[0], m_neigh, val);
+                    if !has_edge {
+                        return Ok(false);
+                    }
+                }
+                if succ_count[0].cmp(&succ_count[1]).then(ordering) != ordering {
+                    return Ok(false);
+                }
+                // R_pred
+                if st.0.graph.is_directed() {
+                    let mut pred_count = [0, 0];
+                    for n_neigh in st.0.graph.neighbors_directed(nodes[0], Incoming) {
+                        pred_count[0] += 1;
+                        if !induced {
+                            continue;
+                        }
+                        // the self loop case is handled in outgoing
+                        let m_neigh = st.0.mapping[n_neigh.index()];
+                        if m_neigh == end {
+                            continue;
+                        }
+                        let val = edge_multiplicity(
+                            &st.0.graph,
+                            &st.0.adjacency_matrix,
+                            n_neigh,
+                            nodes[0],
+                        );
+
+                        let has_edge = is_adjacent(
+                            &st.1.graph,
+                            &st.1.adjacency_matrix,
+                            m_neigh,
+                            nodes[1],
+                            val,
+                        );
+                        if !has_edge {
+                            return Ok(false);
+                        }
+                    }
+
+                    for n_neigh in st.1.graph.neighbors_directed(nodes[1], Incoming) {
+                        pred_count[1] += 1;
+                        // the self loop case is handled in outgoing
+                        let m_neigh = st.1.mapping[n_neigh.index()];
+                        if m_neigh == end {
+                            continue;
+                        }
+                        let val = edge_multiplicity(
+                            &st.1.graph,
+                            &st.1.adjacency_matrix,
+                            n_neigh,
+                            nodes[1],
+                        );
+
+                        let has_edge = is_adjacent(
+                            &st.0.graph,
+                            &st.0.adjacency_matrix,
+                            m_neigh,
+                            nodes[0],
+                            val,
+                        );
+                        if !has_edge {
+                            return Ok(false);
+                        }
+                    }
+                    if pred_count[0].cmp(&pred_count[1]).then(ordering) != ordering {
+                        return Ok(false);
+                    }
+                }
+                macro_rules! field {
+                    ($x:ident,     0) => {
+                        $x.0
+                    };
+                    ($x:ident,     1) => {
+                        $x.1
+                    };
+                    ($x:ident, 1 - 0) => {
+                        $x.1
+                    };
+                    ($x:ident, 1 - 1) => {
+                        $x.0
+                    };
+                }
+                macro_rules! rule {
+                    ($arr:ident, $j:tt, $dir:expr) => {{
+                        let mut count = 0;
+                        for n_neigh in field!(st, $j).graph.neighbors_directed(nodes[$j], $dir) {
+                            let index = n_neigh.index();
+                            if field!(st, $j).$arr[index] > 0 && st.$j.mapping[index] == end {
+                                count += 1;
+                            }
+                        }
+                        count
+                    }};
+                }
+                // R_out
+                if rule!(out, 0, Outgoing)
+                    .cmp(&rule!(out, 1, Outgoing))
+                    .then(ordering)
+                    != ordering
+                {
+                    return Ok(false);
+                }
+                if st.0.graph.is_directed()
+                    && rule!(out, 0, Incoming)
+                        .cmp(&rule!(out, 1, Incoming))
+                        .then(ordering)
+                        != ordering
+                {
+                    return Ok(false);
+                }
+                // R_in
+                if st.0.graph.is_directed() {
+                    if rule!(ins, 0, Outgoing)
+                        .cmp(&rule!(ins, 1, Outgoing))
+                        .then(ordering)
+                        != ordering
+                    {
+                        return Ok(false);
+                    }
+
+                    if rule!(ins, 0, Incoming)
+                        .cmp(&rule!(ins, 1, Incoming))
+                        .then(ordering)
+                        != ordering
+                    {
+                        return Ok(false);
+                    }
+                }
+                // R_new
+                if induced {
+                    let mut new_count = [0, 0];
+                    for n_neigh in st.0.graph.neighbors(nodes[0]) {
+                        let index = n_neigh.index();
+                        if st.0.out[index] == 0 && (st.0.ins.is_empty() || st.0.ins[index] == 0) {
+                            new_count[0] += 1;
+                        }
+                    }
+                    for n_neigh in st.1.graph.neighbors(nodes[1]) {
+                        let index = n_neigh.index();
+                        if st.1.out[index] == 0 && (st.1.ins.is_empty() || st.1.ins[index] == 0) {
+                            new_count[1] += 1;
+                        }
+                    }
+                    if new_count[0].cmp(&new_count[1]).then(ordering) != ordering {
+                        return Ok(false);
+                    }
+                    if st.0.graph.is_directed() {
+                        let mut new_count = [0, 0];
+                        for n_neigh in st.0.graph.neighbors_directed(nodes[0], Incoming) {
+                            let index = n_neigh.index();
+                            if st.0.out[index] == 0 && st.0.ins[index] == 0 {
+                                new_count[0] += 1;
+                            }
+                        }
+                        for n_neigh in st.1.graph.neighbors_directed(nodes[1], Incoming) {
+                            let index = n_neigh.index();
+                            if st.1.out[index] == 0 && st.1.ins[index] == 0 {
+                                new_count[1] += 1;
+                            }
+                        }
+                        if new_count[0].cmp(&new_count[1]).then(ordering) != ordering {
+                            return Ok(false);
+                        }
+                    }
+                }
+                // semantic feasibility: compare associated data for nodes
+                if node_match.enabled()
+                    && !node_match
+                        .eq(&st.0.graph, &st.1.graph, nodes[0], nodes[1])
+                        .map_err(IsIsomorphicError::NodeMatcherErr)?
+                {
+                    return Ok(false);
+                }
+                // semantic feasibility: compare associated data for edges
+                if edge_match.enabled() {
+                    let mut matcher =
+                        |g0_edge: (NodeIndex, G0::EdgeId),
+                         g1_edge: (NodeIndex, G1::EdgeId)|
+                         -> Result<bool, IsIsomorphicError<NM::Error, EM::Error>> {
+                            let (nx, e0) = g0_edge;
+                            let (mx, e1) = g1_edge;
+                            if nx == mx
+                                && edge_match
+                                .eq(&st.0.graph, &st.1.graph, e0, e1)
+                                .map_err(IsIsomorphicError::EdgeMatcherErr)?
+                            {
+                                return Ok(true);
+                            }
+                            Ok(false)
+                        };
+
+                    // Used to reverse the order of edge args to the matcher
+                    // when checking G1 subset of G0.
+                    #[inline]
+                    fn reverse_args<T1, T2, R, F>(mut f: F) -> impl FnMut(T2, T1) -> R
+                    where
+                        F: FnMut(T1, T2) -> R,
+                    {
+                        move |y, x| f(x, y)
+                    }
+
+                    // outgoing edges
+                    if induced {
+                        let e_first: Vec<(NodeIndex, G0::EdgeId)> =
+                            st.0.graph
+                                .edges(nodes[0])
+                                .filter_map(|edge| {
+                                    let n_neigh = edge.target();
+                                    let m_neigh = if nodes[0] != n_neigh {
+                                        st.0.mapping[n_neigh.index()]
+                                    } else {
+                                        nodes[1]
+                                    };
+                                    if m_neigh == end {
+                                        return None;
+                                    }
+                                    Some((m_neigh, edge.id()))
+                                })
+                                .collect();
+
+                        let e_second: Vec<(NodeIndex, G1::EdgeId)> =
+                            st.1.graph
+                                .edges(nodes[1])
+                                .map(|edge| (edge.target(), edge.id()))
+                                .collect();
+
+                        if !is_subset(&e_first, &e_second, &mut matcher)? {
+                            return Ok(false);
+                        };
+                    }
+
+                    let e_first: Vec<(NodeIndex, G1::EdgeId)> =
+                        st.1.graph
+                            .edges(nodes[1])
+                            .filter_map(|edge| {
+                                let n_neigh = edge.target();
+                                let m_neigh = if nodes[1] != n_neigh {
+                                    st.1.mapping[n_neigh.index()]
+                                } else {
+                                    nodes[0]
+                                };
+                                if m_neigh == end {
+                                    return None;
+                                }
+                                Some((m_neigh, edge.id()))
+                            })
+                            .collect();
+
+                    let e_second: Vec<(NodeIndex, G0::EdgeId)> =
+                        st.0.graph
+                            .edges(nodes[0])
+                            .map(|edge| (edge.target(), edge.id()))
+                            .collect();
+
+                    if !is_subset(&e_first, &e_second, &mut reverse_args(&mut matcher))? {
+                        return Ok(false);
+                    };
+
+                    // incoming edges
+                    if st.0.graph.is_directed() {
+                        if induced {
+                            let e_first: Vec<(NodeIndex, G0::EdgeId)> =
+                                st.0.graph
+                                    .edges_directed(nodes[0], Incoming)
+                                    .filter_map(|edge| {
+                                        let n_neigh = edge.source();
+                                        let m_neigh = if nodes[0] != n_neigh {
+                                            st.0.mapping[n_neigh.index()]
+                                        } else {
+                                            nodes[1]
+                                        };
+                                        if m_neigh == end {
+                                            return None;
+                                        }
+                                        Some((m_neigh, edge.id()))
+                                    })
+                                    .collect();
+
+                            let e_second: Vec<(NodeIndex, G1::EdgeId)> =
+                                st.1.graph
+                                    .edges_directed(nodes[1], Incoming)
+                                    .map(|edge| (edge.source(), edge.id()))
+                                    .collect();
+
+                            if !is_subset(&e_first, &e_second, &mut matcher)? {
+                                return Ok(false);
+                            };
+                        }
+
+                        let e_first: Vec<(NodeIndex, G1::EdgeId)> =
+                            st.1.graph
+                                .edges_directed(nodes[1], Incoming)
+                                .filter_map(|edge| {
+                                    let n_neigh = edge.source();
+                                    let m_neigh = if nodes[1] != n_neigh {
+                                        st.1.mapping[n_neigh.index()]
+                                    } else {
+                                        nodes[0]
+                                    };
+                                    if m_neigh == end {
+                                        return None;
+                                    }
+                                    Some((m_neigh, edge.id()))
+                                })
+                                .collect();
+
+                        let e_second: Vec<(NodeIndex, G0::EdgeId)> =
+                            st.0.graph
+                                .edges_directed(nodes[0], Incoming)
+                                .map(|edge| (edge.source(), edge.id()))
+                                .collect();
+
+                        if !is_subset(&e_first, &e_second, &mut reverse_args(&mut matcher))? {
+                            return Ok(false);
+                        };
+                    }
+                }
+                Ok(true)
+            }
+        }
+
+        impl<G0, G1, NM, EM> Iterator for Vf2Algorithm<G0, G1, NM, EM>
+        where
+            G0: GraphProp
+                + GraphBase<NodeId = NodeIndex>
+                + DataMap
+                + Create
+                + NodeCount
+                + EdgeCount,
+            for<'a> &'a G0: GraphBase<NodeId = G0::NodeId, EdgeId = G0::EdgeId>
+                + Data<NodeWeight = G0::NodeWeight, EdgeWeight = G0::EdgeWeight>
+                + NodeIndexable
+                + IntoEdgesDirected
+                + IntoNodeIdentifiers,
+            G0::NodeWeight: Clone,
+            G0::EdgeWeight: Clone,
+            G1: GraphProp
+                + GraphBase<NodeId = NodeIndex>
+                + DataMap
+                + Create
+                + NodeCount
+                + EdgeCount,
+            for<'a> &'a G1: GraphBase<NodeId = G1::NodeId, EdgeId = G1::EdgeId>
+                + Data<NodeWeight = G1::NodeWeight, EdgeWeight = G1::EdgeWeight>
+                + NodeIndexable
+                + IntoEdgesDirected
+                + IntoNodeIdentifiers,
+            G1::NodeWeight: Clone,
+            G1::EdgeWeight: Clone,
+            NM: NodeMatcher<G0, G1>,
+            EM: EdgeMatcher<G0, G1>,
+        {
+            type Item = Result<DictMap<usize, usize>, IsIsomorphicError<NM::Error, EM::Error>>;
+
+            /// Return Some(mapping) if isomorphism is decided, else None.
+            fn next(&mut self) -> Option<Self::Item> {
+                if (self
+                    .st
+                    .0
+                    .graph
+                    .node_count()
+                    .cmp(&self.st.1.graph.node_count())
+                    .then(self.ordering)
+                    != self.ordering)
+                    || (self
+                        .st
+                        .0
+                        .graph
+                        .edge_count()
+                        .cmp(&self.st.1.graph.edge_count())
+                        .then(self.ordering)
+                        != self.ordering)
+                {
+                    return None;
+                }
+
+                // A "depth first" search of a valid mapping from graph 1 to graph 2
+
+                // F(s, n, m) -- evaluate state s and add mapping n <-> m
+
+                // Find least T1out node (in st.out[1] but not in M[1])
+                while let Some(frame) = self.stack.pop() {
+                    match frame {
+                        Frame::Unwind {
+                            nodes,
+                            open_list: ol,
+                        } => {
+                            Vf2Algorithm::<G0, G1, NM, EM>::pop_state(&mut self.st, nodes);
+
+                            match Vf2Algorithm::<G0, G1, NM, EM>::next_from_ix(
+                                &mut self.st,
+                                nodes[0],
+                                ol,
+                            ) {
+                                None => continue,
+                                Some(nx) => {
+                                    let f = Frame::Inner {
+                                        nodes: [nx, nodes[1]],
+                                        open_list: ol,
+                                    };
+                                    self.stack.push(f);
+                                }
+                            }
+                        }
+                        Frame::Outer => {
+                            match Vf2Algorithm::<G0, G1, NM, EM>::next_candidate(&mut self.st) {
+                                None => {
+                                    if self.st.1.is_complete() {
+                                        return Some(Ok(self.mapping()));
+                                    }
+                                    continue;
+                                }
+                                Some((nx, mx, ol)) => {
+                                    let f = Frame::Inner {
+                                        nodes: [nx, mx],
+                                        open_list: ol,
+                                    };
+                                    self.stack.push(f);
+                                }
+                            }
+                        }
+                        Frame::Inner {
+                            nodes,
+                            open_list: ol,
+                        } => {
+                            let feasible = match Vf2Algorithm::<G0, G1, NM, EM>::is_feasible(
+                                &mut self.st,
+                                nodes,
+                                &mut self.node_match,
+                                &mut self.edge_match,
+                                self.ordering,
+                                self.induced,
+                            ) {
+                                Ok(f) => f,
+                                Err(e) => {
+                                    return Some(Err(e));
+                                }
+                            };
+
+                            if feasible {
+                                Vf2Algorithm::<G0, G1, NM, EM>::push_state(&mut self.st, nodes);
+                                // Check cardinalities of Tin, Tout sets
+                                if self
+                                    .st
+                                    .0
+                                    .out_size
+                                    .cmp(&self.st.1.out_size)
+                                    .then(self.ordering)
+                                    == self.ordering
+                                    && self
+                                        .st
+                                        .0
+                                        .ins_size
+                                        .cmp(&self.st.1.ins_size)
+                                        .then(self.ordering)
+                                        == self.ordering
+                                {
+                                    self._counter += 1;
+                                    if let Some(limit) = self.call_limit {
+                                        if self._counter > limit {
+                                            return None;
+                                        }
+                                    }
+                                    let f0 = Frame::Unwind {
+                                        nodes,
+                                        open_list: ol,
+                                    };
+
+                                    self.stack.push(f0);
+                                    self.stack.push(Frame::Outer);
+                                    continue;
+                                }
+                                Vf2Algorithm::<G0, G1, NM, EM>::pop_state(&mut self.st, nodes);
+                            }
+                            match Vf2Algorithm::<G0, G1, NM, EM>::next_from_ix(
+                                &mut self.st,
+                                nodes[0],
+                                ol,
+                            ) {
+                                None => continue,
+                                Some(nx) => {
+                                    let f = Frame::Inner {
+                                        nodes: [nx, nodes[1]],
+                                        open_list: ol,
+                                    };
+                                    self.stack.push(f);
+                                }
+                            }
+                        }
+                    }
+                }
+                None
+            }
+        }
+    }
+}
diff --git a/qiskit/converters/circuit_to_dag.py b/qiskit/converters/circuit_to_dag.py
index 10a48df99778..a330b8cbd682 100644
--- a/qiskit/converters/circuit_to_dag.py
+++ b/qiskit/converters/circuit_to_dag.py
@@ -12,7 +12,8 @@
 
 """Helper function for converting a circuit to a dag"""
 
-from qiskit.dagcircuit.dagcircuit import DAGCircuit, DAGOpNode
+from qiskit.dagcircuit.dagcircuit import DAGCircuit
+from qiskit.dagcircuit.dagnode import DAGOpNode
 
 
 def circuit_to_dag(circuit, copy_operations=True, *, qubit_order=None, clbit_order=None):
@@ -93,7 +94,7 @@ def circuit_to_dag(circuit, copy_operations=True, *, qubit_order=None, clbit_ord
 
     for instruction in circuit.data:
         dagcircuit._apply_op_node_back(
-            DAGOpNode.from_instruction(instruction, dag=dagcircuit, deepcopy=copy_operations)
+            DAGOpNode.from_instruction(instruction, deepcopy=copy_operations)
         )
 
     dagcircuit.duration = circuit.duration
diff --git a/qiskit/dagcircuit/dagcircuit.py b/qiskit/dagcircuit/dagcircuit.py
index 53cbc6f8f7f1..8738c2676a14 100644
--- a/qiskit/dagcircuit/dagcircuit.py
+++ b/qiskit/dagcircuit/dagcircuit.py
@@ -20,2406 +20,5 @@
 composed, and modified. Some natural properties like depth can be computed
 directly from the graph.
 """
-from __future__ import annotations
 
-import copy
-import enum
-import itertools
-import math
-from collections import OrderedDict, defaultdict, deque, namedtuple
-from collections.abc import Callable, Sequence, Generator, Iterable
-from typing import Any, Literal
-
-import numpy as np
-import rustworkx as rx
-
-from qiskit.circuit import (
-    ControlFlowOp,
-    ForLoopOp,
-    IfElseOp,
-    WhileLoopOp,
-    SwitchCaseOp,
-    _classical_resource_map,
-    Operation,
-    Store,
-)
-from qiskit.circuit.classical import expr
-from qiskit.circuit.controlflow import condition_resources, node_resources, CONTROL_FLOW_OP_NAMES
-from qiskit.circuit.quantumregister import QuantumRegister, Qubit
-from qiskit.circuit.classicalregister import ClassicalRegister, Clbit
-from qiskit.circuit.gate import Gate
-from qiskit.circuit.instruction import Instruction
-from qiskit.circuit.parameterexpression import ParameterExpression
-from qiskit.dagcircuit.exceptions import DAGCircuitError
-from qiskit.dagcircuit.dagnode import DAGNode, DAGOpNode, DAGInNode, DAGOutNode
-from qiskit.circuit.bit import Bit
-from qiskit.pulse import Schedule
-from qiskit._accelerate.euler_one_qubit_decomposer import collect_1q_runs_filter
-from qiskit._accelerate.convert_2q_block_matrix import collect_2q_blocks_filter
-
-BitLocations = namedtuple("BitLocations", ("index", "registers"))
-# The allowable arguments to :meth:`DAGCircuit.copy_empty_like`'s ``vars_mode``.
-_VarsMode = Literal["alike", "captures", "drop"]
-
-
-class DAGCircuit:
-    """
-    Quantum circuit as a directed acyclic graph.
-
-    There are 3 types of nodes in the graph: inputs, outputs, and operations.
-    The nodes are connected by directed edges that correspond to qubits and
-    bits.
-    """
-
-    # pylint: disable=invalid-name
-
-    def __init__(self):
-        """Create an empty circuit."""
-
-        # Circuit name.  Generally, this corresponds to the name
-        # of the QuantumCircuit from which the DAG was generated.
-        self.name = None
-
-        # Circuit metadata
-        self.metadata = {}
-
-        # Cache of dag op node sort keys
-        self._key_cache = {}
-
-        # Set of wire data in the DAG.  A wire is an owned unit of data.  Qubits are the primary
-        # wire type (and the only data that has _true_ wire properties from a read/write
-        # perspective), but clbits and classical `Var`s are too.  Note: classical registers are
-        # _not_ wires because the individual bits are the more fundamental unit.  We treat `Var`s
-        # as the entire wire (as opposed to individual bits of them) for scalability reasons; if a
-        # parametric program wants to parametrize over 16-bit angles, we can't scale to 1000s of
-        # those by tracking all 16 bits individually.
-        #
-        # Classical variables shouldn't be "wires"; it should be possible to have multiple reads
-        # without implying ordering.  The initial addition of the classical variables uses the
-        # existing wire structure as an MVP; we expect to handle this better in a new version of the
-        # transpiler IR that also handles control flow more properly.
-        self._wires = set()
-
-        # Map from wire to input nodes of the graph
-        self.input_map = OrderedDict()
-
-        # Map from wire to output nodes of the graph
-        self.output_map = OrderedDict()
-
-        # Directed multigraph whose nodes are inputs, outputs, or operations.
-        # Operation nodes have equal in- and out-degrees and carry
-        # additional data about the operation, including the argument order
-        # and parameter values.
-        # Input nodes have out-degree 1 and output nodes have in-degree 1.
-        # Edges carry wire labels and each operation has
-        # corresponding in- and out-edges with the same wire labels.
-        self._multi_graph = rx.PyDAG()
-
-        # Map of qreg/creg name to Register object.
-        self.qregs = OrderedDict()
-        self.cregs = OrderedDict()
-
-        # List of Qubit/Clbit wires that the DAG acts on.
-        self.qubits: list[Qubit] = []
-        self.clbits: list[Clbit] = []
-
-        # Dictionary mapping of Qubit and Clbit instances to a tuple comprised of
-        # 0) corresponding index in dag.{qubits,clbits} and
-        # 1) a list of Register-int pairs for each Register containing the Bit and
-        # its index within that register.
-        self._qubit_indices: dict[Qubit, BitLocations] = {}
-        self._clbit_indices: dict[Clbit, BitLocations] = {}
-        # Tracking for the classical variables used in the circuit.  This contains the information
-        # needed to insert new nodes.  This is keyed by the name rather than the `Var` instance
-        # itself so we can ensure we don't allow shadowing or redefinition of names.
-        self._vars_info: dict[str, _DAGVarInfo] = {}
-        # Convenience stateful tracking for the individual types of nodes to allow things like
-        # comparisons between circuits to take place without needing to disambiguate the
-        # graph-specific usage information.
-        self._vars_by_type: dict[_DAGVarType, set[expr.Var]] = {
-            type_: set() for type_ in _DAGVarType
-        }
-
-        self._global_phase: float | ParameterExpression = 0.0
-        self._calibrations: dict[str, dict[tuple, Schedule]] = defaultdict(dict)
-
-        self._op_names = {}
-
-        self.duration = None
-        self.unit = "dt"
-
-    @property
-    def wires(self):
-        """Return a list of the wires in order."""
-        return (
-            self.qubits
-            + self.clbits
-            + [var for vars in self._vars_by_type.values() for var in vars]
-        )
-
-    @property
-    def node_counter(self):
-        """
-        Returns the number of nodes in the dag.
-        """
-        return len(self._multi_graph)
-
-    @property
-    def global_phase(self):
-        """Return the global phase of the circuit."""
-        return self._global_phase
-
-    @global_phase.setter
-    def global_phase(self, angle: float | ParameterExpression):
-        """Set the global phase of the circuit.
-
-        Args:
-            angle (float, ParameterExpression)
-        """
-        if isinstance(angle, ParameterExpression):
-            self._global_phase = angle
-        else:
-            # Set the phase to the [0, 2π) interval
-            angle = float(angle)
-            if not angle:
-                self._global_phase = 0
-            else:
-                self._global_phase = angle % (2 * math.pi)
-
-    @property
-    def calibrations(self) -> dict[str, dict[tuple, Schedule]]:
-        """Return calibration dictionary.
-
-        The custom pulse definition of a given gate is of the form
-            {'gate_name': {(qubits, params): schedule}}
-        """
-        return dict(self._calibrations)
-
-    @calibrations.setter
-    def calibrations(self, calibrations: dict[str, dict[tuple, Schedule]]):
-        """Set the circuit calibration data from a dictionary of calibration definition.
-
-        Args:
-            calibrations (dict): A dictionary of input in the format
-                {'gate_name': {(qubits, gate_params): schedule}}
-        """
-        self._calibrations = defaultdict(dict, calibrations)
-
-    def add_calibration(self, gate, qubits, schedule, params=None):
-        """Register a low-level, custom pulse definition for the given gate.
-
-        Args:
-            gate (Union[Gate, str]): Gate information.
-            qubits (Union[int, Tuple[int]]): List of qubits to be measured.
-            schedule (Schedule): Schedule information.
-            params (Optional[List[Union[float, Parameter]]]): A list of parameters.
-
-        Raises:
-            Exception: if the gate is of type string and params is None.
-        """
-
-        def _format(operand):
-            try:
-                # Using float/complex value as a dict key is not good idea.
-                # This makes the mapping quite sensitive to the rounding error.
-                # However, the mechanism is already tied to the execution model (i.e. pulse gate)
-                # and we cannot easily update this rule.
-                # The same logic exists in QuantumCircuit.add_calibration.
-                evaluated = complex(operand)
-                if np.isreal(evaluated):
-                    evaluated = float(evaluated.real)
-                    if evaluated.is_integer():
-                        evaluated = int(evaluated)
-                return evaluated
-            except TypeError:
-                # Unassigned parameter
-                return operand
-
-        if isinstance(gate, Gate):
-            params = gate.params
-            gate = gate.name
-        if params is not None:
-            params = tuple(map(_format, params))
-        else:
-            params = ()
-
-        self._calibrations[gate][(tuple(qubits), params)] = schedule
-
-    def has_calibration_for(self, node):
-        """Return True if the dag has a calibration defined for the node operation. In this
-        case, the operation does not need to be translated to the device basis.
-        """
-        if not self.calibrations or node.op.name not in self.calibrations:
-            return False
-        qubits = tuple(self.qubits.index(qubit) for qubit in node.qargs)
-        params = []
-        for p in node.op.params:
-            if isinstance(p, ParameterExpression) and not p.parameters:
-                params.append(float(p))
-            else:
-                params.append(p)
-        params = tuple(params)
-        return (qubits, params) in self.calibrations[node.op.name]
-
-    def remove_all_ops_named(self, opname):
-        """Remove all operation nodes with the given name."""
-        for n in self.named_nodes(opname):
-            self.remove_op_node(n)
-
-    def add_qubits(self, qubits):
-        """Add individual qubit wires."""
-        if any(not isinstance(qubit, Qubit) for qubit in qubits):
-            raise DAGCircuitError("not a Qubit instance.")
-
-        duplicate_qubits = set(self.qubits).intersection(qubits)
-        if duplicate_qubits:
-            raise DAGCircuitError(f"duplicate qubits {duplicate_qubits}")
-
-        for qubit in qubits:
-            self.qubits.append(qubit)
-            self._qubit_indices[qubit] = BitLocations(len(self.qubits) - 1, [])
-            self._add_wire(qubit)
-
-    def add_clbits(self, clbits):
-        """Add individual clbit wires."""
-        if any(not isinstance(clbit, Clbit) for clbit in clbits):
-            raise DAGCircuitError("not a Clbit instance.")
-
-        duplicate_clbits = set(self.clbits).intersection(clbits)
-        if duplicate_clbits:
-            raise DAGCircuitError(f"duplicate clbits {duplicate_clbits}")
-
-        for clbit in clbits:
-            self.clbits.append(clbit)
-            self._clbit_indices[clbit] = BitLocations(len(self.clbits) - 1, [])
-            self._add_wire(clbit)
-
-    def add_qreg(self, qreg):
-        """Add all wires in a quantum register."""
-        if not isinstance(qreg, QuantumRegister):
-            raise DAGCircuitError("not a QuantumRegister instance.")
-        if qreg.name in self.qregs:
-            raise DAGCircuitError(f"duplicate register {qreg.name}")
-        self.qregs[qreg.name] = qreg
-        existing_qubits = set(self.qubits)
-        for j in range(qreg.size):
-            if qreg[j] in self._qubit_indices:
-                self._qubit_indices[qreg[j]].registers.append((qreg, j))
-            if qreg[j] not in existing_qubits:
-                self.qubits.append(qreg[j])
-                self._qubit_indices[qreg[j]] = BitLocations(
-                    len(self.qubits) - 1, registers=[(qreg, j)]
-                )
-                self._add_wire(qreg[j])
-
-    def add_creg(self, creg):
-        """Add all wires in a classical register."""
-        if not isinstance(creg, ClassicalRegister):
-            raise DAGCircuitError("not a ClassicalRegister instance.")
-        if creg.name in self.cregs:
-            raise DAGCircuitError(f"duplicate register {creg.name}")
-        self.cregs[creg.name] = creg
-        existing_clbits = set(self.clbits)
-        for j in range(creg.size):
-            if creg[j] in self._clbit_indices:
-                self._clbit_indices[creg[j]].registers.append((creg, j))
-            if creg[j] not in existing_clbits:
-                self.clbits.append(creg[j])
-                self._clbit_indices[creg[j]] = BitLocations(
-                    len(self.clbits) - 1, registers=[(creg, j)]
-                )
-                self._add_wire(creg[j])
-
-    def add_input_var(self, var: expr.Var):
-        """Add an input variable to the circuit.
-
-        Args:
-            var: the variable to add."""
-        if self._vars_by_type[_DAGVarType.CAPTURE]:
-            raise DAGCircuitError("cannot add inputs to a circuit with captures")
-        self._add_var(var, _DAGVarType.INPUT)
-
-    def add_captured_var(self, var: expr.Var):
-        """Add a captured variable to the circuit.
-
-        Args:
-            var: the variable to add."""
-        if self._vars_by_type[_DAGVarType.INPUT]:
-            raise DAGCircuitError("cannot add captures to a circuit with inputs")
-        self._add_var(var, _DAGVarType.CAPTURE)
-
-    def add_declared_var(self, var: expr.Var):
-        """Add a declared local variable to the circuit.
-
-        Args:
-            var: the variable to add."""
-        self._add_var(var, _DAGVarType.DECLARE)
-
-    def _add_var(self, var: expr.Var, type_: _DAGVarType):
-        """Inner function to add any variable to the DAG.  ``location`` should be a reference one of
-        the ``self._vars_*`` tracking dictionaries.
-        """
-        # The setup of the initial graph structure between an "in" and an "out" node is the same as
-        # the bit-related `_add_wire`, but this logically needs to do different bookkeeping around
-        # tracking the properties.
-        if not var.standalone:
-            raise DAGCircuitError(
-                "cannot add variables that wrap `Clbit` or `ClassicalRegister` instances"
-            )
-        if (previous := self._vars_info.get(var.name, None)) is not None:
-            if previous.var == var:
-                raise DAGCircuitError(f"'{var}' is already present in the circuit")
-            raise DAGCircuitError(
-                f"cannot add '{var}' as its name shadows the existing '{previous.var}'"
-            )
-        in_node = DAGInNode(wire=var)
-        out_node = DAGOutNode(wire=var)
-        in_node._node_id, out_node._node_id = self._multi_graph.add_nodes_from((in_node, out_node))
-        self._multi_graph.add_edge(in_node._node_id, out_node._node_id, var)
-        self.input_map[var] = in_node
-        self.output_map[var] = out_node
-        self._vars_by_type[type_].add(var)
-        self._vars_info[var.name] = _DAGVarInfo(var, type_, in_node, out_node)
-
-    def _add_wire(self, wire):
-        """Add a qubit or bit to the circuit.
-
-        Args:
-            wire (Bit): the wire to be added
-
-            This adds a pair of in and out nodes connected by an edge.
-
-        Raises:
-            DAGCircuitError: if trying to add duplicate wire
-        """
-        if wire not in self._wires:
-            self._wires.add(wire)
-
-            inp_node = DAGInNode(wire=wire)
-            outp_node = DAGOutNode(wire=wire)
-            input_map_id, output_map_id = self._multi_graph.add_nodes_from([inp_node, outp_node])
-            inp_node._node_id = input_map_id
-            outp_node._node_id = output_map_id
-            self.input_map[wire] = inp_node
-            self.output_map[wire] = outp_node
-            self._multi_graph.add_edge(inp_node._node_id, outp_node._node_id, wire)
-        else:
-            raise DAGCircuitError(f"duplicate wire {wire}")
-
-    def find_bit(self, bit: Bit) -> BitLocations:
-        """
-        Finds locations in the circuit, by mapping the Qubit and Clbit to positional index
-        BitLocations is defined as: BitLocations = namedtuple("BitLocations", ("index", "registers"))
-
-        Args:
-            bit (Bit): The bit to locate.
-
-        Returns:
-            namedtuple(int, List[Tuple(Register, int)]): A 2-tuple. The first element (``index``)
-                contains the index at which the ``Bit`` can be found (in either
-                :obj:`~DAGCircuit.qubits`, :obj:`~DAGCircuit.clbits`, depending on its
-                type). The second element (``registers``) is a list of ``(register, index)``
-                pairs with an entry for each :obj:`~Register` in the circuit which contains the
-                :obj:`~Bit` (and the index in the :obj:`~Register` at which it can be found).
-
-          Raises:
-            DAGCircuitError: If the supplied :obj:`~Bit` was of an unknown type.
-            DAGCircuitError: If the supplied :obj:`~Bit` could not be found on the circuit.
-        """
-        try:
-            if isinstance(bit, Qubit):
-                return self._qubit_indices[bit]
-            elif isinstance(bit, Clbit):
-                return self._clbit_indices[bit]
-            else:
-                raise DAGCircuitError(f"Could not locate bit of unknown type: {type(bit)}")
-        except KeyError as err:
-            raise DAGCircuitError(
-                f"Could not locate provided bit: {bit}. Has it been added to the DAGCircuit?"
-            ) from err
-
-    def remove_clbits(self, *clbits):
-        """
-        Remove classical bits from the circuit. All bits MUST be idle.
-        Any registers with references to at least one of the specified bits will
-        also be removed.
-
-        Args:
-            clbits (List[Clbit]): The bits to remove.
-
-        Raises:
-            DAGCircuitError: a clbit is not a :obj:`.Clbit`, is not in the circuit,
-                or is not idle.
-        """
-        if any(not isinstance(clbit, Clbit) for clbit in clbits):
-            raise DAGCircuitError(
-                f"clbits not of type Clbit: {[b for b in clbits if not isinstance(b, Clbit)]}"
-            )
-
-        clbits = set(clbits)
-        unknown_clbits = clbits.difference(self.clbits)
-        if unknown_clbits:
-            raise DAGCircuitError(f"clbits not in circuit: {unknown_clbits}")
-
-        busy_clbits = {bit for bit in clbits if not self._is_wire_idle(bit)}
-        if busy_clbits:
-            raise DAGCircuitError(f"clbits not idle: {busy_clbits}")
-
-        # remove any references to bits
-        cregs_to_remove = {creg for creg in self.cregs.values() if not clbits.isdisjoint(creg)}
-        self.remove_cregs(*cregs_to_remove)
-
-        for clbit in clbits:
-            self._remove_idle_wire(clbit)
-            self.clbits.remove(clbit)
-            del self._clbit_indices[clbit]
-
-        # Update the indices of remaining clbits
-        for i, clbit in enumerate(self.clbits):
-            self._clbit_indices[clbit] = self._clbit_indices[clbit]._replace(index=i)
-
-    def remove_cregs(self, *cregs):
-        """
-        Remove classical registers from the circuit, leaving underlying bits
-        in place.
-
-        Raises:
-            DAGCircuitError: a creg is not a ClassicalRegister, or is not in
-            the circuit.
-        """
-        if any(not isinstance(creg, ClassicalRegister) for creg in cregs):
-            raise DAGCircuitError(
-                "cregs not of type ClassicalRegister: "
-                f"{[r for r in cregs if not isinstance(r, ClassicalRegister)]}"
-            )
-
-        unknown_cregs = set(cregs).difference(self.cregs.values())
-        if unknown_cregs:
-            raise DAGCircuitError(f"cregs not in circuit: {unknown_cregs}")
-
-        for creg in cregs:
-            del self.cregs[creg.name]
-            for j in range(creg.size):
-                bit = creg[j]
-                bit_position = self._clbit_indices[bit]
-                bit_position.registers.remove((creg, j))
-
-    def remove_qubits(self, *qubits):
-        """
-        Remove quantum bits from the circuit. All bits MUST be idle.
-        Any registers with references to at least one of the specified bits will
-        also be removed.
-
-        Args:
-            qubits (List[~qiskit.circuit.Qubit]): The bits to remove.
-
-        Raises:
-            DAGCircuitError: a qubit is not a :obj:`~.circuit.Qubit`, is not in the circuit,
-                or is not idle.
-        """
-        if any(not isinstance(qubit, Qubit) for qubit in qubits):
-            raise DAGCircuitError(
-                f"qubits not of type Qubit: {[b for b in qubits if not isinstance(b, Qubit)]}"
-            )
-
-        qubits = set(qubits)
-        unknown_qubits = qubits.difference(self.qubits)
-        if unknown_qubits:
-            raise DAGCircuitError(f"qubits not in circuit: {unknown_qubits}")
-
-        busy_qubits = {bit for bit in qubits if not self._is_wire_idle(bit)}
-        if busy_qubits:
-            raise DAGCircuitError(f"qubits not idle: {busy_qubits}")
-
-        # remove any references to bits
-        qregs_to_remove = {qreg for qreg in self.qregs.values() if not qubits.isdisjoint(qreg)}
-        self.remove_qregs(*qregs_to_remove)
-
-        for qubit in qubits:
-            self._remove_idle_wire(qubit)
-            self.qubits.remove(qubit)
-            del self._qubit_indices[qubit]
-
-        # Update the indices of remaining qubits
-        for i, qubit in enumerate(self.qubits):
-            self._qubit_indices[qubit] = self._qubit_indices[qubit]._replace(index=i)
-
-    def remove_qregs(self, *qregs):
-        """
-        Remove quantum registers from the circuit, leaving underlying bits
-        in place.
-
-        Raises:
-            DAGCircuitError: a qreg is not a QuantumRegister, or is not in
-            the circuit.
-        """
-        if any(not isinstance(qreg, QuantumRegister) for qreg in qregs):
-            raise DAGCircuitError(
-                f"qregs not of type QuantumRegister: "
-                f"{[r for r in qregs if not isinstance(r, QuantumRegister)]}"
-            )
-
-        unknown_qregs = set(qregs).difference(self.qregs.values())
-        if unknown_qregs:
-            raise DAGCircuitError(f"qregs not in circuit: {unknown_qregs}")
-
-        for qreg in qregs:
-            del self.qregs[qreg.name]
-            for j in range(qreg.size):
-                bit = qreg[j]
-                bit_position = self._qubit_indices[bit]
-                bit_position.registers.remove((qreg, j))
-
-    def _is_wire_idle(self, wire):
-        """Check if a wire is idle.
-
-        Args:
-            wire (Bit): a wire in the circuit.
-
-        Returns:
-            bool: true if the wire is idle, false otherwise.
-
-        Raises:
-            DAGCircuitError: the wire is not in the circuit.
-        """
-        if wire not in self._wires:
-            raise DAGCircuitError(f"wire {wire} not in circuit")
-
-        try:
-            child = next(self.successors(self.input_map[wire]))
-        except StopIteration as e:
-            raise DAGCircuitError(
-                f"Invalid dagcircuit input node {self.input_map[wire]} has no output"
-            ) from e
-        return child is self.output_map[wire]
-
-    def _remove_idle_wire(self, wire):
-        """Remove an idle qubit or bit from the circuit.
-
-        Args:
-            wire (Bit): the wire to be removed, which MUST be idle.
-        """
-        inp_node = self.input_map[wire]
-        oup_node = self.output_map[wire]
-
-        self._multi_graph.remove_node(inp_node._node_id)
-        self._multi_graph.remove_node(oup_node._node_id)
-        self._wires.remove(wire)
-        del self.input_map[wire]
-        del self.output_map[wire]
-
-    def _check_condition(self, name, condition):
-        """Verify that the condition is valid.
-
-        Args:
-            name (string): used for error reporting
-            condition (tuple or None): a condition tuple (ClassicalRegister, int) or (Clbit, bool)
-
-        Raises:
-            DAGCircuitError: if conditioning on an invalid register
-        """
-        if condition is None:
-            return
-        resources = condition_resources(condition)
-        for creg in resources.cregs:
-            if creg.name not in self.cregs:
-                raise DAGCircuitError(f"invalid creg in condition for {name}")
-        if not set(resources.clbits).issubset(self.clbits):
-            raise DAGCircuitError(f"invalid clbits in condition for {name}")
-
-    def _check_wires(self, args: Iterable[Bit | expr.Var], amap: dict[Bit | expr.Var, Any]):
-        """Check the values of a list of wire arguments.
-
-        For each element of args, check that amap contains it.
-
-        Args:
-            args: the elements to be checked
-            amap: a dictionary keyed on Qubits/Clbits
-
-        Raises:
-            DAGCircuitError: if a qubit is not contained in amap
-        """
-        # Check for each wire
-        for wire in args:
-            if wire not in amap:
-                raise DAGCircuitError(f"wire {wire} not found in {amap}")
-
-    def _increment_op(self, op_name):
-        if op_name in self._op_names:
-            self._op_names[op_name] += 1
-        else:
-            self._op_names[op_name] = 1
-
-    def _decrement_op(self, op_name):
-        if self._op_names[op_name] == 1:
-            del self._op_names[op_name]
-        else:
-            self._op_names[op_name] -= 1
-
-    def copy_empty_like(self, *, vars_mode: _VarsMode = "alike"):
-        """Return a copy of self with the same structure but empty.
-
-        That structure includes:
-            * name and other metadata
-            * global phase
-            * duration
-            * all the qubits and clbits, including the registers
-            * all the classical variables, with a mode defined by ``vars_mode``.
-
-        Args:
-            vars_mode: The mode to handle realtime variables in.
-
-                alike
-                    The variables in the output DAG will have the same declaration semantics as
-                    in the original circuit.  For example, ``input`` variables in the source will be
-                    ``input`` variables in the output DAG.
-
-                captures
-                    All variables will be converted to captured variables.  This is useful when you
-                    are building a new layer for an existing DAG that you will want to
-                    :meth:`compose` onto the base, since :meth:`compose` can inline captures onto
-                    the base circuit (but not other variables).
-
-                drop
-                    The output DAG will have no variables defined.
-
-        Returns:
-            DAGCircuit: An empty copy of self.
-        """
-        target_dag = DAGCircuit()
-        target_dag.name = self.name
-        target_dag._global_phase = self._global_phase
-        target_dag.duration = self.duration
-        target_dag.unit = self.unit
-        target_dag.metadata = self.metadata
-        target_dag._key_cache = self._key_cache
-
-        target_dag.add_qubits(self.qubits)
-        target_dag.add_clbits(self.clbits)
-
-        for qreg in self.qregs.values():
-            target_dag.add_qreg(qreg)
-        for creg in self.cregs.values():
-            target_dag.add_creg(creg)
-
-        if vars_mode == "alike":
-            for var in self.iter_input_vars():
-                target_dag.add_input_var(var)
-            for var in self.iter_captured_vars():
-                target_dag.add_captured_var(var)
-            for var in self.iter_declared_vars():
-                target_dag.add_declared_var(var)
-        elif vars_mode == "captures":
-            for var in self.iter_vars():
-                target_dag.add_captured_var(var)
-        elif vars_mode == "drop":
-            pass
-        else:  # pragma: no cover
-            raise ValueError(f"unknown vars_mode: '{vars_mode}'")
-
-        return target_dag
-
-    def _apply_op_node_back(self, node: DAGOpNode, *, check: bool = False):
-        additional = ()
-        if _may_have_additional_wires(node):
-            # This is the slow path; most of the time, this won't happen.
-            additional = set(_additional_wires(node.op)).difference(node.cargs)
-
-        if check:
-            self._check_condition(node.name, node.condition)
-            self._check_wires(node.qargs, self.output_map)
-            self._check_wires(node.cargs, self.output_map)
-            self._check_wires(additional, self.output_map)
-
-        node._node_id = self._multi_graph.add_node(node)
-        self._increment_op(node.name)
-
-        # Add new in-edges from predecessors of the output nodes to the
-        # operation node while deleting the old in-edges of the output nodes
-        # and adding new edges from the operation node to each output node
-        self._multi_graph.insert_node_on_in_edges_multiple(
-            node._node_id,
-            [
-                self.output_map[bit]._node_id
-                for bits in (node.qargs, node.cargs, additional)
-                for bit in bits
-            ],
-        )
-        return node
-
-    def apply_operation_back(
-        self,
-        op: Operation,
-        qargs: Iterable[Qubit] = (),
-        cargs: Iterable[Clbit] = (),
-        *,
-        check: bool = True,
-    ) -> DAGOpNode:
-        """Apply an operation to the output of the circuit.
-
-        Args:
-            op (qiskit.circuit.Operation): the operation associated with the DAG node
-            qargs (tuple[~qiskit.circuit.Qubit]): qubits that op will be applied to
-            cargs (tuple[Clbit]): cbits that op will be applied to
-            check (bool): If ``True`` (default), this function will enforce that the
-                :class:`.DAGCircuit` data-structure invariants are maintained (all ``qargs`` are
-                :class:`~.circuit.Qubit`\\ s, all are in the DAG, etc).  If ``False``, the caller *must*
-                uphold these invariants itself, but the cost of several checks will be skipped.
-                This is most useful when building a new DAG from a source of known-good nodes.
-        Returns:
-            DAGOpNode: the node for the op that was added to the dag
-
-        Raises:
-            DAGCircuitError: if a leaf node is connected to multiple outputs
-
-        """
-        return self._apply_op_node_back(
-            DAGOpNode(op=op, qargs=tuple(qargs), cargs=tuple(cargs), dag=self), check=check
-        )
-
-    def apply_operation_front(
-        self,
-        op: Operation,
-        qargs: Sequence[Qubit] = (),
-        cargs: Sequence[Clbit] = (),
-        *,
-        check: bool = True,
-    ) -> DAGOpNode:
-        """Apply an operation to the input of the circuit.
-
-        Args:
-            op (qiskit.circuit.Operation): the operation associated with the DAG node
-            qargs (tuple[~qiskit.circuit.Qubit]): qubits that op will be applied to
-            cargs (tuple[Clbit]): cbits that op will be applied to
-            check (bool): If ``True`` (default), this function will enforce that the
-                :class:`.DAGCircuit` data-structure invariants are maintained (all ``qargs`` are
-                :class:`~.circuit.Qubit`\\ s, all are in the DAG, etc).  If ``False``, the caller *must*
-                uphold these invariants itself, but the cost of several checks will be skipped.
-                This is most useful when building a new DAG from a source of known-good nodes.
-        Returns:
-            DAGOpNode: the node for the op that was added to the dag
-
-        Raises:
-            DAGCircuitError: if initial nodes connected to multiple out edges
-        """
-        qargs = tuple(qargs)
-        cargs = tuple(cargs)
-        additional = ()
-
-        node = DAGOpNode(op=op, qargs=qargs, cargs=cargs, dag=self)
-        if _may_have_additional_wires(node):
-            # This is the slow path; most of the time, this won't happen.
-            additional = set(_additional_wires(node.op)).difference(cargs)
-
-        if check:
-            self._check_condition(node.name, node.condition)
-            self._check_wires(node.qargs, self.output_map)
-            self._check_wires(node.cargs, self.output_map)
-            self._check_wires(additional, self.output_map)
-
-        node._node_id = self._multi_graph.add_node(node)
-        self._increment_op(node.name)
-
-        # Add new out-edges to successors of the input nodes from the
-        # operation node while deleting the old out-edges of the input nodes
-        # and adding new edges to the operation node from each input node
-        self._multi_graph.insert_node_on_out_edges_multiple(
-            node._node_id,
-            [
-                self.input_map[bit]._node_id
-                for bits in (node.qargs, node.cargs, additional)
-                for bit in bits
-            ],
-        )
-        return node
-
-    def compose(
-        self, other, qubits=None, clbits=None, front=False, inplace=True, *, inline_captures=False
-    ):
-        """Compose the ``other`` circuit onto the output of this circuit.
-
-        A subset of input wires of ``other`` are mapped
-        to a subset of output wires of this circuit.
-
-        ``other`` can be narrower or of equal width to ``self``.
-
-        Args:
-            other (DAGCircuit): circuit to compose with self
-            qubits (list[~qiskit.circuit.Qubit|int]): qubits of self to compose onto.
-            clbits (list[Clbit|int]): clbits of self to compose onto.
-            front (bool): If True, front composition will be performed (not implemented yet)
-            inplace (bool): If True, modify the object. Otherwise return composed circuit.
-            inline_captures (bool): If ``True``, variables marked as "captures" in the ``other`` DAG
-                will inlined onto existing uses of those same variables in ``self``.  If ``False``,
-                all variables in ``other`` are required to be distinct from ``self``, and they will
-                be added to ``self``.
-
-        ..
-            Note: unlike `QuantumCircuit.compose`, there's no `var_remap` argument here.  That's
-            because the `DAGCircuit` inner-block structure isn't set up well to allow the recursion,
-            and `DAGCircuit.compose` is generally only used to rebuild a DAG from layers within
-            itself than to join unrelated circuits.  While there's no strong motivating use-case
-            (unlike the `QuantumCircuit` equivalent), it's safer and more performant to not provide
-            the option.
-
-        Returns:
-            DAGCircuit: the composed dag (returns None if inplace==True).
-
-        Raises:
-            DAGCircuitError: if ``other`` is wider or there are duplicate edge mappings.
-        """
-        if front:
-            raise DAGCircuitError("Front composition not supported yet.")
-
-        if len(other.qubits) > len(self.qubits) or len(other.clbits) > len(self.clbits):
-            raise DAGCircuitError(
-                "Trying to compose with another DAGCircuit which has more 'in' edges."
-            )
-
-        # number of qubits and clbits must match number in circuit or None
-        identity_qubit_map = dict(zip(other.qubits, self.qubits))
-        identity_clbit_map = dict(zip(other.clbits, self.clbits))
-        if qubits is None:
-            qubit_map = identity_qubit_map
-        elif len(qubits) != len(other.qubits):
-            raise DAGCircuitError(
-                "Number of items in qubits parameter does not"
-                " match number of qubits in the circuit."
-            )
-        else:
-            qubit_map = {
-                other.qubits[i]: (self.qubits[q] if isinstance(q, int) else q)
-                for i, q in enumerate(qubits)
-            }
-        if clbits is None:
-            clbit_map = identity_clbit_map
-        elif len(clbits) != len(other.clbits):
-            raise DAGCircuitError(
-                "Number of items in clbits parameter does not"
-                " match number of clbits in the circuit."
-            )
-        else:
-            clbit_map = {
-                other.clbits[i]: (self.clbits[c] if isinstance(c, int) else c)
-                for i, c in enumerate(clbits)
-            }
-        edge_map = {**qubit_map, **clbit_map} or None
-
-        # if no edge_map, try to do a 1-1 mapping in order
-        if edge_map is None:
-            edge_map = {**identity_qubit_map, **identity_clbit_map}
-
-        # Check the edge_map for duplicate values
-        if len(set(edge_map.values())) != len(edge_map):
-            raise DAGCircuitError("duplicates in wire_map")
-
-        # Compose
-        if inplace:
-            dag = self
-        else:
-            dag = copy.deepcopy(self)
-        dag.global_phase += other.global_phase
-
-        for gate, cals in other.calibrations.items():
-            dag._calibrations[gate].update(cals)
-
-        # This is all the handling we need for realtime variables, if there's no remapping. They:
-        #
-        # * get added to the DAG and then operations involving them get appended on normally.
-        # * get inlined onto an existing variable, then operations get appended normally.
-        # * there's a clash or a failed inlining, and we just raise an error.
-        #
-        # Notably if there's no remapping, there's no need to recurse into control-flow or to do any
-        # Var rewriting during the Expr visits.
-        for var in other.iter_input_vars():
-            dag.add_input_var(var)
-        if inline_captures:
-            for var in other.iter_captured_vars():
-                if not dag.has_var(var):
-                    raise DAGCircuitError(
-                        f"Variable '{var}' to be inlined is not in the base DAG."
-                        " If you wanted it to be automatically added, use `inline_captures=False`."
-                    )
-        else:
-            for var in other.iter_captured_vars():
-                dag.add_captured_var(var)
-        for var in other.iter_declared_vars():
-            dag.add_declared_var(var)
-
-        # Ensure that the error raised here is a `DAGCircuitError` for backwards compatibility.
-        def _reject_new_register(reg):
-            raise DAGCircuitError(f"No register with '{reg.bits}' to map this expression onto.")
-
-        variable_mapper = _classical_resource_map.VariableMapper(
-            dag.cregs.values(), edge_map, add_register=_reject_new_register
-        )
-        for nd in other.topological_nodes():
-            if isinstance(nd, DAGInNode):
-                if isinstance(nd.wire, Bit):
-                    # if in edge_map, get new name, else use existing name
-                    m_wire = edge_map.get(nd.wire, nd.wire)
-                    # the mapped wire should already exist
-                    if m_wire not in dag.output_map:
-                        raise DAGCircuitError(
-                            f"wire {m_wire.register.name}[{m_wire.index}] not in self"
-                        )
-                    if nd.wire not in other._wires:
-                        raise DAGCircuitError(
-                            f"inconsistent wire type for {nd.register.name}[{nd.wire.index}] in other"
-                        )
-                # If it's a Var wire, we already checked that it exists in the destination.
-            elif isinstance(nd, DAGOutNode):
-                # ignore output nodes
-                pass
-            elif isinstance(nd, DAGOpNode):
-                m_qargs = [edge_map.get(x, x) for x in nd.qargs]
-                m_cargs = [edge_map.get(x, x) for x in nd.cargs]
-                inst = nd._to_circuit_instruction(deepcopy=True)
-                m_op = None
-                if inst.condition is not None:
-                    if inst.is_control_flow():
-                        m_op = inst.operation
-                        m_op.condition = variable_mapper.map_condition(
-                            inst.condition, allow_reorder=True
-                        )
-                    else:
-                        m_op = inst.operation.c_if(
-                            *variable_mapper.map_condition(inst.condition, allow_reorder=True)
-                        )
-                elif inst.is_control_flow() and isinstance(inst.operation, SwitchCaseOp):
-                    m_op = inst.operation
-                    m_op.target = variable_mapper.map_target(m_op.target)
-                if m_op is None:
-                    inst = inst.replace(qubits=m_qargs, clbits=m_cargs)
-                else:
-                    inst = inst.replace(operation=m_op, qubits=m_qargs, clbits=m_cargs)
-                dag._apply_op_node_back(DAGOpNode.from_instruction(inst), check=False)
-            else:
-                raise DAGCircuitError(f"bad node type {type(nd)}")
-
-        if not inplace:
-            return dag
-        else:
-            return None
-
-    def reverse_ops(self):
-        """Reverse the operations in the ``self`` circuit.
-
-        Returns:
-            DAGCircuit: the reversed dag.
-        """
-        # TODO: speed up
-        # pylint: disable=cyclic-import
-        from qiskit.converters import dag_to_circuit, circuit_to_dag
-
-        qc = dag_to_circuit(self)
-        reversed_qc = qc.reverse_ops()
-        reversed_dag = circuit_to_dag(reversed_qc)
-        return reversed_dag
-
-    def idle_wires(self, ignore=None):
-        """Return idle wires.
-
-        Args:
-            ignore (list(str)): List of node names to ignore. Default: []
-
-        Yields:
-            Bit: Bit in idle wire.
-
-        Raises:
-            DAGCircuitError: If the DAG is invalid
-        """
-        if ignore is None:
-            ignore = set()
-        ignore_set = set(ignore)
-        for wire in self._wires:
-            if not ignore:
-                if self._is_wire_idle(wire):
-                    yield wire
-            else:
-                for node in self.nodes_on_wire(wire, only_ops=True):
-                    if node.op.name not in ignore_set:
-                        # If we found an op node outside of ignore we can stop iterating over the wire
-                        break
-                else:
-                    yield wire
-
-    def size(self, *, recurse: bool = False):
-        """Return the number of operations.  If there is control flow present, this count may only
-        be an estimate, as the complete control-flow path cannot be statically known.
-
-        Args:
-            recurse: if ``True``, then recurse into control-flow operations.  For loops with
-                known-length iterators are counted unrolled.  If-else blocks sum both of the two
-                branches.  While loops are counted as if the loop body runs once only.  Defaults to
-                ``False`` and raises :class:`.DAGCircuitError` if any control flow is present, to
-                avoid silently returning a mostly meaningless number.
-
-        Returns:
-            int: the circuit size
-
-        Raises:
-            DAGCircuitError: if an unknown :class:`.ControlFlowOp` is present in a call with
-                ``recurse=True``, or any control flow is present in a non-recursive call.
-        """
-        length = len(self._multi_graph) - 2 * len(self._wires)
-        if not recurse:
-            if any(x in self._op_names for x in CONTROL_FLOW_OP_NAMES):
-                raise DAGCircuitError(
-                    "Size with control flow is ambiguous."
-                    " You may use `recurse=True` to get a result,"
-                    " but see this method's documentation for the meaning of this."
-                )
-            return length
-        # pylint: disable=cyclic-import
-        from qiskit.converters import circuit_to_dag
-
-        for node in self.op_nodes(ControlFlowOp):
-            if isinstance(node.op, ForLoopOp):
-                indexset = node.op.params[0]
-                inner = len(indexset) * circuit_to_dag(node.op.blocks[0]).size(recurse=True)
-            elif isinstance(node.op, WhileLoopOp):
-                inner = circuit_to_dag(node.op.blocks[0]).size(recurse=True)
-            elif isinstance(node.op, (IfElseOp, SwitchCaseOp)):
-                inner = sum(circuit_to_dag(block).size(recurse=True) for block in node.op.blocks)
-            else:
-                raise DAGCircuitError(f"unknown control-flow type: '{node.op.name}'")
-            # Replace the "1" for the node itself with the actual count.
-            length += inner - 1
-        return length
-
-    def depth(self, *, recurse: bool = False):
-        """Return the circuit depth.  If there is control flow present, this count may only be an
-        estimate, as the complete control-flow path cannot be statically known.
-
-        Args:
-            recurse: if ``True``, then recurse into control-flow operations.  For loops
-                with known-length iterators are counted as if the loop had been manually unrolled
-                (*i.e.* with each iteration of the loop body written out explicitly).
-                If-else blocks take the longer case of the two branches.  While loops are counted as
-                if the loop body runs once only.  Defaults to ``False`` and raises
-                :class:`.DAGCircuitError` if any control flow is present, to avoid silently
-                returning a nonsensical number.
-
-        Returns:
-            int: the circuit depth
-
-        Raises:
-            DAGCircuitError: if not a directed acyclic graph
-            DAGCircuitError: if unknown control flow is present in a recursive call, or any control
-                flow is present in a non-recursive call.
-        """
-        if recurse:
-            from qiskit.converters import circuit_to_dag  # pylint: disable=cyclic-import
-
-            node_lookup = {}
-            for node in self.op_nodes(ControlFlowOp):
-                weight = len(node.op.params[0]) if isinstance(node.op, ForLoopOp) else 1
-                if weight == 0:
-                    node_lookup[node._node_id] = 0
-                else:
-                    node_lookup[node._node_id] = weight * max(
-                        circuit_to_dag(block).depth(recurse=True) for block in node.op.blocks
-                    )
-
-            def weight_fn(_source, target, _edge):
-                return node_lookup.get(target, 1)
-
-        else:
-            if any(x in self._op_names for x in CONTROL_FLOW_OP_NAMES):
-                raise DAGCircuitError(
-                    "Depth with control flow is ambiguous."
-                    " You may use `recurse=True` to get a result,"
-                    " but see this method's documentation for the meaning of this."
-                )
-            weight_fn = None
-
-        try:
-            depth = rx.dag_longest_path_length(self._multi_graph, weight_fn) - 1
-        except rx.DAGHasCycle as ex:
-            raise DAGCircuitError("not a DAG") from ex
-        return depth if depth >= 0 else 0
-
-    def width(self):
-        """Return the total number of qubits + clbits used by the circuit.
-        This function formerly returned the number of qubits by the calculation
-        return len(self._wires) - self.num_clbits()
-        but was changed by issue #2564 to return number of qubits + clbits
-        with the new function DAGCircuit.num_qubits replacing the former
-        semantic of DAGCircuit.width().
-        """
-        return len(self._wires)
-
-    def num_qubits(self):
-        """Return the total number of qubits used by the circuit.
-        num_qubits() replaces former use of width().
-        DAGCircuit.width() now returns qubits + clbits for
-        consistency with Circuit.width() [qiskit-terra #2564].
-        """
-        return len(self.qubits)
-
-    def num_clbits(self):
-        """Return the total number of classical bits used by the circuit."""
-        return len(self.clbits)
-
-    def num_tensor_factors(self):
-        """Compute how many components the circuit can decompose into."""
-        return rx.number_weakly_connected_components(self._multi_graph)
-
-    @property
-    def num_vars(self):
-        """Total number of classical variables tracked by the circuit."""
-        return len(self._vars_info)
-
-    @property
-    def num_input_vars(self):
-        """Number of input classical variables tracked by the circuit."""
-        return len(self._vars_by_type[_DAGVarType.INPUT])
-
-    @property
-    def num_captured_vars(self):
-        """Number of captured classical variables tracked by the circuit."""
-        return len(self._vars_by_type[_DAGVarType.CAPTURE])
-
-    @property
-    def num_declared_vars(self):
-        """Number of declared local classical variables tracked by the circuit."""
-        return len(self._vars_by_type[_DAGVarType.DECLARE])
-
-    def iter_vars(self):
-        """Iterable over all the classical variables tracked by the circuit."""
-        return itertools.chain.from_iterable(self._vars_by_type.values())
-
-    def iter_input_vars(self):
-        """Iterable over the input classical variables tracked by the circuit."""
-        return iter(self._vars_by_type[_DAGVarType.INPUT])
-
-    def iter_captured_vars(self):
-        """Iterable over the captured classical variables tracked by the circuit."""
-        return iter(self._vars_by_type[_DAGVarType.CAPTURE])
-
-    def iter_declared_vars(self):
-        """Iterable over the declared local classical variables tracked by the circuit."""
-        return iter(self._vars_by_type[_DAGVarType.DECLARE])
-
-    def has_var(self, var: str | expr.Var) -> bool:
-        """Is this realtime variable in the DAG?
-
-        Args:
-            var: the variable or name to check.
-        """
-        if isinstance(var, str):
-            return var in self._vars_info
-        return (info := self._vars_info.get(var.name, False)) and info.var is var
-
-    def __eq__(self, other):
-        # Try to convert to float, but in case of unbound ParameterExpressions
-        # a TypeError will be raise, fallback to normal equality in those
-        # cases
-        try:
-            self_phase = float(self.global_phase)
-            other_phase = float(other.global_phase)
-            if (
-                abs((self_phase - other_phase + np.pi) % (2 * np.pi) - np.pi) > 1.0e-10
-            ):  # TODO: atol?
-                return False
-        except TypeError:
-            if self.global_phase != other.global_phase:
-                return False
-        if self.calibrations != other.calibrations:
-            return False
-
-        # We don't do any semantic equivalence between Var nodes, as things stand; DAGs can only be
-        # equal in our mind if they use the exact same UUID vars.
-        if self._vars_by_type != other._vars_by_type:
-            return False
-
-        self_bit_indices = {bit: idx for idx, bit in enumerate(self.qubits + self.clbits)}
-        other_bit_indices = {bit: idx for idx, bit in enumerate(other.qubits + other.clbits)}
-
-        self_qreg_indices = {
-            regname: [self_bit_indices[bit] for bit in reg] for regname, reg in self.qregs.items()
-        }
-        self_creg_indices = {
-            regname: [self_bit_indices[bit] for bit in reg] for regname, reg in self.cregs.items()
-        }
-
-        other_qreg_indices = {
-            regname: [other_bit_indices[bit] for bit in reg] for regname, reg in other.qregs.items()
-        }
-        other_creg_indices = {
-            regname: [other_bit_indices[bit] for bit in reg] for regname, reg in other.cregs.items()
-        }
-        if self_qreg_indices != other_qreg_indices or self_creg_indices != other_creg_indices:
-            return False
-
-        def node_eq(node_self, node_other):
-            return DAGNode.semantic_eq(node_self, node_other, self_bit_indices, other_bit_indices)
-
-        return rx.is_isomorphic_node_match(self._multi_graph, other._multi_graph, node_eq)
-
-    def topological_nodes(self, key=None):
-        """
-        Yield nodes in topological order.
-
-        Args:
-            key (Callable): A callable which will take a DAGNode object and
-                return a string sort key. If not specified the
-                :attr:`~qiskit.dagcircuit.DAGNode.sort_key` attribute will be
-                used as the sort key for each node.
-
-        Returns:
-            generator(DAGOpNode, DAGInNode, or DAGOutNode): node in topological order
-        """
-
-        def _key(x):
-            return x.sort_key
-
-        if key is None:
-            key = _key
-
-        return iter(rx.lexicographical_topological_sort(self._multi_graph, key=key))
-
-    def topological_op_nodes(self, key: Callable | None = None) -> Generator[DAGOpNode, Any, Any]:
-        """
-        Yield op nodes in topological order.
-
-        Allowed to pass in specific key to break ties in top order
-
-        Args:
-            key (Callable): A callable which will take a DAGNode object and
-                return a string sort key. If not specified the
-                :attr:`~qiskit.dagcircuit.DAGNode.sort_key` attribute will be
-                used as the sort key for each node.
-
-        Returns:
-            generator(DAGOpNode): op node in topological order
-        """
-        return (nd for nd in self.topological_nodes(key) if isinstance(nd, DAGOpNode))
-
-    def replace_block_with_op(
-        self, node_block: list[DAGOpNode], op: Operation, wire_pos_map, cycle_check=True
-    ):
-        """Replace a block of nodes with a single node.
-
-        This is used to consolidate a block of DAGOpNodes into a single
-        operation. A typical example is a block of gates being consolidated
-        into a single ``UnitaryGate`` representing the unitary matrix of the
-        block.
-
-        Args:
-            node_block (List[DAGNode]): A list of dag nodes that represents the
-                node block to be replaced
-            op (qiskit.circuit.Operation): The operation to replace the
-                block with
-            wire_pos_map (Dict[Bit, int]): The dictionary mapping the bits to their positions in the
-                output ``qargs`` or ``cargs``. This is necessary to reconstruct the arg order over
-                multiple gates in the combined single op node.  If a :class:`.Bit` is not in the
-                dictionary, it will not be added to the args; this can be useful when dealing with
-                control-flow operations that have inherent bits in their ``condition`` or ``target``
-                fields.  :class:`.expr.Var` wires similarly do not need to be in this map, since
-                they will never be in ``qargs`` or ``cargs``.
-            cycle_check (bool): When set to True this method will check that
-                replacing the provided ``node_block`` with a single node
-                would introduce a cycle (which would invalidate the
-                ``DAGCircuit``) and will raise a ``DAGCircuitError`` if a cycle
-                would be introduced. This checking comes with a run time
-                penalty. If you can guarantee that your input ``node_block`` is
-                a contiguous block and won't introduce a cycle when it's
-                contracted to a single node, this can be set to ``False`` to
-                improve the runtime performance of this method.
-
-        Raises:
-            DAGCircuitError: if ``cycle_check`` is set to ``True`` and replacing
-                the specified block introduces a cycle or if ``node_block`` is
-                empty.
-
-        Returns:
-            DAGOpNode: The op node that replaces the block.
-        """
-        block_qargs = set()
-        block_cargs = set()
-        block_ids = [x._node_id for x in node_block]
-
-        # If node block is empty return early
-        if not node_block:
-            raise DAGCircuitError("Can't replace an empty node_block")
-
-        for nd in node_block:
-            block_qargs |= set(nd.qargs)
-            block_cargs |= set(nd.cargs)
-            if (condition := getattr(nd, "condition", None)) is not None:
-                block_cargs.update(condition_resources(condition).clbits)
-            elif nd.name in CONTROL_FLOW_OP_NAMES and isinstance(nd.op, SwitchCaseOp):
-                if isinstance(nd.op.target, Clbit):
-                    block_cargs.add(nd.op.target)
-                elif isinstance(nd.op.target, ClassicalRegister):
-                    block_cargs.update(nd.op.target)
-                else:
-                    block_cargs.update(node_resources(nd.op.target).clbits)
-
-        block_qargs = [bit for bit in block_qargs if bit in wire_pos_map]
-        block_qargs.sort(key=wire_pos_map.get)
-        block_cargs = [bit for bit in block_cargs if bit in wire_pos_map]
-        block_cargs.sort(key=wire_pos_map.get)
-        new_node = DAGOpNode(op, block_qargs, block_cargs, dag=self)
-
-        # check the op to insert matches the number of qubits we put it on
-        if op.num_qubits != len(block_qargs):
-            raise DAGCircuitError(
-                f"Number of qubits in the replacement operation ({op.num_qubits}) is not equal to "
-                f"the number of qubits in the block ({len(block_qargs)})!"
-            )
-
-        try:
-            new_node._node_id = self._multi_graph.contract_nodes(
-                block_ids, new_node, check_cycle=cycle_check
-            )
-        except rx.DAGWouldCycle as ex:
-            raise DAGCircuitError(
-                "Replacing the specified node block would introduce a cycle"
-            ) from ex
-
-        self._increment_op(op.name)
-
-        for nd in node_block:
-            self._decrement_op(nd.name)
-
-        return new_node
-
-    def substitute_node_with_dag(self, node, input_dag, wires=None, propagate_condition=True):
-        """Replace one node with dag.
-
-        Args:
-            node (DAGOpNode): node to substitute
-            input_dag (DAGCircuit): circuit that will substitute the node.
-            wires (list[Bit] | Dict[Bit, Bit]): gives an order for (qu)bits
-                in the input circuit. If a list, then the bits refer to those in the ``input_dag``,
-                and the order gets matched to the node wires by qargs first, then cargs, then
-                conditions.  If a dictionary, then a mapping of bits in the ``input_dag`` to those
-                that the ``node`` acts on.
-
-                Standalone :class:`~.expr.Var` nodes cannot currently be remapped as part of the
-                substitution; the ``input_dag`` should be defined over the correct set of variables
-                already.
-
-                ..
-                    The rule about not remapping `Var`s is to avoid performance pitfalls and reduce
-                    complexity; the creator of the input DAG should easily be able to arrange for
-                    the correct `Var`s to be used, and doing so avoids us needing to recurse through
-                    control-flow operations to do deep remappings.
-            propagate_condition (bool): If ``True`` (default), then any ``condition`` attribute on
-                the operation within ``node`` is propagated to each node in the ``input_dag``.  If
-                ``False``, then the ``input_dag`` is assumed to faithfully implement suitable
-                conditional logic already.  This is ignored for :class:`.ControlFlowOp`\\ s (i.e.
-                treated as if it is ``False``); replacements of those must already fulfill the same
-                conditional logic or this function would be close to useless for them.
-
-        Returns:
-            dict: maps node IDs from `input_dag` to their new node incarnations in `self`.
-
-        Raises:
-            DAGCircuitError: if met with unexpected predecessor/successors
-        """
-        if not isinstance(node, DAGOpNode):
-            raise DAGCircuitError(f"expected node DAGOpNode, got {type(node)}")
-
-        if isinstance(wires, dict):
-            wire_map = wires
-        else:
-            wires = input_dag.wires if wires is None else wires
-            node_cargs = set(node.cargs)
-            node_wire_order = list(node.qargs) + list(node.cargs)
-            # If we're not propagating it, the number of wires in the input DAG should include the
-            # condition as well.
-            if not propagate_condition and _may_have_additional_wires(node):
-                node_wire_order += [
-                    wire for wire in _additional_wires(node.op) if wire not in node_cargs
-                ]
-            if len(wires) != len(node_wire_order):
-                raise DAGCircuitError(
-                    f"bit mapping invalid: expected {len(node_wire_order)}, got {len(wires)}"
-                )
-            wire_map = dict(zip(wires, node_wire_order))
-            if len(wire_map) != len(node_wire_order):
-                raise DAGCircuitError("bit mapping invalid: some bits have duplicate entries")
-        for input_dag_wire, our_wire in wire_map.items():
-            if our_wire not in self.input_map:
-                raise DAGCircuitError(f"bit mapping invalid: {our_wire} is not in this DAG")
-            if isinstance(our_wire, expr.Var) or isinstance(input_dag_wire, expr.Var):
-                raise DAGCircuitError("`Var` nodes cannot be remapped during substitution")
-            # Support mapping indiscriminately between Qubit and AncillaQubit, etc.
-            check_type = Qubit if isinstance(our_wire, Qubit) else Clbit
-            if not isinstance(input_dag_wire, check_type):
-                raise DAGCircuitError(
-                    f"bit mapping invalid: {input_dag_wire} and {our_wire} are different bit types"
-                )
-        if _may_have_additional_wires(node):
-            node_vars = {var for var in _additional_wires(node.op) if isinstance(var, expr.Var)}
-        else:
-            node_vars = set()
-        dag_vars = set(input_dag.iter_vars())
-        if dag_vars - node_vars:
-            raise DAGCircuitError(
-                "Cannot replace a node with a DAG with more variables."
-                f" Variables in node: {node_vars}."
-                f" Variables in DAG: {dag_vars}."
-            )
-        for var in dag_vars:
-            wire_map[var] = var
-
-        reverse_wire_map = {b: a for a, b in wire_map.items()}
-        # It doesn't make sense to try and propagate a condition from a control-flow op; a
-        # replacement for the control-flow op should implement the operation completely.
-        if propagate_condition and not node.is_control_flow() and node.condition is not None:
-            in_dag = input_dag.copy_empty_like()
-            # The remapping of `condition` below is still using the old code that assumes a 2-tuple.
-            # This is because this remapping code only makes sense in the case of non-control-flow
-            # operations being replaced.  These can only have the 2-tuple conditions, and the
-            # ability to set a condition at an individual node level will be deprecated and removed
-            # in favour of the new-style conditional blocks.  The extra logic in here to add
-            # additional wires into the map as necessary would hugely complicate matters if we tried
-            # to abstract it out into the `VariableMapper` used elsewhere.
-            target, value = node.condition
-            if isinstance(target, Clbit):
-                new_target = reverse_wire_map.get(target, Clbit())
-                if new_target not in wire_map:
-                    in_dag.add_clbits([new_target])
-                    wire_map[new_target], reverse_wire_map[target] = target, new_target
-                target_cargs = {new_target}
-            else:  # ClassicalRegister
-                mapped_bits = [reverse_wire_map.get(bit, Clbit()) for bit in target]
-                for ours, theirs in zip(target, mapped_bits):
-                    # Update to any new dummy bits we just created to the wire maps.
-                    wire_map[theirs], reverse_wire_map[ours] = ours, theirs
-                new_target = ClassicalRegister(bits=mapped_bits)
-                in_dag.add_creg(new_target)
-                target_cargs = set(new_target)
-            new_condition = (new_target, value)
-            for in_node in input_dag.topological_op_nodes():
-                if getattr(in_node.op, "condition", None) is not None:
-                    raise DAGCircuitError(
-                        "cannot propagate a condition to an element that already has one"
-                    )
-                if target_cargs.intersection(in_node.cargs):
-                    # This is for backwards compatibility with early versions of the method, as it is
-                    # a tested part of the API.  In the newer model of a condition being an integral
-                    # part of the operation (not a separate property to be copied over), this error
-                    # is overzealous, because it forbids a custom instruction from implementing the
-                    # condition within its definition rather than at the top level.
-                    raise DAGCircuitError(
-                        "cannot propagate a condition to an element that acts on those bits"
-                    )
-                new_op = copy.copy(in_node.op)
-                if new_condition:
-                    if not isinstance(new_op, ControlFlowOp):
-                        new_op = new_op.c_if(*new_condition)
-                    else:
-                        new_op.condition = new_condition
-                in_dag.apply_operation_back(new_op, in_node.qargs, in_node.cargs, check=False)
-        else:
-            in_dag = input_dag
-
-        if in_dag.global_phase:
-            self.global_phase += in_dag.global_phase
-
-        # Add wire from pred to succ if no ops on mapped wire on ``in_dag``
-        # rustworkx's substitute_node_with_subgraph lacks the DAGCircuit
-        # context to know what to do in this case (the method won't even see
-        # these nodes because they're filtered) so we manually retain the
-        # edges prior to calling substitute_node_with_subgraph and set the
-        # edge_map_fn callback kwarg to skip these edges when they're
-        # encountered.
-        for in_dag_wire, self_wire in wire_map.items():
-            input_node = in_dag.input_map[in_dag_wire]
-            output_node = in_dag.output_map[in_dag_wire]
-            if in_dag._multi_graph.has_edge(input_node._node_id, output_node._node_id):
-                pred = self._multi_graph.find_predecessors_by_edge(
-                    node._node_id, lambda edge, wire=self_wire: edge == wire
-                )[0]
-                succ = self._multi_graph.find_successors_by_edge(
-                    node._node_id, lambda edge, wire=self_wire: edge == wire
-                )[0]
-                self._multi_graph.add_edge(pred._node_id, succ._node_id, self_wire)
-        for contracted_var in node_vars - dag_vars:
-            pred = self._multi_graph.find_predecessors_by_edge(
-                node._node_id, lambda edge, wire=contracted_var: edge == wire
-            )[0]
-            succ = self._multi_graph.find_successors_by_edge(
-                node._node_id, lambda edge, wire=contracted_var: edge == wire
-            )[0]
-            self._multi_graph.add_edge(pred._node_id, succ._node_id, contracted_var)
-
-        # Exclude any nodes from in_dag that are not a DAGOpNode or are on
-        # wires outside the set specified by the wires kwarg
-        def filter_fn(node):
-            if not isinstance(node, DAGOpNode):
-                return False
-            for _, _, wire in in_dag.edges(node):
-                if wire not in wire_map:
-                    return False
-            return True
-
-        # Map edges into and out of node to the appropriate node from in_dag
-        def edge_map_fn(source, _target, self_wire):
-            wire = reverse_wire_map[self_wire]
-            # successor edge
-            if source == node._node_id:
-                wire_output_id = in_dag.output_map[wire]._node_id
-                out_index = in_dag._multi_graph.predecessor_indices(wire_output_id)[0]
-                # Edge directly from from input nodes to output nodes in in_dag are
-                # already handled prior to calling rustworkx. Don't map these edges
-                # in rustworkx.
-                if not isinstance(in_dag._multi_graph[out_index], DAGOpNode):
-                    return None
-            # predecessor edge
-            else:
-                wire_input_id = in_dag.input_map[wire]._node_id
-                out_index = in_dag._multi_graph.successor_indices(wire_input_id)[0]
-                # Edge directly from from input nodes to output nodes in in_dag are
-                # already handled prior to calling rustworkx. Don't map these edges
-                # in rustworkx.
-                if not isinstance(in_dag._multi_graph[out_index], DAGOpNode):
-                    return None
-            return out_index
-
-        # Adjust edge weights from in_dag
-        def edge_weight_map(wire):
-            return wire_map[wire]
-
-        node_map = self._multi_graph.substitute_node_with_subgraph(
-            node._node_id, in_dag._multi_graph, edge_map_fn, filter_fn, edge_weight_map
-        )
-        self._decrement_op(node.name)
-
-        variable_mapper = _classical_resource_map.VariableMapper(
-            self.cregs.values(), wire_map, add_register=self.add_creg
-        )
-        # Iterate over nodes of input_circuit and update wires in node objects migrated
-        # from in_dag
-        for old_node_index, new_node_index in node_map.items():
-            # update node attributes
-            old_node = in_dag._multi_graph[old_node_index]
-            m_op = None
-            if not old_node.is_standard_gate() and isinstance(old_node.op, SwitchCaseOp):
-                m_op = SwitchCaseOp(
-                    variable_mapper.map_target(old_node.op.target),
-                    old_node.op.cases_specifier(),
-                    label=old_node.op.label,
-                )
-            elif old_node.condition is not None:
-                m_op = old_node.op
-                if old_node.is_control_flow():
-                    m_op.condition = variable_mapper.map_condition(m_op.condition)
-                else:
-                    new_condition = variable_mapper.map_condition(m_op.condition)
-                    if new_condition is not None:
-                        m_op = m_op.c_if(*new_condition)
-            m_qargs = [wire_map[x] for x in old_node.qargs]
-            m_cargs = [wire_map[x] for x in old_node.cargs]
-            old_instruction = old_node._to_circuit_instruction()
-            if m_op is None:
-                new_instruction = old_instruction.replace(qubits=m_qargs, clbits=m_cargs)
-            else:
-                new_instruction = old_instruction.replace(
-                    operation=m_op, qubits=m_qargs, clbits=m_cargs
-                )
-            new_node = DAGOpNode.from_instruction(new_instruction)
-            new_node._node_id = new_node_index
-            self._multi_graph[new_node_index] = new_node
-            self._increment_op(new_node.name)
-
-        return {k: self._multi_graph[v] for k, v in node_map.items()}
-
-    def substitute_node(self, node: DAGOpNode, op, inplace: bool = False, propagate_condition=True):
-        """Replace an DAGOpNode with a single operation. qargs, cargs and
-        conditions for the new operation will be inferred from the node to be
-        replaced. The new operation will be checked to match the shape of the
-        replaced operation.
-
-        Args:
-            node (DAGOpNode): Node to be replaced
-            op (qiskit.circuit.Operation): The :class:`qiskit.circuit.Operation`
-                instance to be added to the DAG
-            inplace (bool): Optional, default False. If True, existing DAG node
-                will be modified to include op. Otherwise, a new DAG node will
-                be used.
-            propagate_condition (bool): Optional, default True.  If True, a condition on the
-                ``node`` to be replaced will be applied to the new ``op``.  This is the legacy
-                behavior.  If either node is a control-flow operation, this will be ignored.  If
-                the ``op`` already has a condition, :exc:`.DAGCircuitError` is raised.
-
-        Returns:
-            DAGOpNode: the new node containing the added operation.
-
-        Raises:
-            DAGCircuitError: If replacement operation was incompatible with
-            location of target node.
-        """
-
-        if not isinstance(node, DAGOpNode):
-            raise DAGCircuitError("Only DAGOpNodes can be replaced.")
-
-        if node.op.num_qubits != op.num_qubits or node.op.num_clbits != op.num_clbits:
-            raise DAGCircuitError(
-                f"Cannot replace node of width ({node.op.num_qubits} qubits, "
-                f"{node.op.num_clbits} clbits) with "
-                f"operation of mismatched width ({op.num_qubits} qubits, "
-                f"{op.num_clbits} clbits)."
-            )
-
-        # This might include wires that are inherent to the node, like in its `condition` or
-        # `target` fields, so might be wider than `node.op.num_{qu,cl}bits`.
-        current_wires = {wire for _, _, wire in self.edges(node)}
-        new_wires = set(node.qargs) | set(node.cargs) | set(_additional_wires(op))
-
-        if propagate_condition and not (
-            isinstance(node.op, ControlFlowOp) or isinstance(op, ControlFlowOp)
-        ):
-            if getattr(op, "condition", None) is not None:
-                raise DAGCircuitError(
-                    "Cannot propagate a condition to an operation that already has one."
-                )
-            if (old_condition := getattr(node.op, "condition", None)) is not None:
-                if not isinstance(op, Instruction):
-                    raise DAGCircuitError("Cannot add a condition on a generic Operation.")
-                if not isinstance(node.op, ControlFlowOp):
-                    op = op.c_if(*old_condition)
-                else:
-                    op.condition = old_condition
-                new_wires.update(condition_resources(old_condition).clbits)
-
-        if new_wires != current_wires:
-            # The new wires must be a non-strict subset of the current wires; if they add new wires,
-            # we'd not know where to cut the existing wire to insert the new dependency.
-            raise DAGCircuitError(
-                f"New operation '{op}' does not span the same wires as the old node '{node}'."
-                f" New wires: {new_wires}, old wires: {current_wires}."
-            )
-
-        if inplace:
-            if op.name != node.op.name:
-                self._increment_op(op.name)
-                self._decrement_op(node.name)
-            node.op = op
-            return node
-
-        new_node = copy.copy(node)
-        new_node.op = op
-        self._multi_graph[node._node_id] = new_node
-        if op.name != node.name:
-            self._increment_op(op.name)
-            self._decrement_op(node.name)
-        return new_node
-
-    def separable_circuits(
-        self, remove_idle_qubits: bool = False, *, vars_mode: _VarsMode = "alike"
-    ) -> list["DAGCircuit"]:
-        """Decompose the circuit into sets of qubits with no gates connecting them.
-
-        Args:
-            remove_idle_qubits (bool): Flag denoting whether to remove idle qubits from
-                the separated circuits. If ``False``, each output circuit will contain the
-                same number of qubits as ``self``.
-            vars_mode: how any realtime :class:`~.expr.Var` nodes should be handled in the output
-                DAGs.  See :meth:`copy_empty_like` for details on the modes.
-
-        Returns:
-            List[DAGCircuit]: The circuits resulting from separating ``self`` into sets
-                of disconnected qubits
-
-        Each :class:`~.DAGCircuit` instance returned by this method will contain the same number of
-        clbits as ``self``. The global phase information in ``self`` will not be maintained
-        in the subcircuits returned by this method.
-        """
-        connected_components = rx.weakly_connected_components(self._multi_graph)
-
-        # Collect each disconnected subgraph
-        disconnected_subgraphs = []
-        for components in connected_components:
-            disconnected_subgraphs.append(self._multi_graph.subgraph(list(components)))
-
-        # Helper function for ensuring rustworkx nodes are returned in lexicographical,
-        # topological order
-        def _key(x):
-            return x.sort_key
-
-        # Create new DAGCircuit objects from each of the rustworkx subgraph objects
-        decomposed_dags = []
-        for subgraph in disconnected_subgraphs:
-            new_dag = self.copy_empty_like(vars_mode=vars_mode)
-            new_dag.global_phase = 0
-            subgraph_is_classical = True
-            for node in rx.lexicographical_topological_sort(subgraph, key=_key):
-                if isinstance(node, DAGInNode):
-                    if isinstance(node.wire, Qubit):
-                        subgraph_is_classical = False
-                if not isinstance(node, DAGOpNode):
-                    continue
-                new_dag.apply_operation_back(node.op, node.qargs, node.cargs, check=False)
-
-            # Ignore DAGs created for empty clbits
-            if not subgraph_is_classical:
-                decomposed_dags.append(new_dag)
-
-        if remove_idle_qubits:
-            for dag in decomposed_dags:
-                dag.remove_qubits(*(bit for bit in dag.idle_wires() if isinstance(bit, Qubit)))
-
-        return decomposed_dags
-
-    def swap_nodes(self, node1, node2):
-        """Swap connected nodes e.g. due to commutation.
-
-        Args:
-            node1 (OpNode): predecessor node
-            node2 (OpNode): successor node
-
-        Raises:
-            DAGCircuitError: if either node is not an OpNode or nodes are not connected
-        """
-        if not (isinstance(node1, DAGOpNode) and isinstance(node2, DAGOpNode)):
-            raise DAGCircuitError("nodes to swap are not both DAGOpNodes")
-        try:
-            connected_edges = self._multi_graph.get_all_edge_data(node1._node_id, node2._node_id)
-        except rx.NoEdgeBetweenNodes as no_common_edge:
-            raise DAGCircuitError("attempt to swap unconnected nodes") from no_common_edge
-        node1_id = node1._node_id
-        node2_id = node2._node_id
-        for edge in connected_edges[::-1]:
-            edge_find = lambda x, y=edge: x == y
-            edge_parent = self._multi_graph.find_predecessors_by_edge(node1_id, edge_find)[0]
-            self._multi_graph.remove_edge(edge_parent._node_id, node1_id)
-            self._multi_graph.add_edge(edge_parent._node_id, node2_id, edge)
-            edge_child = self._multi_graph.find_successors_by_edge(node2_id, edge_find)[0]
-            self._multi_graph.remove_edge(node1_id, node2_id)
-            self._multi_graph.add_edge(node2_id, node1_id, edge)
-            self._multi_graph.remove_edge(node2_id, edge_child._node_id)
-            self._multi_graph.add_edge(node1_id, edge_child._node_id, edge)
-
-    def node(self, node_id):
-        """Get the node in the dag.
-
-        Args:
-            node_id(int): Node identifier.
-
-        Returns:
-            node: the node.
-        """
-        return self._multi_graph[node_id]
-
-    def nodes(self):
-        """Iterator for node values.
-
-        Yield:
-            node: the node.
-        """
-        yield from self._multi_graph.nodes()
-
-    def edges(self, nodes=None):
-        """Iterator for edge values and source and dest node
-
-        This works by returning the output edges from the specified nodes. If
-        no nodes are specified all edges from the graph are returned.
-
-        Args:
-            nodes(DAGOpNode, DAGInNode, or DAGOutNode|list(DAGOpNode, DAGInNode, or DAGOutNode):
-                Either a list of nodes or a single input node. If none is specified,
-                all edges are returned from the graph.
-
-        Yield:
-            edge: the edge in the same format as out_edges the tuple
-                (source node, destination node, edge data)
-        """
-        if nodes is None:
-            nodes = self._multi_graph.nodes()
-
-        elif isinstance(nodes, (DAGOpNode, DAGInNode, DAGOutNode)):
-            nodes = [nodes]
-        for node in nodes:
-            raw_nodes = self._multi_graph.out_edges(node._node_id)
-            for source, dest, edge in raw_nodes:
-                yield (self._multi_graph[source], self._multi_graph[dest], edge)
-
-    def op_nodes(self, op=None, include_directives=True):
-        """Get the list of "op" nodes in the dag.
-
-        Args:
-            op (Type): :class:`qiskit.circuit.Operation` subclass op nodes to
-                return. If None, return all op nodes.
-            include_directives (bool): include `barrier`, `snapshot` etc.
-
-        Returns:
-            list[DAGOpNode]: the list of node ids containing the given op.
-        """
-        nodes = []
-        filter_is_nonstandard = getattr(op, "_standard_gate", None) is None
-        for node in self._multi_graph.nodes():
-            if isinstance(node, DAGOpNode):
-                if not include_directives and node.is_directive():
-                    continue
-                if op is None or (
-                    # This middle catch is to avoid Python-space operation creation for most uses of
-                    # `op`; we're usually just looking for control-flow ops, and standard gates
-                    # aren't control-flow ops.
-                    not (filter_is_nonstandard and node.is_standard_gate())
-                    and isinstance(node.op, op)
-                ):
-                    nodes.append(node)
-        return nodes
-
-    def gate_nodes(self):
-        """Get the list of gate nodes in the dag.
-
-        Returns:
-            list[DAGOpNode]: the list of DAGOpNodes that represent gates.
-        """
-        nodes = []
-        for node in self.op_nodes():
-            if isinstance(node.op, Gate):
-                nodes.append(node)
-        return nodes
-
-    def named_nodes(self, *names):
-        """Get the set of "op" nodes with the given name."""
-        named_nodes = []
-        for node in self._multi_graph.nodes():
-            if isinstance(node, DAGOpNode) and node.name in names:
-                named_nodes.append(node)
-        return named_nodes
-
-    def two_qubit_ops(self):
-        """Get list of 2 qubit operations. Ignore directives like snapshot and barrier."""
-        ops = []
-        for node in self.op_nodes(include_directives=False):
-            if len(node.qargs) == 2:
-                ops.append(node)
-        return ops
-
-    def multi_qubit_ops(self):
-        """Get list of 3+ qubit operations. Ignore directives like snapshot and barrier."""
-        ops = []
-        for node in self.op_nodes(include_directives=False):
-            if len(node.qargs) >= 3:
-                ops.append(node)
-        return ops
-
-    def longest_path(self):
-        """Returns the longest path in the dag as a list of DAGOpNodes, DAGInNodes, and DAGOutNodes."""
-        return [self._multi_graph[x] for x in rx.dag_longest_path(self._multi_graph)]
-
-    def successors(self, node):
-        """Returns iterator of the successors of a node as DAGOpNodes and DAGOutNodes."""
-        return iter(self._multi_graph.successors(node._node_id))
-
-    def predecessors(self, node):
-        """Returns iterator of the predecessors of a node as DAGOpNodes and DAGInNodes."""
-        return iter(self._multi_graph.predecessors(node._node_id))
-
-    def op_successors(self, node):
-        """Returns iterator of "op" successors of a node in the dag."""
-        return (succ for succ in self.successors(node) if isinstance(succ, DAGOpNode))
-
-    def op_predecessors(self, node):
-        """Returns the iterator of "op" predecessors of a node in the dag."""
-        return (pred for pred in self.predecessors(node) if isinstance(pred, DAGOpNode))
-
-    def is_successor(self, node, node_succ):
-        """Checks if a second node is in the successors of node."""
-        return self._multi_graph.has_edge(node._node_id, node_succ._node_id)
-
-    def is_predecessor(self, node, node_pred):
-        """Checks if a second node is in the predecessors of node."""
-        return self._multi_graph.has_edge(node_pred._node_id, node._node_id)
-
-    def quantum_predecessors(self, node):
-        """Returns iterator of the predecessors of a node that are
-        connected by a quantum edge as DAGOpNodes and DAGInNodes."""
-        return iter(
-            self._multi_graph.find_predecessors_by_edge(
-                node._node_id, lambda edge_data: isinstance(edge_data, Qubit)
-            )
-        )
-
-    def classical_predecessors(self, node):
-        """Returns iterator of the predecessors of a node that are
-        connected by a classical edge as DAGOpNodes and DAGInNodes."""
-        return iter(
-            self._multi_graph.find_predecessors_by_edge(
-                node._node_id, lambda edge_data: not isinstance(edge_data, Qubit)
-            )
-        )
-
-    def ancestors(self, node):
-        """Returns set of the ancestors of a node as DAGOpNodes and DAGInNodes."""
-        return {self._multi_graph[x] for x in rx.ancestors(self._multi_graph, node._node_id)}
-
-    def descendants(self, node):
-        """Returns set of the descendants of a node as DAGOpNodes and DAGOutNodes."""
-        return {self._multi_graph[x] for x in rx.descendants(self._multi_graph, node._node_id)}
-
-    def bfs_successors(self, node):
-        """
-        Returns an iterator of tuples of (DAGNode, [DAGNodes]) where the DAGNode is the current node
-        and [DAGNode] is its successors in  BFS order.
-        """
-        return iter(rx.bfs_successors(self._multi_graph, node._node_id))
-
-    def quantum_successors(self, node):
-        """Returns iterator of the successors of a node that are
-        connected by a quantum edge as Opnodes and DAGOutNodes."""
-        return iter(
-            self._multi_graph.find_successors_by_edge(
-                node._node_id, lambda edge_data: isinstance(edge_data, Qubit)
-            )
-        )
-
-    def classical_successors(self, node):
-        """Returns iterator of the successors of a node that are
-        connected by a classical edge as DAGOpNodes and DAGInNodes."""
-        return iter(
-            self._multi_graph.find_successors_by_edge(
-                node._node_id, lambda edge_data: not isinstance(edge_data, Qubit)
-            )
-        )
-
-    def remove_op_node(self, node):
-        """Remove an operation node n.
-
-        Add edges from predecessors to successors.
-        """
-        if not isinstance(node, DAGOpNode):
-            raise DAGCircuitError(
-                f'The method remove_op_node only works on DAGOpNodes. A "{type(node)}" '
-                "node type was wrongly provided."
-            )
-
-        self._multi_graph.remove_node_retain_edges_by_id(node._node_id)
-        self._decrement_op(node.name)
-
-    def remove_ancestors_of(self, node):
-        """Remove all of the ancestor operation nodes of node."""
-        anc = rx.ancestors(self._multi_graph, node)
-        # TODO: probably better to do all at once using
-        # multi_graph.remove_nodes_from; same for related functions ...
-
-        for anc_node in anc:
-            if isinstance(anc_node, DAGOpNode):
-                self.remove_op_node(anc_node)
-
-    def remove_descendants_of(self, node):
-        """Remove all of the descendant operation nodes of node."""
-        desc = rx.descendants(self._multi_graph, node)
-        for desc_node in desc:
-            if isinstance(desc_node, DAGOpNode):
-                self.remove_op_node(desc_node)
-
-    def remove_nonancestors_of(self, node):
-        """Remove all of the non-ancestors operation nodes of node."""
-        anc = rx.ancestors(self._multi_graph, node)
-        comp = list(set(self._multi_graph.nodes()) - set(anc))
-        for n in comp:
-            if isinstance(n, DAGOpNode):
-                self.remove_op_node(n)
-
-    def remove_nondescendants_of(self, node):
-        """Remove all of the non-descendants operation nodes of node."""
-        dec = rx.descendants(self._multi_graph, node)
-        comp = list(set(self._multi_graph.nodes()) - set(dec))
-        for n in comp:
-            if isinstance(n, DAGOpNode):
-                self.remove_op_node(n)
-
-    def front_layer(self):
-        """Return a list of op nodes in the first layer of this dag."""
-        graph_layers = self.multigraph_layers()
-        try:
-            next(graph_layers)  # Remove input nodes
-        except StopIteration:
-            return []
-
-        op_nodes = [node for node in next(graph_layers) if isinstance(node, DAGOpNode)]
-
-        return op_nodes
-
-    def layers(self, *, vars_mode: _VarsMode = "captures"):
-        """Yield a shallow view on a layer of this DAGCircuit for all d layers of this circuit.
-
-        A layer is a circuit whose gates act on disjoint qubits, i.e.,
-        a layer has depth 1. The total number of layers equals the
-        circuit depth d. The layers are indexed from 0 to d-1 with the
-        earliest layer at index 0. The layers are constructed using a
-        greedy algorithm. Each returned layer is a dict containing
-        {"graph": circuit graph, "partition": list of qubit lists}.
-
-        The returned layer contains new (but semantically equivalent) DAGOpNodes, DAGInNodes,
-        and DAGOutNodes. These are not the same as nodes of the original dag, but are equivalent
-        via DAGNode.semantic_eq(node1, node2).
-
-        TODO: Gates that use the same cbits will end up in different
-        layers as this is currently implemented. This may not be
-        the desired behavior.
-
-        Args:
-            vars_mode: how any realtime :class:`~.expr.Var` nodes should be handled in the output
-                DAGs.  See :meth:`copy_empty_like` for details on the modes.
-        """
-        graph_layers = self.multigraph_layers()
-        try:
-            next(graph_layers)  # Remove input nodes
-        except StopIteration:
-            return
-
-        for graph_layer in graph_layers:
-
-            # Get the op nodes from the layer, removing any input and output nodes.
-            op_nodes = [node for node in graph_layer if isinstance(node, DAGOpNode)]
-
-            # Sort to make sure they are in the order they were added to the original DAG
-            # It has to be done by node_id as graph_layer is just a list of nodes
-            # with no implied topology
-            # Drawing tools rely on _node_id to infer order of node creation
-            # so we need this to be preserved by layers()
-            op_nodes.sort(key=lambda nd: nd._node_id)
-
-            # Stop yielding once there are no more op_nodes in a layer.
-            if not op_nodes:
-                return
-
-            # Construct a shallow copy of self
-            new_layer = self.copy_empty_like(vars_mode=vars_mode)
-
-            for node in op_nodes:
-                new_layer._apply_op_node_back(node, check=False)
-
-            # The quantum registers that have an operation in this layer.
-            support_list = [
-                op_node.qargs for op_node in new_layer.op_nodes() if not op_node.is_directive()
-            ]
-
-            yield {"graph": new_layer, "partition": support_list}
-
-    def serial_layers(self, *, vars_mode: _VarsMode = "captures"):
-        """Yield a layer for all gates of this circuit.
-
-        A serial layer is a circuit with one gate. The layers have the
-        same structure as in layers().
-
-        Args:
-            vars_mode: how any realtime :class:`~.expr.Var` nodes should be handled in the output
-                DAGs.  See :meth:`copy_empty_like` for details on the modes.
-        """
-        for next_node in self.topological_op_nodes():
-            new_layer = self.copy_empty_like(vars_mode=vars_mode)
-
-            # Save the support of the operation we add to the layer
-            support_list = []
-            # Operation data
-            op = copy.copy(next_node.op)
-            qargs = copy.copy(next_node.qargs)
-            cargs = copy.copy(next_node.cargs)
-
-            # Add node to new_layer
-            new_layer.apply_operation_back(op, qargs, cargs, check=False)
-            # Add operation to partition
-            if not getattr(next_node.op, "_directive", False):
-                support_list.append(list(qargs))
-            l_dict = {"graph": new_layer, "partition": support_list}
-            yield l_dict
-
-    def multigraph_layers(self):
-        """Yield layers of the multigraph."""
-        first_layer = [x._node_id for x in self.input_map.values()]
-        return iter(rx.layers(self._multi_graph, first_layer))
-
-    def collect_runs(self, namelist):
-        """Return a set of non-conditional runs of "op" nodes with the given names.
-
-        For example, "... h q[0]; cx q[0],q[1]; cx q[0],q[1]; h q[1]; .."
-        would produce the tuple of cx nodes as an element of the set returned
-        from a call to collect_runs(["cx"]). If instead the cx nodes were
-        "cx q[0],q[1]; cx q[1],q[0];", the method would still return the
-        pair in a tuple. The namelist can contain names that are not
-        in the circuit's basis.
-
-        Nodes must have only one successor to continue the run.
-        """
-
-        def filter_fn(node):
-            return isinstance(node, DAGOpNode) and node.name in namelist and node.condition is None
-
-        group_list = rx.collect_runs(self._multi_graph, filter_fn)
-        return {tuple(x) for x in group_list}
-
-    def collect_1q_runs(self) -> list[list[DAGOpNode]]:
-        """Return a set of non-conditional runs of 1q "op" nodes."""
-        return rx.collect_runs(self._multi_graph, collect_1q_runs_filter)
-
-    def collect_2q_runs(self):
-        """Return a set of non-conditional runs of 2q "op" nodes."""
-
-        def color_fn(edge):
-            if isinstance(edge, Qubit):
-                return self.find_bit(edge).index
-            else:
-                return None
-
-        return rx.collect_bicolor_runs(self._multi_graph, collect_2q_blocks_filter, color_fn)
-
-    def nodes_on_wire(self, wire, only_ops=False):
-        """
-        Iterator for nodes that affect a given wire.
-
-        Args:
-            wire (Bit): the wire to be looked at.
-            only_ops (bool): True if only the ops nodes are wanted;
-                        otherwise, all nodes are returned.
-        Yield:
-             Iterator: the successive nodes on the given wire
-
-        Raises:
-            DAGCircuitError: if the given wire doesn't exist in the DAG
-        """
-        current_node = self.input_map.get(wire, None)
-
-        if not current_node:
-            raise DAGCircuitError(f"The given wire {str(wire)} is not present in the circuit")
-
-        more_nodes = True
-        while more_nodes:
-            more_nodes = False
-            # allow user to just get ops on the wire - not the input/output nodes
-            if isinstance(current_node, DAGOpNode) or not only_ops:
-                yield current_node
-
-            try:
-                current_node = self._multi_graph.find_adjacent_node_by_edge(
-                    current_node._node_id, lambda x: wire == x
-                )
-                more_nodes = True
-            except rx.NoSuitableNeighbors:
-                pass
-
-    def count_ops(self, *, recurse: bool = True):
-        """Count the occurrences of operation names.
-
-        Args:
-            recurse: if ``True`` (default), then recurse into control-flow operations.  In all
-                cases, this counts only the number of times the operation appears in any possible
-                block; both branches of if-elses are counted, and for- and while-loop blocks are
-                only counted once.
-
-        Returns:
-            Mapping[str, int]: a mapping of operation names to the number of times it appears.
-        """
-        if not recurse or not CONTROL_FLOW_OP_NAMES.intersection(self._op_names):
-            return self._op_names.copy()
-
-        # pylint: disable=cyclic-import
-        from qiskit.converters import circuit_to_dag
-
-        def inner(dag, counts):
-            for name, count in dag._op_names.items():
-                counts[name] += count
-            for node in dag.op_nodes(ControlFlowOp):
-                for block in node.op.blocks:
-                    counts = inner(circuit_to_dag(block), counts)
-            return counts
-
-        return dict(inner(self, defaultdict(int)))
-
-    def count_ops_longest_path(self):
-        """Count the occurrences of operation names on the longest path.
-
-        Returns a dictionary of counts keyed on the operation name.
-        """
-        op_dict = {}
-        path = self.longest_path()
-        path = path[1:-1]  # remove qubits at beginning and end of path
-        for node in path:
-            name = node.op.name
-            if name not in op_dict:
-                op_dict[name] = 1
-            else:
-                op_dict[name] += 1
-        return op_dict
-
-    def quantum_causal_cone(self, qubit):
-        """
-        Returns causal cone of a qubit.
-
-        A qubit's causal cone is the set of qubits that can influence the output of that
-        qubit through interactions, whether through multi-qubit gates or operations. Knowing
-        the causal cone of a qubit can be useful when debugging faulty circuits, as it can
-        help identify which wire(s) may be causing the problem.
-
-        This method does not consider any classical data dependency in the ``DAGCircuit``,
-        classical bit wires are ignored for the purposes of building the causal cone.
-
-        Args:
-            qubit (~qiskit.circuit.Qubit): The output qubit for which we want to find the causal cone.
-
-        Returns:
-            Set[~qiskit.circuit.Qubit]: The set of qubits whose interactions affect ``qubit``.
-        """
-        # Retrieve the output node from the qubit
-        output_node = self.output_map.get(qubit, None)
-        if not output_node:
-            raise DAGCircuitError(f"Qubit {qubit} is not part of this circuit.")
-
-        qubits_in_cone = {qubit}
-        queue = deque(self.quantum_predecessors(output_node))
-
-        # The processed_non_directive_nodes stores the set of processed non-directive nodes.
-        # This is an optimization to avoid considering the same non-directive node multiple
-        # times when reached from different paths.
-        # The directive nodes (such as barriers or measures) are trickier since when processing
-        # them we only add their predecessors that intersect qubits_in_cone. Hence, directive
-        # nodes have to be considered multiple times.
-        processed_non_directive_nodes = set()
-
-        while queue:
-            node_to_check = queue.popleft()
-
-            if isinstance(node_to_check, DAGOpNode):
-                # If the operation is not a directive (in particular not a barrier nor a measure),
-                # we do not do anything if it was already processed. Otherwise, we add its qubits
-                # to qubits_in_cone, and append its predecessors to queue.
-                if not getattr(node_to_check.op, "_directive"):
-                    if node_to_check in processed_non_directive_nodes:
-                        continue
-                    qubits_in_cone = qubits_in_cone.union(set(node_to_check.qargs))
-                    processed_non_directive_nodes.add(node_to_check)
-                    for pred in self.quantum_predecessors(node_to_check):
-                        if isinstance(pred, DAGOpNode):
-                            queue.append(pred)
-                else:
-                    # Directives (such as barriers and measures) may be defined over all the qubits,
-                    # yet not all of these qubits should be considered in the causal cone. So we
-                    # only add those predecessors that have qubits in common with qubits_in_cone.
-                    for pred in self.quantum_predecessors(node_to_check):
-                        if isinstance(pred, DAGOpNode) and not qubits_in_cone.isdisjoint(
-                            set(pred.qargs)
-                        ):
-                            queue.append(pred)
-
-        return qubits_in_cone
-
-    def properties(self):
-        """Return a dictionary of circuit properties."""
-        summary = {
-            "size": self.size(),
-            "depth": self.depth(),
-            "width": self.width(),
-            "qubits": self.num_qubits(),
-            "bits": self.num_clbits(),
-            "factors": self.num_tensor_factors(),
-            "operations": self.count_ops(),
-        }
-        return summary
-
-    def draw(self, scale=0.7, filename=None, style="color"):
-        """
-        Draws the dag circuit.
-
-        This function needs `Graphviz <https://www.graphviz.org/>`_ to be
-        installed. Graphviz is not a python package and can't be pip installed
-        (the ``graphviz`` package on PyPI is a Python interface library for
-        Graphviz and does not actually install Graphviz). You can refer to
-        `the Graphviz documentation <https://www.graphviz.org/download/>`__ on
-        how to install it.
-
-        Args:
-            scale (float): scaling factor
-            filename (str): file path to save image to (format inferred from name)
-            style (str):
-                'plain': B&W graph;
-                'color' (default): color input/output/op nodes
-
-        Returns:
-            Ipython.display.Image: if in Jupyter notebook and not saving to file,
-            otherwise None.
-        """
-        from qiskit.visualization.dag_visualization import dag_drawer
-
-        return dag_drawer(dag=self, scale=scale, filename=filename, style=style)
-
-
-class _DAGVarType(enum.Enum):
-    INPUT = enum.auto()
-    CAPTURE = enum.auto()
-    DECLARE = enum.auto()
-
-
-class _DAGVarInfo:
-    __slots__ = ("var", "type", "in_node", "out_node")
-
-    def __init__(self, var: expr.Var, type_: _DAGVarType, in_node: DAGInNode, out_node: DAGOutNode):
-        self.var = var
-        self.type = type_
-        self.in_node = in_node
-        self.out_node = out_node
-
-
-def _may_have_additional_wires(node) -> bool:
-    """Return whether a given :class:`.DAGOpNode` may contain references to additional wires
-    locations within its :class:`.Operation`.  If this is ``True``, it doesn't necessarily mean
-    that the operation _will_ access memory inherently, but a ``False`` return guarantees that it
-    won't.
-
-    The memory might be classical bits or classical variables, such as a control-flow operation or a
-    store.
-
-    Args:
-        operation (qiskit.dagcircuit.DAGOpNode): the operation to check.
-    """
-    # This is separate to `_additional_wires` because most of the time there won't be any extra
-    # wires beyond the explicit `qargs` and `cargs` so we want a fast path to be able to skip
-    # creating and testing a generator for emptiness.
-    #
-    # If updating this, you most likely also need to update `_additional_wires`.
-    return node.condition is not None or (
-        not node.is_standard_gate() and isinstance(node.op, (ControlFlowOp, Store))
-    )
-
-
-def _additional_wires(operation) -> Iterable[Clbit | expr.Var]:
-    """Return an iterable over the additional tracked memory usage in this operation.  These
-    additional wires include (for example, non-exhaustive) bits referred to by a ``condition`` or
-    the classical variables involved in control-flow operations.
-
-    Args:
-        operation: the :class:`~.circuit.Operation` instance for a node.
-
-    Returns:
-        Iterable: the additional wires inherent to this operation.
-    """
-    # If updating this, you likely need to update `_may_have_additional_wires` too.
-    if (condition := getattr(operation, "condition", None)) is not None:
-        if isinstance(condition, expr.Expr):
-            yield from _wires_from_expr(condition)
-        else:
-            yield from condition_resources(condition).clbits
-    if isinstance(operation, ControlFlowOp):
-        yield from operation.iter_captured_vars()
-        if isinstance(operation, SwitchCaseOp):
-            target = operation.target
-            if isinstance(target, Clbit):
-                yield target
-            elif isinstance(target, ClassicalRegister):
-                yield from target
-            else:
-                yield from _wires_from_expr(target)
-    elif isinstance(operation, Store):
-        yield from _wires_from_expr(operation.lvalue)
-        yield from _wires_from_expr(operation.rvalue)
-
-
-def _wires_from_expr(node: expr.Expr) -> Iterable[Clbit | expr.Var]:
-    for var in expr.iter_vars(node):
-        if isinstance(var.var, Clbit):
-            yield var.var
-        elif isinstance(var.var, ClassicalRegister):
-            yield from var.var
-        else:
-            yield var
+from qiskit._accelerate.circuit import DAGCircuit  # pylint: disable=unused-import
diff --git a/qiskit/dagcircuit/dagnode.py b/qiskit/dagcircuit/dagnode.py
index 9f35f6eda898..60e2a7465707 100644
--- a/qiskit/dagcircuit/dagnode.py
+++ b/qiskit/dagcircuit/dagnode.py
@@ -21,7 +21,6 @@
 from qiskit.circuit import (
     Clbit,
     ClassicalRegister,
-    ControlFlowOp,
     IfElseOp,
     WhileLoopOp,
     SwitchCaseOp,
@@ -175,67 +174,3 @@ def _for_loop_eq(node1, node2, bit_indices1, bit_indices2):
 }
 
 _SEMANTIC_EQ_SYMMETRIC = frozenset({"barrier", "swap", "break_loop", "continue_loop"})
-
-
-# Note: called from dag_node.rs.
-def _semantic_eq(node1, node2, bit_indices1, bit_indices2):
-    """
-    Check if DAG nodes are considered equivalent, e.g., as a node_match for
-    :func:`rustworkx.is_isomorphic_node_match`.
-
-    Args:
-        node1 (DAGOpNode, DAGInNode, DAGOutNode): A node to compare.
-        node2 (DAGOpNode, DAGInNode, DAGOutNode): The other node to compare.
-        bit_indices1 (dict): Dictionary mapping Bit instances to their index
-            within the circuit containing node1
-        bit_indices2 (dict): Dictionary mapping Bit instances to their index
-            within the circuit containing node2
-
-    Return:
-        Bool: If node1 == node2
-    """
-    if not isinstance(node1, DAGOpNode) or not isinstance(node1, DAGOpNode):
-        return type(node1) is type(node2) and bit_indices1.get(node1.wire) == bit_indices2.get(
-            node2.wire
-        )
-    if isinstance(node1.op, ControlFlowOp) and isinstance(node2.op, ControlFlowOp):
-        # While control-flow operations aren't represented natively in the DAG, we have to do
-        # some unpleasant dispatching and very manual handling.  Once they have more first-class
-        # support we'll still be dispatching, but it'll look more appropriate (like the dispatch
-        # based on `DAGOpNode`/`DAGInNode`/`DAGOutNode` that already exists) and less like we're
-        # duplicating code from the `ControlFlowOp` classes.
-        if type(node1.op) is not type(node2.op):
-            return False
-        comparer = _SEMANTIC_EQ_CONTROL_FLOW.get(type(node1.op))
-        if comparer is None:  # pragma: no cover
-            raise RuntimeError(f"unhandled control-flow operation: {type(node1.op)}")
-        return comparer(node1, node2, bit_indices1, bit_indices2)
-
-    node1_qargs = [bit_indices1[qarg] for qarg in node1.qargs]
-    node1_cargs = [bit_indices1[carg] for carg in node1.cargs]
-
-    node2_qargs = [bit_indices2[qarg] for qarg in node2.qargs]
-    node2_cargs = [bit_indices2[carg] for carg in node2.cargs]
-
-    # For barriers, qarg order is not significant so compare as sets
-    if node1.op.name == node2.op.name and node1.name in _SEMANTIC_EQ_SYMMETRIC:
-        node1_qargs = set(node1_qargs)
-        node1_cargs = set(node1_cargs)
-        node2_qargs = set(node2_qargs)
-        node2_cargs = set(node2_cargs)
-
-    return (
-        node1_qargs == node2_qargs
-        and node1_cargs == node2_cargs
-        and _legacy_condition_eq(
-            getattr(node1.op, "condition", None),
-            getattr(node2.op, "condition", None),
-            bit_indices1,
-            bit_indices2,
-        )
-        and node1.op == node2.op
-    )
-
-
-# Bind semantic_eq from Python to Rust implementation
-DAGNode.semantic_eq = staticmethod(_semantic_eq)
diff --git a/qiskit/synthesis/two_qubit/two_qubit_decompose.py b/qiskit/synthesis/two_qubit/two_qubit_decompose.py
index 86c5cba8295f..633de3a64f78 100644
--- a/qiskit/synthesis/two_qubit/two_qubit_decompose.py
+++ b/qiskit/synthesis/two_qubit/two_qubit_decompose.py
@@ -639,7 +639,8 @@ def __call__(
         """
 
         if use_dag:
-            from qiskit.dagcircuit.dagcircuit import DAGCircuit, DAGOpNode
+            from qiskit.dagcircuit.dagcircuit import DAGCircuit
+            from qiskit.dagcircuit.dagnode import DAGOpNode
 
             sequence = self._inner_decomposer(
                 np.asarray(unitary, dtype=complex),
@@ -659,7 +660,7 @@ def __call__(
                     op = CircuitInstruction.from_standard(
                         gate, qubits=tuple(q[x] for x in qubits), params=params
                     )
-                    node = DAGOpNode.from_instruction(op, dag=dag)
+                    node = DAGOpNode.from_instruction(op)
                     dag._apply_op_node_back(node)
             return dag
         else:
diff --git a/qiskit/transpiler/passes/basis/basis_translator.py b/qiskit/transpiler/passes/basis/basis_translator.py
index a5a3936b1d7e..5737385af15b 100644
--- a/qiskit/transpiler/passes/basis/basis_translator.py
+++ b/qiskit/transpiler/passes/basis/basis_translator.py
@@ -313,10 +313,7 @@ def _replace_node(self, dag, node, instr_map):
         if node.params:
             parameter_map = dict(zip(target_params, node.params))
             for inner_node in target_dag.topological_op_nodes():
-                new_node = DAGOpNode.from_instruction(
-                    inner_node._to_circuit_instruction(),
-                    dag=target_dag,
-                )
+                new_node = DAGOpNode.from_instruction(inner_node._to_circuit_instruction())
                 new_node.qargs = tuple(
                     node.qargs[target_dag.find_bit(x).index] for x in inner_node.qargs
                 )
@@ -366,7 +363,6 @@ def _replace_node(self, dag, node, instr_map):
             for inner_node in target_dag.topological_op_nodes():
                 new_node = DAGOpNode.from_instruction(
                     inner_node._to_circuit_instruction(),
-                    dag=target_dag,
                 )
                 new_node.qargs = tuple(
                     node.qargs[target_dag.find_bit(x).index] for x in inner_node.qargs
diff --git a/qiskit/transpiler/passes/basis/unroll_3q_or_more.py b/qiskit/transpiler/passes/basis/unroll_3q_or_more.py
index 73e1d4ac5484..0c6d780f052a 100644
--- a/qiskit/transpiler/passes/basis/unroll_3q_or_more.py
+++ b/qiskit/transpiler/passes/basis/unroll_3q_or_more.py
@@ -58,7 +58,9 @@ def run(self, dag):
                 continue
 
             if isinstance(node.op, ControlFlowOp):
-                node.op = control_flow.map_blocks(self.run, node.op)
+                dag.substitute_node(
+                    node, control_flow.map_blocks(self.run, node.op), propagate_condition=False
+                )
                 continue
 
             if self.target is not None:
diff --git a/qiskit/transpiler/passes/basis/unroll_custom_definitions.py b/qiskit/transpiler/passes/basis/unroll_custom_definitions.py
index 99bf95147ae2..51e116033bb6 100644
--- a/qiskit/transpiler/passes/basis/unroll_custom_definitions.py
+++ b/qiskit/transpiler/passes/basis/unroll_custom_definitions.py
@@ -66,7 +66,9 @@ def run(self, dag):
 
         for node in dag.op_nodes():
             if isinstance(node.op, ControlFlowOp):
-                node.op = control_flow.map_blocks(self.run, node.op)
+                dag.substitute_node(
+                    node, control_flow.map_blocks(self.run, node.op), propagate_condition=False
+                )
                 continue
 
             if getattr(node.op, "_directive", False):
diff --git a/qiskit/transpiler/passes/calibration/rzx_templates.py b/qiskit/transpiler/passes/calibration/rzx_templates.py
index 406e5e75de04..10f4d19ebd9e 100644
--- a/qiskit/transpiler/passes/calibration/rzx_templates.py
+++ b/qiskit/transpiler/passes/calibration/rzx_templates.py
@@ -20,17 +20,6 @@
 from qiskit.circuit.library.templates import rzx
 
 
-class RZXTemplateMap(Enum):
-    """Mapping of instruction name to decomposition template."""
-
-    ZZ1 = rzx.rzx_zz1()
-    ZZ2 = rzx.rzx_zz2()
-    ZZ3 = rzx.rzx_zz3()
-    YZ = rzx.rzx_yz()
-    XZ = rzx.rzx_xz()
-    CY = rzx.rzx_cy()
-
-
 def rzx_templates(template_list: List[str] = None) -> Dict:
     """Convenience function to get the cost_dict and templates for template matching.
 
@@ -40,6 +29,17 @@ def rzx_templates(template_list: List[str] = None) -> Dict:
     Returns:
         Decomposition templates and cost values.
     """
+
+    class RZXTemplateMap(Enum):
+        """Mapping of instruction name to decomposition template."""
+
+        ZZ1 = rzx.rzx_zz1()
+        ZZ2 = rzx.rzx_zz2()
+        ZZ3 = rzx.rzx_zz3()
+        YZ = rzx.rzx_yz()
+        XZ = rzx.rzx_xz()
+        CY = rzx.rzx_cy()
+
     if template_list is None:
         template_list = ["zz1", "zz2", "zz3", "yz", "xz", "cy"]
 
diff --git a/qiskit/transpiler/passes/layout/apply_layout.py b/qiskit/transpiler/passes/layout/apply_layout.py
index 629dc32061fc..7514ac6b421f 100644
--- a/qiskit/transpiler/passes/layout/apply_layout.py
+++ b/qiskit/transpiler/passes/layout/apply_layout.py
@@ -118,6 +118,6 @@ def run(self, dag):
                 }
                 out_layout = Layout(final_layout_mapping)
                 self.property_set["final_layout"] = out_layout
-        new_dag._global_phase = dag._global_phase
+        new_dag.global_phase = dag.global_phase
 
         return new_dag
diff --git a/qiskit/transpiler/passes/layout/sabre_layout.py b/qiskit/transpiler/passes/layout/sabre_layout.py
index 4ce94ecdb62f..7e7031ec3361 100644
--- a/qiskit/transpiler/passes/layout/sabre_layout.py
+++ b/qiskit/transpiler/passes/layout/sabre_layout.py
@@ -310,7 +310,7 @@ def run(self, dag):
             mapped_dag.add_captured_var(var)
         for var in dag.iter_declared_vars():
             mapped_dag.add_declared_var(var)
-        mapped_dag._global_phase = dag._global_phase
+        mapped_dag.global_phase = dag.global_phase
         self.property_set["original_qubit_indices"] = {
             bit: index for index, bit in enumerate(dag.qubits)
         }
diff --git a/qiskit/transpiler/passes/optimization/commutative_cancellation.py b/qiskit/transpiler/passes/optimization/commutative_cancellation.py
index adfc4d73a221..836fa112fd84 100644
--- a/qiskit/transpiler/passes/optimization/commutative_cancellation.py
+++ b/qiskit/transpiler/passes/optimization/commutative_cancellation.py
@@ -219,5 +219,7 @@ def _handle_control_flow_ops(self, dag):
             for block in node.op.blocks:
                 new_circ = pass_manager.run(block)
                 mapped_blocks.append(new_circ)
-            node.op = node.op.replace_blocks(mapped_blocks)
+            dag.substitute_node(
+                node, node.op.replace_blocks(mapped_blocks), propagate_condition=False
+            )
         return dag
diff --git a/qiskit/transpiler/passes/optimization/consolidate_blocks.py b/qiskit/transpiler/passes/optimization/consolidate_blocks.py
index 12f7285af9dc..49f227e8a746 100644
--- a/qiskit/transpiler/passes/optimization/consolidate_blocks.py
+++ b/qiskit/transpiler/passes/optimization/consolidate_blocks.py
@@ -202,7 +202,11 @@ def _handle_control_flow_ops(self, dag):
         for node in dag.op_nodes():
             if node.name not in CONTROL_FLOW_OP_NAMES:
                 continue
-            node.op = node.op.replace_blocks(pass_manager.run(block) for block in node.op.blocks)
+            dag.substitute_node(
+                node,
+                node.op.replace_blocks(pass_manager.run(block) for block in node.op.blocks),
+                propagate_condition=False,
+            )
         return dag
 
     def _check_not_in_basis(self, dag, gate_name, qargs):
diff --git a/qiskit/transpiler/passes/optimization/optimize_1q_decomposition.py b/qiskit/transpiler/passes/optimization/optimize_1q_decomposition.py
index e7c502c9ef9f..181f02e312b3 100644
--- a/qiskit/transpiler/passes/optimization/optimize_1q_decomposition.py
+++ b/qiskit/transpiler/passes/optimization/optimize_1q_decomposition.py
@@ -242,10 +242,8 @@ def run(self, dag):
                     qubit = run[0].qargs
                     for gate, angles in best_circuit_sequence:
                         op = CircuitInstruction.from_standard(gate, qubit, angles)
-                        node = DAGOpNode.from_instruction(op, dag=dag)
-                        node._node_id = dag._multi_graph.add_node(node)
-                        dag._increment_op(gate.name)
-                        dag._multi_graph.insert_node_on_in_edges(node._node_id, first_node_id)
+                        node = DAGOpNode.from_instruction(op)
+                        dag._insert_1q_on_incoming_qubit(node, first_node_id)
                     dag.global_phase += best_circuit_sequence.global_phase
                     # Delete the other nodes in the run
                     for current_node in run:
diff --git a/qiskit/transpiler/passes/optimization/optimize_annotated.py b/qiskit/transpiler/passes/optimization/optimize_annotated.py
index fe6fe7f49e78..0a583259c800 100644
--- a/qiskit/transpiler/passes/optimization/optimize_annotated.py
+++ b/qiskit/transpiler/passes/optimization/optimize_annotated.py
@@ -125,7 +125,9 @@ def _run_inner(self, dag) -> Tuple[DAGCircuit, bool]:
         # Handle control-flow
         for node in dag.op_nodes():
             if isinstance(node.op, ControlFlowOp):
-                node.op = control_flow.map_blocks(self.run, node.op)
+                dag.substitute_node(
+                    node, control_flow.map_blocks(self.run, node.op), propagate_condition=False
+                )
 
         # First, optimize every node in the DAG.
         dag, opt1 = self._canonicalize(dag)
@@ -163,7 +165,7 @@ def _canonicalize(self, dag) -> Tuple[DAGCircuit, bool]:
                 node.op.modifiers = canonical_modifiers
             else:
                 # no need for annotated operations
-                node.op = cur
+                dag.substitute_node(node, cur, propagate_condition=False)
             did_something = True
         return dag, did_something
 
diff --git a/qiskit/transpiler/passes/optimization/split_2q_unitaries.py b/qiskit/transpiler/passes/optimization/split_2q_unitaries.py
index 7508c9440a6e..ac04043a27fa 100644
--- a/qiskit/transpiler/passes/optimization/split_2q_unitaries.py
+++ b/qiskit/transpiler/passes/optimization/split_2q_unitaries.py
@@ -14,7 +14,8 @@
 
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.circuit.quantumcircuitdata import CircuitInstruction
-from qiskit.dagcircuit.dagcircuit import DAGCircuit, DAGOpNode
+from qiskit.dagcircuit.dagcircuit import DAGCircuit
+from qiskit.dagcircuit.dagnode import DAGOpNode
 from qiskit.circuit.library.generalized_gates import UnitaryGate
 from qiskit.synthesis.two_qubit.two_qubit_decompose import TwoQubitWeylDecomposition
 
@@ -60,12 +61,12 @@ def run(self, dag: DAGCircuit):
 
                 ur = decomp.K1r
                 ur_node = DAGOpNode.from_instruction(
-                    CircuitInstruction(UnitaryGate(ur), qubits=(node.qargs[0],)), dag=new_dag
+                    CircuitInstruction(UnitaryGate(ur), qubits=(node.qargs[0],))
                 )
 
                 ul = decomp.K1l
                 ul_node = DAGOpNode.from_instruction(
-                    CircuitInstruction(UnitaryGate(ul), qubits=(node.qargs[1],)), dag=new_dag
+                    CircuitInstruction(UnitaryGate(ul), qubits=(node.qargs[1],))
                 )
                 new_dag._apply_op_node_back(ur_node)
                 new_dag._apply_op_node_back(ul_node)
diff --git a/qiskit/transpiler/passes/routing/sabre_swap.py b/qiskit/transpiler/passes/routing/sabre_swap.py
index 788f0d995754..9edd1ceee445 100644
--- a/qiskit/transpiler/passes/routing/sabre_swap.py
+++ b/qiskit/transpiler/passes/routing/sabre_swap.py
@@ -372,7 +372,7 @@ def empty_dag(block):
         empty.add_clbits(block.clbits)
         for creg in block.cregs:
             empty.add_creg(creg)
-        empty._global_phase = block.global_phase
+        empty.global_phase = block.global_phase
         return empty
 
     def apply_swaps(dest_dag, swaps, layout):
@@ -388,7 +388,7 @@ def recurse(dest_dag, source_dag, result, root_logical_map, layout):
         the virtual qubit in the root source DAG that it is bound to."""
         swap_map, node_order, node_block_results = result
         for node_id in node_order:
-            node = source_dag._multi_graph[node_id]
+            node = source_dag.node(node_id)
             if node_id in swap_map:
                 apply_swaps(dest_dag, swap_map[node_id], layout)
             if not node.is_control_flow():
diff --git a/qiskit/transpiler/passes/routing/stochastic_swap.py b/qiskit/transpiler/passes/routing/stochastic_swap.py
index a3ebbd6cbdde..efbd7e37f626 100644
--- a/qiskit/transpiler/passes/routing/stochastic_swap.py
+++ b/qiskit/transpiler/passes/routing/stochastic_swap.py
@@ -223,7 +223,7 @@ def _layer_permutation(self, dag, layer_partition, layout, qubit_subset, couplin
         int_layout = nlayout.NLayout(layout_mapping, num_qubits, coupling.size())
 
         trial_circuit = DAGCircuit()  # SWAP circuit for slice of swaps in this trial
-        trial_circuit.add_qubits(layout.get_virtual_bits())
+        trial_circuit.add_qubits(list(layout.get_virtual_bits()))
 
         edges = np.asarray(coupling.get_edges(), dtype=np.uint32).ravel()
         cdist = coupling._dist_matrix
@@ -273,9 +273,7 @@ def _layer_update(self, dag, layer, best_layout, best_depth, best_circuit):
         # Output any swaps
         if best_depth > 0:
             logger.debug("layer_update: there are swaps in this layer, depth %d", best_depth)
-            dag.compose(
-                best_circuit, qubits={bit: bit for bit in best_circuit.qubits}, inline_captures=True
-            )
+            dag.compose(best_circuit, qubits=list(best_circuit.qubits), inline_captures=True)
         else:
             logger.debug("layer_update: there are no swaps in this layer")
         # Output this layer
diff --git a/qiskit/transpiler/passes/scheduling/padding/dynamical_decoupling.py b/qiskit/transpiler/passes/scheduling/padding/dynamical_decoupling.py
index 0e351161f7df..2217d32f847c 100644
--- a/qiskit/transpiler/passes/scheduling/padding/dynamical_decoupling.py
+++ b/qiskit/transpiler/passes/scheduling/padding/dynamical_decoupling.py
@@ -370,7 +370,10 @@ def _pad(
                 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)
-                prev_node.op = op
+                new_prev_node = dag.substitute_node(prev_node, op, propagate_condition=False)
+                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
diff --git a/qiskit/transpiler/passes/scheduling/scheduling/base_scheduler.py b/qiskit/transpiler/passes/scheduling/scheduling/base_scheduler.py
index 2c7c97ec856a..d9f3d77f2915 100644
--- a/qiskit/transpiler/passes/scheduling/scheduling/base_scheduler.py
+++ b/qiskit/transpiler/passes/scheduling/scheduling/base_scheduler.py
@@ -72,9 +72,9 @@ def _get_node_duration(
             # Note that node duration is updated (but this is analysis pass)
             op = node.op.to_mutable()
             op.duration = duration
-            node.op = op
+            dag.substitute_node(node, op, propagate_condition=False)
         else:
-            duration = node.op.duration
+            duration = node.duration
 
         if isinstance(duration, ParameterExpression):
             raise TranspilerError(
diff --git a/qiskit/transpiler/passes/scheduling/time_unit_conversion.py b/qiskit/transpiler/passes/scheduling/time_unit_conversion.py
index 08ac932d8aeb..f4f70210b785 100644
--- a/qiskit/transpiler/passes/scheduling/time_unit_conversion.py
+++ b/qiskit/transpiler/passes/scheduling/time_unit_conversion.py
@@ -108,7 +108,7 @@ def run(self, dag: DAGCircuit):
             op = node.op.to_mutable()
             op.duration = duration
             op.unit = time_unit
-            node.op = op
+            dag.substitute_node(node, op, propagate_condition=False)
 
         self.property_set["time_unit"] = time_unit
         return dag
diff --git a/qiskit/transpiler/passes/synthesis/high_level_synthesis.py b/qiskit/transpiler/passes/synthesis/high_level_synthesis.py
index 38c46547b12d..73a402dc202f 100644
--- a/qiskit/transpiler/passes/synthesis/high_level_synthesis.py
+++ b/qiskit/transpiler/passes/synthesis/high_level_synthesis.py
@@ -303,8 +303,10 @@ def _run(self, dag: DAGCircuit, tracker: QubitTracker) -> DAGCircuit:
 
             # next check control flow
             elif node.is_control_flow():
-                node.op = control_flow.map_blocks(
-                    partial(self._run, tracker=tracker.copy()), node.op
+                dag.substitute_node(
+                    node,
+                    control_flow.map_blocks(partial(self._run, tracker=tracker.copy()), node.op),
+                    propagate_condition=False,
                 )
 
             # now we are free to synthesize
diff --git a/qiskit/transpiler/passes/synthesis/unitary_synthesis.py b/qiskit/transpiler/passes/synthesis/unitary_synthesis.py
index 4054a158d12a..e31f6918f452 100644
--- a/qiskit/transpiler/passes/synthesis/unitary_synthesis.py
+++ b/qiskit/transpiler/passes/synthesis/unitary_synthesis.py
@@ -52,7 +52,8 @@
     RGate,
 )
 from qiskit.converters import circuit_to_dag, dag_to_circuit
-from qiskit.dagcircuit.dagcircuit import DAGCircuit, DAGOpNode
+from qiskit.dagcircuit.dagcircuit import DAGCircuit
+from qiskit.dagcircuit.dagnode import DAGOpNode
 from qiskit.exceptions import QiskitError
 from qiskit.providers.models.backendproperties import BackendProperties
 from qiskit.quantum_info import Operator
@@ -511,7 +512,7 @@ def _run_main_loop(
         for node in dag.op_nodes():
             if node.name not in CONTROL_FLOW_OP_NAMES:
                 continue
-            node.op = node.op.replace_blocks(
+            new_op = node.op.replace_blocks(
                 [
                     dag_to_circuit(
                         self._run_main_loop(
@@ -530,6 +531,7 @@ def _run_main_loop(
                     for block in node.op.blocks
                 ]
             )
+            dag.substitute_node(node, new_op, propagate_condition=False)
 
         out_dag = dag.copy_empty_like()
         for node in dag.topological_op_nodes():
@@ -572,15 +574,13 @@ def _run_main_loop(
                                 user_gate_node._to_circuit_instruction().replace(
                                     params=user_gate_node.params,
                                     qubits=tuple(qubits[x] for x in qargs),
-                                ),
-                                dag=out_dag,
+                                )
                             )
                         else:
                             node = DAGOpNode.from_instruction(
                                 CircuitInstruction.from_standard(
                                     gate, tuple(qubits[x] for x in qargs), params
-                                ),
-                                dag=out_dag,
+                                )
                             )
                         out_dag._apply_op_node_back(node)
                     out_dag.global_phase += global_phase
diff --git a/qiskit/transpiler/passes/utils/control_flow.py b/qiskit/transpiler/passes/utils/control_flow.py
index 3739852b4c7e..27c3c83d53c7 100644
--- a/qiskit/transpiler/passes/utils/control_flow.py
+++ b/qiskit/transpiler/passes/utils/control_flow.py
@@ -45,7 +45,7 @@ def trivial_recurse(method):
     use :func:`map_blocks` as::
 
         if isinstance(node.op, ControlFlowOp):
-            node.op = map_blocks(self.run, node.op)
+            dag.substitute_node(node, map_blocks(self.run, node.op))
 
     from with :meth:`.BasePass.run`."""
 
@@ -55,7 +55,9 @@ def bound_wrapped_method(dag):
             return out(self, dag)
 
         for node in dag.op_nodes(ControlFlowOp):
-            node.op = map_blocks(bound_wrapped_method, node.op)
+            dag.substitute_node(
+                node, map_blocks(bound_wrapped_method, node.op), propagate_condition=False
+            )
         return method(self, dag)
 
     return out
diff --git a/qiskit/transpiler/passes/utils/gate_direction.py b/qiskit/transpiler/passes/utils/gate_direction.py
index 79493ae8ad25..8ea77f7ccd46 100644
--- a/qiskit/transpiler/passes/utils/gate_direction.py
+++ b/qiskit/transpiler/passes/utils/gate_direction.py
@@ -175,7 +175,7 @@ def _run_coupling_map(self, dag, wire_map, edges=None):
         # Don't include directives to avoid things like barrier, which are assumed always supported.
         for node in dag.op_nodes(include_directives=False):
             if isinstance(node.op, ControlFlowOp):
-                node.op = node.op.replace_blocks(
+                new_op = node.op.replace_blocks(
                     dag_to_circuit(
                         self._run_coupling_map(
                             circuit_to_dag(block),
@@ -188,6 +188,7 @@ def _run_coupling_map(self, dag, wire_map, edges=None):
                     )
                     for block in node.op.blocks
                 )
+                dag.substitute_node(node, new_op, propagate_condition=False)
                 continue
             if len(node.qargs) != 2:
                 continue
@@ -222,7 +223,7 @@ def _run_target(self, dag, wire_map):
         # Don't include directives to avoid things like barrier, which are assumed always supported.
         for node in dag.op_nodes(include_directives=False):
             if isinstance(node.op, ControlFlowOp):
-                node.op = node.op.replace_blocks(
+                new_op = node.op.replace_blocks(
                     dag_to_circuit(
                         self._run_target(
                             circuit_to_dag(block),
@@ -234,6 +235,7 @@ def _run_target(self, dag, wire_map):
                     )
                     for block in node.op.blocks
                 )
+                dag.substitute_node(node, new_op, propagate_condition=False)
                 continue
             if len(node.qargs) != 2:
                 continue
diff --git a/qiskit/transpiler/passes/utils/merge_adjacent_barriers.py b/qiskit/transpiler/passes/utils/merge_adjacent_barriers.py
index 40390a02cade..acb748bb6f95 100644
--- a/qiskit/transpiler/passes/utils/merge_adjacent_barriers.py
+++ b/qiskit/transpiler/passes/utils/merge_adjacent_barriers.py
@@ -108,7 +108,7 @@ def _collect_potential_merges(dag, barriers):
         for next_barrier in barriers[1:]:
 
             # Ensure barriers are adjacent before checking if they are mergeable.
-            if dag._multi_graph.has_edge(end_of_barrier._node_id, next_barrier._node_id):
+            if dag._has_edge(end_of_barrier._node_id, next_barrier._node_id):
 
                 # Remove all barriers that have already been included in this new barrier from the
                 # set of ancestors/descendants as they will be removed from the new DAG when it is
diff --git a/qiskit/visualization/circuit/_utils.py b/qiskit/visualization/circuit/_utils.py
index e6ee03905d27..d933d38b5c4a 100644
--- a/qiskit/visualization/circuit/_utils.py
+++ b/qiskit/visualization/circuit/_utils.py
@@ -454,14 +454,12 @@ def _get_layered_instructions(
         clbits = new_clbits
 
     dag = circuit_to_dag(circuit)
-    dag.qubits = qubits
-    dag.clbits = clbits
 
     if justify == "none":
         for node in dag.topological_op_nodes():
             nodes.append([node])
     else:
-        nodes = _LayerSpooler(dag, justify, measure_map)
+        nodes = _LayerSpooler(dag, qubits, clbits, justify, measure_map)
 
     # Optionally remove all idle wires and instructions that are on them and
     # on them only.
@@ -515,23 +513,25 @@ def _get_gate_span(qubits, node):
 
 def _any_crossover(qubits, node, nodes):
     """Return True .IFF. 'node' crosses over any 'nodes'."""
-    gate_span = _get_gate_span(qubits, node)
-    all_indices = []
-    for check_node in nodes:
-        if check_node != node:
-            all_indices += _get_gate_span(qubits, check_node)
-    return any(i in gate_span for i in all_indices)
+    return bool(
+        set(_get_gate_span(qubits, node)).intersection(
+            bit for check_node in nodes for bit in _get_gate_span(qubits, check_node)
+        )
+    )
+
+
+_GLOBAL_NID = 0
 
 
 class _LayerSpooler(list):
     """Manipulate list of layer dicts for _get_layered_instructions."""
 
-    def __init__(self, dag, justification, measure_map):
+    def __init__(self, dag, qubits, clbits, justification, measure_map):
         """Create spool"""
         super().__init__()
         self.dag = dag
-        self.qubits = dag.qubits
-        self.clbits = dag.clbits
+        self.qubits = qubits
+        self.clbits = clbits
         self.justification = justification
         self.measure_map = measure_map
         self.cregs = [self.dag.cregs[reg] for reg in self.dag.cregs]
@@ -660,6 +660,15 @@ def slide_from_right(self, node, index):
 
     def add(self, node, index):
         """Add 'node' where it belongs, starting the try at 'index'."""
+        # Before we add the node, we set its node ID to be globally unique
+        # within this spooler. This is necessary because nodes may span
+        # layers (which are separate DAGs), and thus can falsely compare
+        # as equal if their contents and node IDs happen to be the same.
+        # This is particularly important for the matplotlib drawer, which
+        # keys several of its internal data structures with these nodes.
+        global _GLOBAL_NID  # pylint: disable=global-statement
+        node._node_id = _GLOBAL_NID
+        _GLOBAL_NID += 1
         if self.justification == "left":
             self.slide_from_left(node, index)
         else:
diff --git a/qiskit/visualization/dag_visualization.py b/qiskit/visualization/dag_visualization.py
index dae97b51b0a4..a6a111fe75e9 100644
--- a/qiskit/visualization/dag_visualization.py
+++ b/qiskit/visualization/dag_visualization.py
@@ -15,9 +15,14 @@
 """
 Visualization function for DAG circuit representation.
 """
+
+import io
+import subprocess
+
 from rustworkx.visualization import graphviz_draw
 
 from qiskit.dagcircuit.dagnode import DAGOpNode, DAGInNode, DAGOutNode
+from qiskit.dagcircuit.dagcircuit import DAGCircuit
 from qiskit.circuit import Qubit, Clbit, ClassicalRegister
 from qiskit.circuit.classical import expr
 from qiskit.converters import dagdependency_to_circuit
@@ -26,7 +31,48 @@
 from .exceptions import VisualizationError
 
 
+IMAGE_TYPES = {
+    "canon",
+    "cmap",
+    "cmapx",
+    "cmapx_np",
+    "dia",
+    "dot",
+    "fig",
+    "gd",
+    "gd2",
+    "gif",
+    "hpgl",
+    "imap",
+    "imap_np",
+    "ismap",
+    "jpe",
+    "jpeg",
+    "jpg",
+    "mif",
+    "mp",
+    "pcl",
+    "pdf",
+    "pic",
+    "plain",
+    "plain-ext",
+    "png",
+    "ps",
+    "ps2",
+    "svg",
+    "svgz",
+    "vml",
+    "vmlz",
+    "vrml",
+    "vtx",
+    "wbmp",
+    "xdor",
+    "xlib",
+}
+
+
 @_optionals.HAS_GRAPHVIZ.require_in_call
+@_optionals.HAS_PIL.require_in_call
 def dag_drawer(dag, scale=0.7, filename=None, style="color"):
     """Plot the directed acyclic graph (dag) to represent operation dependencies
     in a quantum circuit.
@@ -48,6 +94,8 @@ def dag_drawer(dag, scale=0.7, filename=None, style="color"):
     Raises:
         VisualizationError: when style is not recognized.
         InvalidFileError: when filename provided is not valid
+        ValueError: If the file extension for ``filename`` is not an image
+            type supported by Graphviz.
 
     Example:
         .. plot::
@@ -69,6 +117,7 @@ def dag_drawer(dag, scale=0.7, filename=None, style="color"):
             dag = circuit_to_dag(circ)
             dag_drawer(dag)
     """
+    from PIL import Image
 
     # NOTE: use type str checking to avoid potential cyclical import
     # the two tradeoffs ere that it will not handle subclasses and it is
@@ -215,16 +264,53 @@ def edge_attr_func(edge):
             e["label"] = label
             return e
 
-    image_type = None
+    image_type = "png"
     if filename:
         if "." not in filename:
             raise InvalidFileError("Parameter 'filename' must be in format 'name.extension'")
         image_type = filename.split(".")[-1]
-    return graphviz_draw(
-        dag._multi_graph,
-        node_attr_func,
-        edge_attr_func,
-        graph_attrs,
-        filename,
-        image_type,
-    )
+        if image_type not in IMAGE_TYPES:
+            raise ValueError(
+                "The specified value for the image_type argument, "
+                f"'{image_type}' is not a valid choice. It must be one of: "
+                f"{IMAGE_TYPES}"
+            )
+
+    if isinstance(dag, DAGCircuit):
+        dot_str = dag._to_dot(
+            graph_attrs,
+            node_attr_func,
+            edge_attr_func,
+        )
+
+        prog = "dot"
+        if not filename:
+            dot_result = subprocess.run(
+                [prog, "-T", image_type],
+                input=dot_str.encode("utf-8"),
+                capture_output=True,
+                encoding=None,
+                check=True,
+                text=False,
+            )
+            dot_bytes_image = io.BytesIO(dot_result.stdout)
+            image = Image.open(dot_bytes_image)
+            return image
+        else:
+            subprocess.run(
+                [prog, "-T", image_type, "-o", filename],
+                input=dot_str,
+                check=True,
+                encoding="utf8",
+                text=True,
+            )
+            return None
+    else:
+        return graphviz_draw(
+            dag._multi_graph,
+            node_attr_func,
+            edge_attr_func,
+            graph_attrs,
+            filename,
+            image_type,
+        )
diff --git a/releasenotes/notes/dag-oxide-60b3d7219cb21703.yaml b/releasenotes/notes/dag-oxide-60b3d7219cb21703.yaml
new file mode 100644
index 000000000000..090a8226c111
--- /dev/null
+++ b/releasenotes/notes/dag-oxide-60b3d7219cb21703.yaml
@@ -0,0 +1,49 @@
+---
+features_transpiler:
+  - |
+    The implementation of the :class:`.DAGCircuit` has been rewritten in Rust. This rewrite of
+    the Python class should be fully API compatible with the previous Python implementation of
+    the class. While the class was previously implemented using
+    `rustworkx <https://www.rustworkx.org/>`__ and its underlying data graph structure existed
+    in Rust, the implementation of the class and all the data was stored in Python. This new
+    version of :class:`.DAGCircuit` stores a Rust native representation for all its data and
+    is fully implemented in Rust. This new implementation should be more efficient in memory
+    usage as it compresses     the qubit and clbit representation for instructions at rest.
+    It also enables speed up for     transpiler passes as they can fully manipulate a
+    :class:`.DAGCircuit` from Rust.
+upgrade_transpiler:
+  - |
+    :class:`.DAGNode` objects (and its subclasses :class:`.DAGInNode`, :class:`.DAGOutNode`, and
+    :class:`.DAGOpNode`) no longer return references to the same underlying object from
+    :class:`.DAGCircuit` methods. This was never a guarantee before that all returned nodes would
+    be shared reference to the same object, but with the migration of the :class:`.DAGCircuit` to
+    Rust when a :class:`.DAGNode` a new :class:`.DAGNode` instance is generated on the fly when
+    a node is returned to Python. These objects will evaluate as equal using ``==`` or similar
+    checks that rely on ``__eq__`` but will no longer identify as the same object.
+  - |
+    The :class:`.DAGOpNode` instances returned from the :class:`.DAGCircuit` are no longer shared
+    references to the underlying data stored on the DAG. In previous release it was possible to
+    do something like::
+
+        for node in dag.op_nodes():
+            node.op = new_op
+
+    however this type of mutation was always unsound as it could break the DAG's internal caching
+    and cause corruption of the data structure. Instead you should use the API provided by
+    :class:`.DAGCircuit` for mutation such as :meth:`.DAGCircuit.substitute_node`,
+    :meth:`.DAGCircuit.substitute_node_with_dag`, or :meth:`.DAGCircuit.contract_node`. For example
+    the above code block would become::
+
+        for node in dag.op_nodes():
+          dag.substitute_node(node, new_op)
+
+    This is similar to an upgrade note from 1.2.0 where this was noted on for mutation of the
+    :attr:`.DAGOpNode.op` attribute, not the :class:`.DAGOpNode` itself. However in 1.3 this extends
+    to the entire object, not just it's inner ``op`` attribute. In general this type of mutation was
+    always unsound and not supported, but could previously have potentially worked in some cases.
+fixes:
+  - |
+    Fixed an issue with :meth:`.DAGCircuit.apply_operation_back` and
+    :meth:`.DAGCircuit.apply_operation_front` where previously if you set a
+    :class:`.Clbit` object to the input for the ``qargs`` argument it would silently be accepted.
+    This has been fixed so the type mismatch is correctly identified and an exception is raised.
diff --git a/test/python/compiler/test_transpiler.py b/test/python/compiler/test_transpiler.py
index c3a930aed1f2..edb3df63e46d 100644
--- a/test/python/compiler/test_transpiler.py
+++ b/test/python/compiler/test_transpiler.py
@@ -3320,19 +3320,19 @@ def _visit_block(circuit, qubit_mapping=None):
         tqc_dag = circuit_to_dag(tqc)
         qubit_map = {qubit: index for index, qubit in enumerate(tqc_dag.qubits)}
         input_node = tqc_dag.input_map[tqc_dag.clbits[0]]
-        first_meas_node = tqc_dag._multi_graph.find_successors_by_edge(
+        first_meas_node = tqc_dag._find_successors_by_edge(
             input_node._node_id, lambda edge_data: isinstance(edge_data, Clbit)
         )[0]
         # The first node should be a measurement
         self.assertIsInstance(first_meas_node.op, Measure)
         # This should be in the first component
         self.assertIn(qubit_map[first_meas_node.qargs[0]], components[0])
-        op_node = tqc_dag._multi_graph.find_successors_by_edge(
+        op_node = tqc_dag._find_successors_by_edge(
             first_meas_node._node_id, lambda edge_data: isinstance(edge_data, Clbit)
         )[0]
         while isinstance(op_node, DAGOpNode):
             self.assertIn(qubit_map[op_node.qargs[0]], components[1])
-            op_node = tqc_dag._multi_graph.find_successors_by_edge(
+            op_node = tqc_dag._find_successors_by_edge(
                 op_node._node_id, lambda edge_data: isinstance(edge_data, Clbit)
             )[0]
 
@@ -3394,19 +3394,19 @@ def _visit_block(circuit, qubit_mapping=None):
         tqc_dag = circuit_to_dag(tqc)
         qubit_map = {qubit: index for index, qubit in enumerate(tqc_dag.qubits)}
         input_node = tqc_dag.input_map[tqc_dag.clbits[0]]
-        first_meas_node = tqc_dag._multi_graph.find_successors_by_edge(
+        first_meas_node = tqc_dag._find_successors_by_edge(
             input_node._node_id, lambda edge_data: isinstance(edge_data, Clbit)
         )[0]
         # The first node should be a measurement
         self.assertIsInstance(first_meas_node.op, Measure)
         # This should be in the first component
         self.assertIn(qubit_map[first_meas_node.qargs[0]], components[0])
-        op_node = tqc_dag._multi_graph.find_successors_by_edge(
+        op_node = tqc_dag._find_successors_by_edge(
             first_meas_node._node_id, lambda edge_data: isinstance(edge_data, Clbit)
         )[0]
         while isinstance(op_node, DAGOpNode):
             self.assertIn(qubit_map[op_node.qargs[0]], components[1])
-            op_node = tqc_dag._multi_graph.find_successors_by_edge(
+            op_node = tqc_dag._find_successors_by_edge(
                 op_node._node_id, lambda edge_data: isinstance(edge_data, Clbit)
             )[0]
 
@@ -3477,26 +3477,26 @@ def _visit_block(circuit, qubit_mapping=None):
         tqc_dag = circuit_to_dag(tqc)
         qubit_map = {qubit: index for index, qubit in enumerate(tqc_dag.qubits)}
         input_node = tqc_dag.input_map[tqc_dag.clbits[0]]
-        first_meas_node = tqc_dag._multi_graph.find_successors_by_edge(
+        first_meas_node = tqc_dag._find_successors_by_edge(
             input_node._node_id, lambda edge_data: isinstance(edge_data, Clbit)
         )[0]
         self.assertIsInstance(first_meas_node.op, Measure)
         self.assertIn(qubit_map[first_meas_node.qargs[0]], components[0])
-        op_node = tqc_dag._multi_graph.find_successors_by_edge(
+        op_node = tqc_dag._find_successors_by_edge(
             first_meas_node._node_id, lambda edge_data: isinstance(edge_data, Clbit)
         )[0]
         while not isinstance(op_node.op, Measure):
             self.assertIn(qubit_map[op_node.qargs[0]], components[1])
-            op_node = tqc_dag._multi_graph.find_successors_by_edge(
+            op_node = tqc_dag._find_successors_by_edge(
                 op_node._node_id, lambda edge_data: isinstance(edge_data, Clbit)
             )[0]
         self.assertIn(qubit_map[op_node.qargs[0]], components[1])
-        op_node = tqc_dag._multi_graph.find_successors_by_edge(
+        op_node = tqc_dag._find_successors_by_edge(
             op_node._node_id, lambda edge_data: isinstance(edge_data, Clbit)
         )[0]
         while not isinstance(op_node.op, Measure):
             self.assertIn(qubit_map[op_node.qargs[0]], components[2])
-            op_node = tqc_dag._multi_graph.find_successors_by_edge(
+            op_node = tqc_dag._find_successors_by_edge(
                 op_node._node_id, lambda edge_data: isinstance(edge_data, Clbit)
             )[0]
         self.assertIn(qubit_map[op_node.qargs[0]], components[2])
diff --git a/test/python/dagcircuit/test_dagcircuit.py b/test/python/dagcircuit/test_dagcircuit.py
index 26f7e4788083..ef8050961066 100644
--- a/test/python/dagcircuit/test_dagcircuit.py
+++ b/test/python/dagcircuit/test_dagcircuit.py
@@ -18,7 +18,6 @@
 import unittest
 
 from ddt import ddt, data
-import rustworkx as rx
 from numpy import pi
 
 from qiskit.dagcircuit import DAGCircuit, DAGOpNode, DAGInNode, DAGOutNode, DAGCircuitError
@@ -55,18 +54,16 @@ def raise_if_dagcircuit_invalid(dag):
        DAGCircuitError: if DAGCircuit._multi_graph is inconsistent.
     """
 
-    multi_graph = dag._multi_graph
-
-    if not rx.is_directed_acyclic_graph(multi_graph):
+    if not dag._is_dag():
         raise DAGCircuitError("multi_graph is not a DAG.")
 
     # Every node should be of type in, out, or op.
     # All input/output nodes should be present in input_map/output_map.
-    for node in dag._multi_graph.nodes():
+    for node in dag.nodes():
         if isinstance(node, DAGInNode):
-            assert node is dag.input_map[node.wire]
+            assert node == dag.input_map[node.wire]
         elif isinstance(node, DAGOutNode):
-            assert node is dag.output_map[node.wire]
+            assert node == dag.output_map[node.wire]
         elif isinstance(node, DAGOpNode):
             continue
         else:
@@ -78,9 +75,7 @@ def raise_if_dagcircuit_invalid(dag):
         assert len(node.cargs) == node.op.num_clbits
 
     # Every edge should be labled with a known wire.
-    edges_outside_wires = [
-        edge_data for edge_data in dag._multi_graph.edges() if edge_data not in dag.wires
-    ]
+    edges_outside_wires = [edge_data for edge_data in dag._edges() if edge_data not in dag.wires]
     if edges_outside_wires:
         raise DAGCircuitError(
             f"multi_graph contains one or more edges ({edges_outside_wires}) "
@@ -103,7 +98,7 @@ def raise_if_dagcircuit_invalid(dag):
         out_node_id = dag.output_map[wire]._node_id
 
         while cur_node_id != out_node_id:
-            out_edges = dag._multi_graph.out_edges(cur_node_id)
+            out_edges = dag._out_edges(cur_node_id)
             edges_to_follow = [(src, dest, data) for (src, dest, data) in out_edges if data == wire]
 
             assert len(edges_to_follow) == 1
@@ -112,18 +107,15 @@ def raise_if_dagcircuit_invalid(dag):
     # Wires can only terminate at input/output nodes.
     op_counts = Counter()
     for op_node in dag.op_nodes():
-        assert multi_graph.in_degree(op_node._node_id) == multi_graph.out_degree(op_node._node_id)
+        assert sum(1 for _ in dag.predecessors(op_node)) == sum(1 for _ in dag.successors(op_node))
         op_counts[op_node.name] += 1
     # The _op_names attribute should match the counted op names
-    assert op_counts == dag._op_names
+    assert op_counts == dag.count_ops()
 
     # Node input/output edges should match node qarg/carg/condition.
     for node in dag.op_nodes():
-        in_edges = dag._multi_graph.in_edges(node._node_id)
-        out_edges = dag._multi_graph.out_edges(node._node_id)
-
-        in_wires = {data for src, dest, data in in_edges}
-        out_wires = {data for src, dest, data in out_edges}
+        in_wires = set(dag._in_wires(node._node_id))
+        out_wires = set(dag._out_wires(node._node_id))
 
         node_cond_bits = set(
             node.op.condition[0][:] if getattr(node.op, "condition", None) is not None else []
@@ -516,6 +508,38 @@ def test_remove_unknown_clbit(self):
         self.assert_cregs_equal(self.original_cregs)
         self.assert_clbits_equal(self.original_clbits)
 
+    def test_remove_clbit_with_control_flow(self):
+        """Test clbit removal in the middle of clbits with control flow."""
+        qr = QuantumRegister(1)
+        cr1 = ClassicalRegister(2, "a")
+        cr2 = ClassicalRegister(2, "b")
+        clbit = Clbit()
+        dag = DAGCircuit()
+        dag.add_qreg(qr)
+        dag.add_creg(cr1)
+        dag.add_creg(cr2)
+        dag.add_clbits([clbit])
+
+        inner = QuantumCircuit(1)
+        inner.h(0)
+        inner.z(0)
+
+        op = IfElseOp(expr.logic_and(expr.equal(cr1, 3), expr.logic_not(clbit)), inner, None)
+        dag.apply_operation_back(op, qr, ())
+        dag.remove_clbits(*cr2)
+        self.assertEqual(dag.clbits, list(cr1) + [clbit])
+        self.assertEqual(dag.cregs, {"a": cr1})
+
+        expected = DAGCircuit()
+        expected.add_qreg(qr)
+        expected.add_creg(cr1)
+        expected.add_clbits([clbit])
+
+        op = IfElseOp(expr.logic_and(expr.equal(cr1, 3), expr.logic_not(clbit)), inner, None)
+        expected.apply_operation_back(op, qr, ())
+
+        self.assertEqual(dag, expected)
+
 
 class TestDagApplyOperation(QiskitTestCase):
     """Test adding an op node to a dag."""
@@ -575,7 +599,7 @@ def test_apply_operation_back_conditional(self):
         self.assertEqual(h_node.op.condition, h_gate.condition)
 
         self.assertEqual(
-            sorted(self.dag._multi_graph.in_edges(h_node._node_id)),
+            sorted(self.dag._in_edges(h_node._node_id)),
             sorted(
                 [
                     (self.dag.input_map[self.qubit2]._node_id, h_node._node_id, self.qubit2),
@@ -586,7 +610,7 @@ def test_apply_operation_back_conditional(self):
         )
 
         self.assertEqual(
-            sorted(self.dag._multi_graph.out_edges(h_node._node_id)),
+            sorted(self.dag._out_edges(h_node._node_id)),
             sorted(
                 [
                     (h_node._node_id, self.dag.output_map[self.qubit2]._node_id, self.qubit2),
@@ -596,7 +620,7 @@ def test_apply_operation_back_conditional(self):
             ),
         )
 
-        self.assertTrue(rx.is_directed_acyclic_graph(self.dag._multi_graph))
+        self.assertTrue(self.dag._is_dag())
 
     def test_apply_operation_back_conditional_measure(self):
         """Test consistency of apply_operation_back for conditional measure."""
@@ -615,7 +639,7 @@ def test_apply_operation_back_conditional_measure(self):
         self.assertEqual(meas_node.op.condition, meas_gate.condition)
 
         self.assertEqual(
-            sorted(self.dag._multi_graph.in_edges(meas_node._node_id)),
+            sorted(self.dag._in_edges(meas_node._node_id)),
             sorted(
                 [
                     (self.dag.input_map[self.qubit0]._node_id, meas_node._node_id, self.qubit0),
@@ -630,7 +654,7 @@ def test_apply_operation_back_conditional_measure(self):
         )
 
         self.assertEqual(
-            sorted(self.dag._multi_graph.out_edges(meas_node._node_id)),
+            sorted(self.dag._out_edges(meas_node._node_id)),
             sorted(
                 [
                     (meas_node._node_id, self.dag.output_map[self.qubit0]._node_id, self.qubit0),
@@ -644,7 +668,7 @@ def test_apply_operation_back_conditional_measure(self):
             ),
         )
 
-        self.assertTrue(rx.is_directed_acyclic_graph(self.dag._multi_graph))
+        self.assertTrue(self.dag._is_dag())
 
     def test_apply_operation_back_conditional_measure_to_self(self):
         """Test consistency of apply_operation_back for measure onto conditioning bit."""
@@ -660,7 +684,7 @@ def test_apply_operation_back_conditional_measure_to_self(self):
         self.assertEqual(meas_node.op.condition, meas_gate.condition)
 
         self.assertEqual(
-            sorted(self.dag._multi_graph.in_edges(meas_node._node_id)),
+            sorted(self.dag._in_edges(meas_node._node_id)),
             sorted(
                 [
                     (self.dag.input_map[self.qubit1]._node_id, meas_node._node_id, self.qubit1),
@@ -671,7 +695,7 @@ def test_apply_operation_back_conditional_measure_to_self(self):
         )
 
         self.assertEqual(
-            sorted(self.dag._multi_graph.out_edges(meas_node._node_id)),
+            sorted(self.dag._out_edges(meas_node._node_id)),
             sorted(
                 [
                     (meas_node._node_id, self.dag.output_map[self.qubit1]._node_id, self.qubit1),
@@ -681,7 +705,7 @@ def test_apply_operation_back_conditional_measure_to_self(self):
             ),
         )
 
-        self.assertTrue(rx.is_directed_acyclic_graph(self.dag._multi_graph))
+        self.assertTrue(self.dag._is_dag())
 
     def test_apply_operation_front(self):
         """The apply_operation_front() method"""
@@ -935,8 +959,8 @@ def test_classical_predecessors(self):
         self.dag.apply_operation_back(CXGate(), [self.qubit0, self.qubit1], [])
         self.dag.apply_operation_back(HGate(), [self.qubit0], [])
         self.dag.apply_operation_back(HGate(), [self.qubit1], [])
-        self.dag.apply_operation_back(Measure(), [self.qubit0, self.clbit0], [])
-        self.dag.apply_operation_back(Measure(), [self.qubit1, self.clbit1], [])
+        self.dag.apply_operation_back(Measure(), [self.qubit0], [self.clbit0])
+        self.dag.apply_operation_back(Measure(), [self.qubit1], [self.clbit1])
 
         predecessor_measure = self.dag.classical_predecessors(self.dag.named_nodes("measure").pop())
 
@@ -948,6 +972,13 @@ def test_classical_predecessors(self):
         self.assertIsInstance(predecessor1, DAGInNode)
         self.assertIsInstance(predecessor1.wire, Clbit)
 
+    def test_apply_operation_reject_invalid_qarg_carg(self):
+        """Test that we can't add a carg to qargs and vice versa on apply methods"""
+        with self.assertRaises(KeyError):
+            self.dag.apply_operation_back(Measure(), [self.clbit1], [self.qubit1])
+        with self.assertRaises(KeyError):
+            self.dag.apply_operation_front(Measure(), [self.clbit1], [self.qubit1])
+
     def test_classical_successors(self):
         """The method dag.classical_successors() returns successors connected by classical edges"""
 
@@ -969,8 +1000,8 @@ def test_classical_successors(self):
         self.dag.apply_operation_back(CXGate(), [self.qubit0, self.qubit1], [])
         self.dag.apply_operation_back(HGate(), [self.qubit0], [])
         self.dag.apply_operation_back(HGate(), [self.qubit1], [])
-        self.dag.apply_operation_back(Measure(), [self.qubit0, self.clbit0], [])
-        self.dag.apply_operation_back(Measure(), [self.qubit1, self.clbit1], [])
+        self.dag.apply_operation_back(Measure(), [self.qubit0], [self.clbit0])
+        self.dag.apply_operation_back(Measure(), [self.qubit1], [self.clbit1])
 
         successors_measure = self.dag.classical_successors(self.dag.named_nodes("measure").pop())
 
@@ -1067,12 +1098,12 @@ def test_topological_nodes(self):
             ("cx", (self.qubit2, self.qubit1)),
             ("cx", (self.qubit0, self.qubit2)),
             ("h", (self.qubit2,)),
+            cr[0],
+            cr[1],
             qr[0],
             qr[1],
             qr[2],
             cr[0],
-            cr[0],
-            cr[1],
             cr[1],
         ]
         self.assertEqual(
@@ -2397,7 +2428,6 @@ def test_contract_var_use_to_nothing(self):
 
         expected = DAGCircuit()
         expected.add_input_var(a)
-
         self.assertEqual(src, expected)
 
     def test_raise_if_var_mismatch(self):
@@ -2665,7 +2695,6 @@ def test_substituting_node_preserves_args_condition(self, inplace):
         self.assertEqual(replacement_node.qargs, (qr[1], qr[0]))
         self.assertEqual(replacement_node.cargs, ())
         self.assertEqual(replacement_node.op.condition, (cr, 1))
-
         self.assertEqual(replacement_node is node_to_be_replaced, inplace)
 
     @data(True, False)
@@ -3172,24 +3201,34 @@ def test_creg_conditional(self):
         self.assertEqual(gate_node.qargs, (self.qreg[0],))
         self.assertEqual(gate_node.cargs, ())
         self.assertEqual(gate_node.op.condition, (self.creg, 1))
+
+        gate_node_preds = list(self.dag.predecessors(gate_node))
+        gate_node_in_edges = [
+            (src._node_id, wire)
+            for (src, tgt, wire) in self.dag.edges(gate_node_preds)
+            if tgt == gate_node
+        ]
+
         self.assertEqual(
-            sorted(self.dag._multi_graph.in_edges(gate_node._node_id)),
+            sorted(gate_node_in_edges),
             sorted(
                 [
-                    (self.dag.input_map[self.qreg[0]]._node_id, gate_node._node_id, self.qreg[0]),
-                    (self.dag.input_map[self.creg[0]]._node_id, gate_node._node_id, self.creg[0]),
-                    (self.dag.input_map[self.creg[1]]._node_id, gate_node._node_id, self.creg[1]),
+                    (self.dag.input_map[self.qreg[0]]._node_id, self.qreg[0]),
+                    (self.dag.input_map[self.creg[0]]._node_id, self.creg[0]),
+                    (self.dag.input_map[self.creg[1]]._node_id, self.creg[1]),
                 ]
             ),
         )
 
+        gate_node_out_edges = [(tgt._node_id, wire) for (_, tgt, wire) in self.dag.edges(gate_node)]
+
         self.assertEqual(
-            sorted(self.dag._multi_graph.out_edges(gate_node._node_id)),
+            sorted(gate_node_out_edges),
             sorted(
                 [
-                    (gate_node._node_id, self.dag.output_map[self.qreg[0]]._node_id, self.qreg[0]),
-                    (gate_node._node_id, self.dag.output_map[self.creg[0]]._node_id, self.creg[0]),
-                    (gate_node._node_id, self.dag.output_map[self.creg[1]]._node_id, self.creg[1]),
+                    (self.dag.output_map[self.qreg[0]]._node_id, self.qreg[0]),
+                    (self.dag.output_map[self.creg[0]]._node_id, self.creg[0]),
+                    (self.dag.output_map[self.creg[1]]._node_id, self.creg[1]),
                 ]
             ),
         )
@@ -3204,22 +3243,31 @@ def test_clbit_conditional(self):
         self.assertEqual(gate_node.qargs, (self.qreg[0],))
         self.assertEqual(gate_node.cargs, ())
         self.assertEqual(gate_node.op.condition, (self.creg[0], 1))
+
+        gate_node_preds = list(self.dag.predecessors(gate_node))
+        gate_node_in_edges = [
+            (src._node_id, wire)
+            for (src, tgt, wire) in self.dag.edges(gate_node_preds)
+            if tgt == gate_node
+        ]
+
         self.assertEqual(
-            sorted(self.dag._multi_graph.in_edges(gate_node._node_id)),
+            sorted(gate_node_in_edges),
             sorted(
                 [
-                    (self.dag.input_map[self.qreg[0]]._node_id, gate_node._node_id, self.qreg[0]),
-                    (self.dag.input_map[self.creg[0]]._node_id, gate_node._node_id, self.creg[0]),
+                    (self.dag.input_map[self.qreg[0]]._node_id, self.qreg[0]),
+                    (self.dag.input_map[self.creg[0]]._node_id, self.creg[0]),
                 ]
             ),
         )
 
+        gate_node_out_edges = [(tgt._node_id, wire) for (_, tgt, wire) in self.dag.edges(gate_node)]
         self.assertEqual(
-            sorted(self.dag._multi_graph.out_edges(gate_node._node_id)),
+            sorted(gate_node_out_edges),
             sorted(
                 [
-                    (gate_node._node_id, self.dag.output_map[self.qreg[0]]._node_id, self.qreg[0]),
-                    (gate_node._node_id, self.dag.output_map[self.creg[0]]._node_id, self.creg[0]),
+                    (self.dag.output_map[self.qreg[0]]._node_id, self.qreg[0]),
+                    (self.dag.output_map[self.creg[0]]._node_id, self.creg[0]),
                 ]
             ),
         )
diff --git a/test/python/transpiler/_dummy_passes.py b/test/python/transpiler/_dummy_passes.py
index 64956e541024..eaddfe6d1ddd 100644
--- a/test/python/transpiler/_dummy_passes.py
+++ b/test/python/transpiler/_dummy_passes.py
@@ -122,10 +122,10 @@ class PassF_reduce_dag_property(DummyTP):
 
     def run(self, dag):
         super().run(dag)
-        if not hasattr(dag, "property"):
-            dag.property = 8
-        dag.property = round(dag.property * 0.8)
-        logging.getLogger(logger).info("dag property = %i", dag.property)
+        if dag.duration is None:
+            dag.duration = 8
+        dag.duration = round(dag.duration * 0.8)
+        logging.getLogger(logger).info("dag property = %i", dag.duration)
         return dag
 
 
@@ -138,8 +138,8 @@ class PassG_calculates_dag_property(DummyAP):
 
     def run(self, dag):
         super().run(dag)
-        if hasattr(dag, "property"):
-            self.property_set["property"] = dag.property
+        if dag.duration is not None:
+            self.property_set["property"] = dag.duration
         else:
             self.property_set["property"] = 8
         logging.getLogger(logger).info(
diff --git a/test/python/transpiler/test_collect_multiq_blocks.py b/test/python/transpiler/test_collect_multiq_blocks.py
index 58589d838e33..e2446d03da2a 100644
--- a/test/python/transpiler/test_collect_multiq_blocks.py
+++ b/test/python/transpiler/test_collect_multiq_blocks.py
@@ -93,6 +93,7 @@ def test_block_interrupted_by_gate(self):
         # but equivalent between python 3.5 and 3.7
         # there is no implied topology in a block, so this isn't an issue
         dag_nodes = [set(dag_nodes[:4]), set(dag_nodes[4:])]
+
         pass_nodes = [set(bl) for bl in pass_.property_set["block_list"]]
 
         self.assertEqual(dag_nodes, pass_nodes)
diff --git a/test/python/visualization/test_utils.py b/test/python/visualization/test_utils.py
index 1dca43b6beb2..1ef87994d001 100644
--- a/test/python/visualization/test_utils.py
+++ b/test/python/visualization/test_utils.py
@@ -48,18 +48,18 @@ def test_get_layered_instructions(self):
         (qregs, cregs, layered_ops) = _utils._get_layered_instructions(self.circuit)
 
         exp = [
-            [("cx", (self.qr2[0], self.qr2[1]), ()), ("cx", (self.qr1[0], self.qr1[1]), ())],
-            [("measure", (self.qr2[0],), (self.cr2[0],))],
-            [("measure", (self.qr1[0],), (self.cr1[0],))],
-            [("cx", (self.qr2[1], self.qr2[0]), ()), ("cx", (self.qr1[1], self.qr1[0]), ())],
-            [("measure", (self.qr2[1],), (self.cr2[1],))],
-            [("measure", (self.qr1[1],), (self.cr1[1],))],
+            {("cx", (self.qr2[0], self.qr2[1]), ()), ("cx", (self.qr1[0], self.qr1[1]), ())},
+            {("measure", (self.qr2[0],), (self.cr2[0],))},
+            {("measure", (self.qr1[0],), (self.cr1[0],))},
+            {("cx", (self.qr2[1], self.qr2[0]), ()), ("cx", (self.qr1[1], self.qr1[0]), ())},
+            {("measure", (self.qr2[1],), (self.cr2[1],))},
+            {("measure", (self.qr1[1],), (self.cr1[1],))},
         ]
 
         self.assertEqual([self.qr1[0], self.qr1[1], self.qr2[0], self.qr2[1]], qregs)
         self.assertEqual([self.cr1[0], self.cr1[1], self.cr2[0], self.cr2[1]], cregs)
         self.assertEqual(
-            exp, [[(op.name, op.qargs, op.cargs) for op in ops] for ops in layered_ops]
+            exp, [{(op.name, op.qargs, op.cargs) for op in ops} for ops in layered_ops]
         )
 
     def test_get_layered_instructions_reverse_bits(self):
@@ -69,18 +69,18 @@ def test_get_layered_instructions_reverse_bits(self):
         )
 
         exp = [
-            [("cx", (self.qr2[0], self.qr2[1]), ()), ("cx", (self.qr1[0], self.qr1[1]), ())],
-            [("measure", (self.qr2[0],), (self.cr2[0],))],
-            [("measure", (self.qr1[0],), (self.cr1[0],)), ("cx", (self.qr2[1], self.qr2[0]), ())],
-            [("cx", (self.qr1[1], self.qr1[0]), ())],
-            [("measure", (self.qr2[1],), (self.cr2[1],))],
-            [("measure", (self.qr1[1],), (self.cr1[1],))],
+            {("cx", (self.qr2[0], self.qr2[1]), ()), ("cx", (self.qr1[0], self.qr1[1]), ())},
+            {("measure", (self.qr2[0],), (self.cr2[0],))},
+            {("measure", (self.qr1[0],), (self.cr1[0],)), ("cx", (self.qr2[1], self.qr2[0]), ())},
+            {("cx", (self.qr1[1], self.qr1[0]), ())},
+            {("measure", (self.qr2[1],), (self.cr2[1],))},
+            {("measure", (self.qr1[1],), (self.cr1[1],))},
         ]
 
         self.assertEqual([self.qr2[1], self.qr2[0], self.qr1[1], self.qr1[0]], qregs)
         self.assertEqual([self.cr2[1], self.cr2[0], self.cr1[1], self.cr1[0]], cregs)
         self.assertEqual(
-            exp, [[(op.name, op.qargs, op.cargs) for op in ops] for ops in layered_ops]
+            exp, [{(op.name, op.qargs, op.cargs) for op in ops} for ops in layered_ops]
         )
 
     def test_get_layered_instructions_remove_idle_wires(self):
@@ -103,18 +103,18 @@ def test_get_layered_instructions_remove_idle_wires(self):
         (qregs, cregs, layered_ops) = _utils._get_layered_instructions(circuit, idle_wires=False)
 
         exp = [
-            [("cx", (qr2[0], qr2[1]), ()), ("cx", (qr1[0], qr1[1]), ())],
-            [("measure", (qr2[0],), (cr2[0],))],
-            [("measure", (qr1[0],), (cr1[0],))],
-            [("cx", (qr2[1], qr2[0]), ()), ("cx", (qr1[1], qr1[0]), ())],
-            [("measure", (qr2[1],), (cr2[1],))],
-            [("measure", (qr1[1],), (cr1[1],))],
+            {("cx", (qr2[0], qr2[1]), ()), ("cx", (qr1[0], qr1[1]), ())},
+            {("measure", (qr2[0],), (cr2[0],))},
+            {("measure", (qr1[0],), (cr1[0],))},
+            {("cx", (qr2[1], qr2[0]), ()), ("cx", (qr1[1], qr1[0]), ())},
+            {("measure", (qr2[1],), (cr2[1],))},
+            {("measure", (qr1[1],), (cr1[1],))},
         ]
 
         self.assertEqual([qr1[0], qr1[1], qr2[0], qr2[1]], qregs)
         self.assertEqual([cr1[0], cr1[1], cr2[0], cr2[1]], cregs)
         self.assertEqual(
-            exp, [[(op.name, op.qargs, op.cargs) for op in ops] for ops in layered_ops]
+            exp, [{(op.name, op.qargs, op.cargs) for op in ops} for ops in layered_ops]
         )
 
     def test_get_layered_instructions_left_justification_simple(self):
@@ -136,15 +136,15 @@ def test_get_layered_instructions_left_justification_simple(self):
         (_, _, layered_ops) = _utils._get_layered_instructions(qc, justify="left")
 
         l_exp = [
-            [
+            {
                 ("h", (Qubit(QuantumRegister(4, "q"), 1),), ()),
                 ("h", (Qubit(QuantumRegister(4, "q"), 2),), ()),
-            ],
-            [("cx", (Qubit(QuantumRegister(4, "q"), 0), Qubit(QuantumRegister(4, "q"), 3)), ())],
+            },
+            {("cx", (Qubit(QuantumRegister(4, "q"), 0), Qubit(QuantumRegister(4, "q"), 3)), ())},
         ]
 
         self.assertEqual(
-            l_exp, [[(op.name, op.qargs, op.cargs) for op in ops] for ops in layered_ops]
+            l_exp, [{(op.name, op.qargs, op.cargs) for op in ops} for ops in layered_ops]
         )
 
     def test_get_layered_instructions_right_justification_simple(self):
@@ -166,15 +166,15 @@ def test_get_layered_instructions_right_justification_simple(self):
         (_, _, layered_ops) = _utils._get_layered_instructions(qc, justify="right")
 
         r_exp = [
-            [("cx", (Qubit(QuantumRegister(4, "q"), 0), Qubit(QuantumRegister(4, "q"), 3)), ())],
-            [
+            {("cx", (Qubit(QuantumRegister(4, "q"), 0), Qubit(QuantumRegister(4, "q"), 3)), ())},
+            {
                 ("h", (Qubit(QuantumRegister(4, "q"), 1),), ()),
                 ("h", (Qubit(QuantumRegister(4, "q"), 2),), ()),
-            ],
+            },
         ]
 
         self.assertEqual(
-            r_exp, [[(op.name, op.qargs, op.cargs) for op in ops] for ops in layered_ops]
+            r_exp, [{(op.name, op.qargs, op.cargs) for op in ops} for ops in layered_ops]
         )
 
     def test_get_layered_instructions_left_justification_less_simple(self):
@@ -215,33 +215,33 @@ def test_get_layered_instructions_left_justification_less_simple(self):
         (_, _, layered_ops) = _utils._get_layered_instructions(qc, justify="left")
 
         l_exp = [
-            [
+            {
                 ("u2", (Qubit(QuantumRegister(5, "q"), 0),), ()),
                 ("u2", (Qubit(QuantumRegister(5, "q"), 1),), ()),
-            ],
-            [("cx", (Qubit(QuantumRegister(5, "q"), 1), Qubit(QuantumRegister(5, "q"), 0)), ())],
-            [
+            },
+            {("cx", (Qubit(QuantumRegister(5, "q"), 1), Qubit(QuantumRegister(5, "q"), 0)), ())},
+            {
                 ("u2", (Qubit(QuantumRegister(5, "q"), 0),), ()),
                 ("u2", (Qubit(QuantumRegister(5, "q"), 1),), ()),
-            ],
-            [("u2", (Qubit(QuantumRegister(5, "q"), 1),), ())],
-            [
+            },
+            {("u2", (Qubit(QuantumRegister(5, "q"), 1),), ())},
+            {
                 (
                     "measure",
                     (Qubit(QuantumRegister(5, "q"), 0),),
                     (Clbit(ClassicalRegister(1, "c1"), 0),),
                 )
-            ],
-            [("u2", (Qubit(QuantumRegister(5, "q"), 0),), ())],
-            [("cx", (Qubit(QuantumRegister(5, "q"), 1), Qubit(QuantumRegister(5, "q"), 0)), ())],
-            [
+            },
+            {("u2", (Qubit(QuantumRegister(5, "q"), 0),), ())},
+            {("cx", (Qubit(QuantumRegister(5, "q"), 1), Qubit(QuantumRegister(5, "q"), 0)), ())},
+            {
                 ("u2", (Qubit(QuantumRegister(5, "q"), 0),), ()),
                 ("u2", (Qubit(QuantumRegister(5, "q"), 1),), ()),
-            ],
+            },
         ]
 
         self.assertEqual(
-            l_exp, [[(op.name, op.qargs, op.cargs) for op in ops] for ops in layered_ops]
+            l_exp, [{(op.name, op.qargs, op.cargs) for op in ops} for ops in layered_ops]
         )
 
     def test_get_layered_instructions_right_justification_less_simple(self):
@@ -282,35 +282,35 @@ def test_get_layered_instructions_right_justification_less_simple(self):
         (_, _, layered_ops) = _utils._get_layered_instructions(qc, justify="right")
 
         r_exp = [
-            [
+            {
                 ("u2", (Qubit(QuantumRegister(5, "q"), 0),), ()),
                 ("u2", (Qubit(QuantumRegister(5, "q"), 1),), ()),
-            ],
-            [("cx", (Qubit(QuantumRegister(5, "q"), 1), Qubit(QuantumRegister(5, "q"), 0)), ())],
-            [
+            },
+            {("cx", (Qubit(QuantumRegister(5, "q"), 1), Qubit(QuantumRegister(5, "q"), 0)), ())},
+            {
                 ("u2", (Qubit(QuantumRegister(5, "q"), 0),), ()),
                 ("u2", (Qubit(QuantumRegister(5, "q"), 1),), ()),
-            ],
-            [
+            },
+            {
                 (
                     "measure",
                     (Qubit(QuantumRegister(5, "q"), 0),),
                     (Clbit(ClassicalRegister(1, "c1"), 0),),
                 )
-            ],
-            [
+            },
+            {
                 ("u2", (Qubit(QuantumRegister(5, "q"), 0),), ()),
                 ("u2", (Qubit(QuantumRegister(5, "q"), 1),), ()),
-            ],
-            [("cx", (Qubit(QuantumRegister(5, "q"), 1), Qubit(QuantumRegister(5, "q"), 0)), ())],
-            [
+            },
+            {("cx", (Qubit(QuantumRegister(5, "q"), 1), Qubit(QuantumRegister(5, "q"), 0)), ())},
+            {
                 ("u2", (Qubit(QuantumRegister(5, "q"), 0),), ()),
                 ("u2", (Qubit(QuantumRegister(5, "q"), 1),), ()),
-            ],
+            },
         ]
 
         self.assertEqual(
-            r_exp, [[(op.name, op.qargs, op.cargs) for op in ops] for ops in layered_ops]
+            r_exp, [{(op.name, op.qargs, op.cargs) for op in ops} for ops in layered_ops]
         )
 
     def test_get_layered_instructions_op_with_cargs(self):
@@ -335,25 +335,25 @@ def test_get_layered_instructions_op_with_cargs(self):
         (_, _, layered_ops) = _utils._get_layered_instructions(qc)
 
         expected = [
-            [("h", (Qubit(QuantumRegister(2, "q"), 0),), ())],
-            [
+            {("h", (Qubit(QuantumRegister(2, "q"), 0),), ())},
+            {
                 (
                     "measure",
                     (Qubit(QuantumRegister(2, "q"), 0),),
                     (Clbit(ClassicalRegister(2, "c"), 0),),
                 )
-            ],
-            [
+            },
+            {
                 (
                     "add_circ",
                     (Qubit(QuantumRegister(2, "q"), 1),),
                     (Clbit(ClassicalRegister(2, "c"), 0),),
                 )
-            ],
+            },
         ]
 
         self.assertEqual(
-            expected, [[(op.name, op.qargs, op.cargs) for op in ops] for ops in layered_ops]
+            expected, [{(op.name, op.qargs, op.cargs) for op in ops} for ops in layered_ops]
         )
 
     @unittest.skipUnless(optionals.HAS_PYLATEX, "needs pylatexenc")

From 54ac8f17517759e5ae591fe36a73a5ee3ffda615 Mon Sep 17 00:00:00 2001
From: Julien Gacon <jules.gacon@gmail.com>
Date: Mon, 26 Aug 2024 09:35:41 +0200
Subject: [PATCH 22/85] Move the circuit library's entanglement logic to Rust
 (#12950)

* Move ``get_entangler_map`` to Rust

* add reno

* add docs, better arg order

* clippy

* add docs to make reviewers happier

* use Itertools::combinations

thanks @alexanderivrii for the hint!

* avoid usage of convert_idx

* implement reviews

* implement review comments

* rm unused import
---
 .../src/circuit_library/entanglement.rs       | 245 ++++++++++++++++++
 crates/accelerate/src/circuit_library/mod.rs  |  21 ++
 crates/accelerate/src/lib.rs                  |   1 +
 crates/pyext/src/lib.rs                       |  17 +-
 qiskit/__init__.py                            |   1 +
 qiskit/circuit/library/n_local/n_local.py     |  52 +---
 ...ircular-entanglement-5aadd5adf75c0c13.yaml |  16 ++
 test/python/circuit/library/test_nlocal.py    | 157 ++++++++++-
 8 files changed, 456 insertions(+), 54 deletions(-)
 create mode 100644 crates/accelerate/src/circuit_library/entanglement.rs
 create mode 100644 crates/accelerate/src/circuit_library/mod.rs
 create mode 100644 releasenotes/notes/fix-circular-entanglement-5aadd5adf75c0c13.yaml

diff --git a/crates/accelerate/src/circuit_library/entanglement.rs b/crates/accelerate/src/circuit_library/entanglement.rs
new file mode 100644
index 000000000000..db602ef717fa
--- /dev/null
+++ b/crates/accelerate/src/circuit_library/entanglement.rs
@@ -0,0 +1,245 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// 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.
+
+use itertools::Itertools;
+use pyo3::prelude::*;
+use pyo3::{
+    types::{PyAnyMethods, PyInt, PyList, PyListMethods, PyString, PyTuple},
+    Bound, PyAny, PyResult,
+};
+
+use crate::QiskitError;
+
+/// Get all-to-all entanglement. For 4 qubits and block size 2 we have:
+/// [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]
+fn full(num_qubits: u32, block_size: u32) -> impl Iterator<Item = Vec<u32>> {
+    (0..num_qubits).combinations(block_size as usize)
+}
+
+/// Get a linear entanglement structure. For ``n`` qubits and block size ``m`` we have:
+/// [(0..m-1), (1..m), (2..m+1), ..., (n-m..n-1)]
+fn linear(num_qubits: u32, block_size: u32) -> impl DoubleEndedIterator<Item = Vec<u32>> {
+    (0..num_qubits - block_size + 1)
+        .map(move |start_index| (start_index..start_index + block_size).collect())
+}
+
+/// Get a reversed linear entanglement. This is like linear entanglement but in reversed order:
+/// [(n-m..n-1), ..., (1..m), (0..m-1)]
+/// This is particularly interesting, as CX+"full" uses n(n-1)/2 gates, but operationally equals
+/// CX+"reverse_linear", which needs only n-1 gates.
+fn reverse_linear(num_qubits: u32, block_size: u32) -> impl Iterator<Item = Vec<u32>> {
+    linear(num_qubits, block_size).rev()
+}
+
+/// Return the qubit indices for circular entanglement. This is defined as tuples of length ``m``
+/// starting at each possible index ``(0..n)``. Historically, Qiskit starts with index ``n-m+1``.
+/// This is probably easiest understood for a concerete example of 4 qubits and block size 3:
+/// [(2,3,0), (3,0,1), (0,1,2), (1,2,3)]
+fn circular(num_qubits: u32, block_size: u32) -> Box<dyn Iterator<Item = Vec<u32>>> {
+    if block_size == 1 || num_qubits == block_size {
+        Box::new(linear(num_qubits, block_size))
+    } else {
+        let historic_offset = num_qubits - block_size + 1;
+        Box::new((0..num_qubits).map(move |start_index| {
+            (0..block_size)
+                .map(|i| (historic_offset + start_index + i) % num_qubits)
+                .collect()
+        }))
+    }
+}
+
+/// Get pairwise entanglement. This is typically used on 2 qubits and only has a depth of 2, as
+/// first all odd pairs, and then even pairs are entangled. For example on 6 qubits:
+/// [(0, 1), (2, 3), (4, 5), /* now the even pairs */ (1, 2), (3, 4)]
+fn pairwise(num_qubits: u32) -> impl Iterator<Item = Vec<u32>> {
+    // for Python-folks (like me): pairwise is equal to linear[::2] + linear[1::2]
+    linear(num_qubits, 2)
+        .step_by(2)
+        .chain(linear(num_qubits, 2).skip(1).step_by(2))
+}
+
+/// The shifted, circular, alternating (sca) entanglement is motivated from circuits 14/15 of
+/// https://arxiv.org/abs/1905.10876. It corresponds to circular entanglement, with the difference
+/// that in each layer (controlled by ``offset``) the entanglement gates are shifted by one, plus
+/// in each second layer, the entanglement gate is turned upside down.
+/// Offset 0 -> [(2,3,0), (3,0,1), (0,1,2), (1,2,3)]
+/// Offset 1 -> [(3,2,1), (0,3,2), (1,0,3), (2,1,0)]
+/// Offset 2 -> [(0,1,2), (1,2,3), (2,3,0), (3,0,1)]
+/// ...
+fn shift_circular_alternating(
+    num_qubits: u32,
+    block_size: u32,
+    offset: usize,
+) -> Box<dyn Iterator<Item = Vec<u32>>> {
+    // index at which we split the circular iterator -- we use Python-like indexing here,
+    // and define ``split`` as equivalent to a Python index of ``-offset``
+    let split = (num_qubits - (offset as u32 % num_qubits)) % num_qubits;
+    let shifted = circular(num_qubits, block_size)
+        .skip(split as usize)
+        .chain(circular(num_qubits, block_size).take(split as usize));
+    if offset % 2 == 0 {
+        Box::new(shifted)
+    } else {
+        // if the offset is odd, reverse the indices inside the qubit block (e.g. turn CX
+        // gates upside down)
+        Box::new(shifted.map(|indices| indices.into_iter().rev().collect()))
+    }
+}
+
+/// Get an entangler map for an arbitrary number of qubits.
+///
+/// Args:
+///     num_qubits: The number of qubits of the circuit.
+///     block_size: The number of qubits of the entangling block.
+///     entanglement: The entanglement strategy as string.
+///     offset: The block offset, can be used if the entanglements differ per block,
+///         for example used in the "sca" mode.
+///
+/// Returns:
+///     The entangler map using mode ``entanglement`` to scatter a block of ``block_size``
+///     qubits on ``num_qubits`` qubits.
+pub fn get_entanglement_from_str(
+    num_qubits: u32,
+    block_size: u32,
+    entanglement: &str,
+    offset: usize,
+) -> PyResult<Box<dyn Iterator<Item = Vec<u32>>>> {
+    if num_qubits == 0 || block_size == 0 {
+        return Ok(Box::new(std::iter::empty()));
+    }
+
+    if block_size > num_qubits {
+        return Err(QiskitError::new_err(format!(
+            "block_size ({}) cannot be larger than number of qubits ({})",
+            block_size, num_qubits
+        )));
+    }
+
+    match (entanglement, block_size) {
+        ("full", _) => Ok(Box::new(full(num_qubits, block_size))),
+        ("linear", _) => Ok(Box::new(linear(num_qubits, block_size))),
+        ("reverse_linear", _) => Ok(Box::new(reverse_linear(num_qubits, block_size))),
+        ("sca", _) => Ok(shift_circular_alternating(num_qubits, block_size, offset)),
+        ("circular", _) => Ok(circular(num_qubits, block_size)),
+        ("pairwise", 1) => Ok(Box::new(linear(num_qubits, 1))),
+        ("pairwise", 2) => Ok(Box::new(pairwise(num_qubits))),
+        ("pairwise", _) => Err(QiskitError::new_err(format!(
+            "block_size ({}) can be at most 2 for pairwise entanglement",
+            block_size
+        ))),
+        _ => Err(QiskitError::new_err(format!(
+            "Unsupported entanglement: {}",
+            entanglement
+        ))),
+    }
+}
+
+/// Get an entangler map for an arbitrary number of qubits.
+///
+/// Args:
+///     num_qubits: The number of qubits of the circuit.
+///     block_size: The number of qubits of the entangling block.
+///     entanglement: The entanglement strategy.
+///     offset: The block offset, can be used if the entanglements differ per block,
+///         for example used in the "sca" mode.
+///
+/// Returns:
+///     The entangler map using mode ``entanglement`` to scatter a block of ``block_size``
+///     qubits on ``num_qubits`` qubits.
+pub fn get_entanglement<'a>(
+    num_qubits: u32,
+    block_size: u32,
+    entanglement: &'a Bound<PyAny>,
+    offset: usize,
+) -> PyResult<Box<dyn Iterator<Item = PyResult<Vec<u32>>> + 'a>> {
+    // unwrap the callable, if it is one
+    let entanglement = if entanglement.is_callable() {
+        entanglement.call1((offset,))?
+    } else {
+        entanglement.to_owned()
+    };
+
+    if let Ok(strategy) = entanglement.downcast::<PyString>() {
+        let as_str = strategy.to_string();
+        return Ok(Box::new(
+            get_entanglement_from_str(num_qubits, block_size, as_str.as_str(), offset)?.map(Ok),
+        ));
+    } else if let Ok(list) = entanglement.downcast::<PyList>() {
+        let entanglement_iter = list.iter().map(move |el| {
+            let connections = el
+                .downcast::<PyTuple>()?
+                // .expect("Entanglement must be list of tuples") // clearer error message than `?`
+                .iter()
+                .map(|index| index.downcast::<PyInt>()?.extract())
+                .collect::<Result<Vec<u32>, _>>()?;
+
+            if connections.len() != block_size as usize {
+                return Err(QiskitError::new_err(format!(
+                    "Entanglement {:?} does not match block size {}",
+                    connections, block_size
+                )));
+            }
+            Ok(connections)
+        });
+        return Ok(Box::new(entanglement_iter));
+    }
+    Err(QiskitError::new_err(
+        "Entanglement must be a string or list of qubit indices.",
+    ))
+}
+
+/// Get the entanglement for given number of qubits and block size.
+///
+/// Args:
+///     num_qubits: The number of qubits to entangle.
+///     block_size: The entanglement block size (e.g. 2 for CX or 3 for CCX).
+///     entanglement: The entanglement strategy. This can be one of:
+///
+///         * string: Available options are ``"full"``, ``"linear"``, ``"pairwise"``
+///             ``"reverse_linear"``, ``"circular"``, or ``"sca"``.
+///         * list of tuples: A list of entanglements given as tuple, e.g. [(0, 1), (1, 2)].
+///         * callable: A callable that takes as input an offset as ``int`` (usually the layer
+///             in the variational circuit) and returns a string or list of tuples to use as
+///             entanglement in this layer.
+///
+///     offset: An offset used by certain entanglement strategies (e.g. ``"sca"``) or if the
+///         entanglement is given as callable. This is typically used to have different
+///         entanglement structures in different layers of variational quantum circuits.
+///
+/// Returns:
+///     The entanglement as list of tuples.
+///
+/// Raises:
+///     QiskitError: In case the entanglement is invalid.
+#[pyfunction]
+#[pyo3(signature = (num_qubits, block_size, entanglement, offset=0))]
+pub fn get_entangler_map<'py>(
+    py: Python<'py>,
+    num_qubits: u32,
+    block_size: u32,
+    entanglement: &Bound<PyAny>,
+    offset: usize,
+) -> PyResult<Vec<Bound<'py, PyTuple>>> {
+    // The entanglement is Result<impl Iterator<Item = Result<Vec<u32>>>>, so there's two
+    // levels of errors we must handle: the outer error is handled by the outer match statement,
+    // and the inner (Result<Vec<u32>>) is handled upon the PyTuple creation.
+    match get_entanglement(num_qubits, block_size, entanglement, offset) {
+        Ok(entanglement) => entanglement
+            .into_iter()
+            .map(|vec| match vec {
+                Ok(vec) => Ok(PyTuple::new_bound(py, vec)),
+                Err(e) => Err(e),
+            })
+            .collect::<Result<Vec<_>, _>>(),
+        Err(e) => Err(e),
+    }
+}
diff --git a/crates/accelerate/src/circuit_library/mod.rs b/crates/accelerate/src/circuit_library/mod.rs
new file mode 100644
index 000000000000..d0444c484dc8
--- /dev/null
+++ b/crates/accelerate/src/circuit_library/mod.rs
@@ -0,0 +1,21 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// 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.
+
+use pyo3::prelude::*;
+
+mod entanglement;
+
+#[pymodule]
+pub fn circuit_library(m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_wrapped(wrap_pyfunction!(entanglement::get_entangler_map))?;
+    Ok(())
+}
diff --git a/crates/accelerate/src/lib.rs b/crates/accelerate/src/lib.rs
index 4e079ea84b57..5414183d22cc 100644
--- a/crates/accelerate/src/lib.rs
+++ b/crates/accelerate/src/lib.rs
@@ -14,6 +14,7 @@ use std::env;
 
 use pyo3::import_exception;
 
+pub mod circuit_library;
 pub mod convert_2q_block_matrix;
 pub mod dense_layout;
 pub mod edge_collections;
diff --git a/crates/pyext/src/lib.rs b/crates/pyext/src/lib.rs
index 04b0c0609347..e8971bc87629 100644
--- a/crates/pyext/src/lib.rs
+++ b/crates/pyext/src/lib.rs
@@ -13,14 +13,14 @@
 use pyo3::prelude::*;
 
 use qiskit_accelerate::{
-    convert_2q_block_matrix::convert_2q_block_matrix, dense_layout::dense_layout,
-    error_map::error_map, euler_one_qubit_decomposer::euler_one_qubit_decomposer,
-    isometry::isometry, nlayout::nlayout, optimize_1q_gates::optimize_1q_gates,
-    pauli_exp_val::pauli_expval, results::results, sabre::sabre, sampled_exp_val::sampled_exp_val,
-    sparse_pauli_op::sparse_pauli_op, star_prerouting::star_prerouting,
-    stochastic_swap::stochastic_swap, synthesis::synthesis, target_transpiler::target,
-    two_qubit_decompose::two_qubit_decompose, uc_gate::uc_gate, utils::utils,
-    vf2_layout::vf2_layout,
+    circuit_library::circuit_library, convert_2q_block_matrix::convert_2q_block_matrix,
+    dense_layout::dense_layout, error_map::error_map,
+    euler_one_qubit_decomposer::euler_one_qubit_decomposer, isometry::isometry, nlayout::nlayout,
+    optimize_1q_gates::optimize_1q_gates, pauli_exp_val::pauli_expval, results::results,
+    sabre::sabre, sampled_exp_val::sampled_exp_val, sparse_pauli_op::sparse_pauli_op,
+    star_prerouting::star_prerouting, stochastic_swap::stochastic_swap, synthesis::synthesis,
+    target_transpiler::target, two_qubit_decompose::two_qubit_decompose, uc_gate::uc_gate,
+    utils::utils, vf2_layout::vf2_layout,
 };
 
 #[inline(always)]
@@ -39,6 +39,7 @@ fn _accelerate(m: &Bound<PyModule>) -> PyResult<()> {
     add_submodule(m, qiskit_circuit::circuit, "circuit")?;
     add_submodule(m, qiskit_qasm2::qasm2, "qasm2")?;
     add_submodule(m, qiskit_qasm3::qasm3, "qasm3")?;
+    add_submodule(m, circuit_library, "circuit_library")?;
     add_submodule(m, convert_2q_block_matrix, "convert_2q_block_matrix")?;
     add_submodule(m, dense_layout, "dense_layout")?;
     add_submodule(m, error_map, "error_map")?;
diff --git a/qiskit/__init__.py b/qiskit/__init__.py
index 6a8df393307e..33933fd8fd7e 100644
--- a/qiskit/__init__.py
+++ b/qiskit/__init__.py
@@ -60,6 +60,7 @@
 # We manually define them on import so people can directly import qiskit._accelerate.* submodules
 # and not have to rely on attribute access.  No action needed for top-level extension packages.
 sys.modules["qiskit._accelerate.circuit"] = _accelerate.circuit
+sys.modules["qiskit._accelerate.circuit_library"] = _accelerate.circuit_library
 sys.modules["qiskit._accelerate.convert_2q_block_matrix"] = _accelerate.convert_2q_block_matrix
 sys.modules["qiskit._accelerate.dense_layout"] = _accelerate.dense_layout
 sys.modules["qiskit._accelerate.error_map"] = _accelerate.error_map
diff --git a/qiskit/circuit/library/n_local/n_local.py b/qiskit/circuit/library/n_local/n_local.py
index 2a750195dab3..f948a458ad7b 100644
--- a/qiskit/circuit/library/n_local/n_local.py
+++ b/qiskit/circuit/library/n_local/n_local.py
@@ -31,9 +31,11 @@
 )
 from qiskit.exceptions import QiskitError
 from qiskit.circuit.library.standard_gates import get_standard_gate_name_mapping
+from qiskit._accelerate.circuit_library import get_entangler_map as fast_entangler_map
 
 from ..blueprintcircuit import BlueprintCircuit
 
+
 if typing.TYPE_CHECKING:
     import qiskit  # pylint: disable=cyclic-import
 
@@ -1037,51 +1039,11 @@ def get_entangler_map(
     Raises:
         ValueError: If the entanglement mode ist not supported.
     """
-    n, m = num_circuit_qubits, num_block_qubits
-    if m > n:
-        raise ValueError(
-            "The number of block qubits must be smaller or equal to the number of "
-            "qubits in the circuit."
-        )
-
-    if entanglement == "pairwise" and num_block_qubits > 2:
-        raise ValueError("Pairwise entanglement is not defined for blocks with more than 2 qubits.")
-
-    if entanglement == "full":
-        return list(itertools.combinations(list(range(n)), m))
-    elif entanglement == "reverse_linear":
-        # reverse linear connectivity. In the case of m=2 and the entanglement_block='cx'
-        # then it's equivalent to 'full' entanglement
-        reverse = [tuple(range(n - i - m, n - i)) for i in range(n - m + 1)]
-        return reverse
-    elif entanglement in ["linear", "circular", "sca", "pairwise"]:
-        linear = [tuple(range(i, i + m)) for i in range(n - m + 1)]
-        # if the number of block qubits is 1, we don't have to add the 'circular' part
-        if entanglement == "linear" or m == 1:
-            return linear
-
-        if entanglement == "pairwise":
-            return linear[::2] + linear[1::2]
-
-        # circular equals linear plus top-bottom entanglement (if there's space for it)
-        if n > m:
-            circular = [tuple(range(n - m + 1, n)) + (0,)] + linear
-        else:
-            circular = linear
-        if entanglement == "circular":
-            return circular
-
-        # sca is circular plus shift and reverse
-        shifted = circular[-offset:] + circular[:-offset]
-        if offset % 2 == 1:  # if odd, reverse the qubit indices
-            sca = [ind[::-1] for ind in shifted]
-        else:
-            sca = shifted
-
-        return sca
-
-    else:
-        raise ValueError(f"Unsupported entanglement type: {entanglement}")
+    try:
+        return fast_entangler_map(num_circuit_qubits, num_block_qubits, entanglement, offset)
+    except Exception as exc:
+        # need this as Rust is now raising a QiskitError, where this function was raising ValueError
+        raise ValueError("Something went wrong in Rust space, here's the error:") from exc
 
 
 _StdlibGateResult = collections.namedtuple("_StdlibGateResult", ("gate", "num_params"))
diff --git a/releasenotes/notes/fix-circular-entanglement-5aadd5adf75c0c13.yaml b/releasenotes/notes/fix-circular-entanglement-5aadd5adf75c0c13.yaml
new file mode 100644
index 000000000000..fbede3d31756
--- /dev/null
+++ b/releasenotes/notes/fix-circular-entanglement-5aadd5adf75c0c13.yaml
@@ -0,0 +1,16 @@
+fixes:
+  - |
+    Fixed a bug with the ``"circular"`` and ``"sca"`` entanglement for
+    :class:`.NLocal` circuits and its derivatives. For entanglement blocks
+    of more than 2 qubits, the circular entanglement was previously missing
+    some connections. For example, for 4 qubits and a block size of 3 the
+    code previously used::
+
+      [(2, 3, 0), (0, 1, 2), (1, 2, 3)]
+
+    but now is correctly adding the ``(3, 0, 1)`` connections, that is::
+
+      [(2, 3, 0), (3, 0, 1), (0, 1, 2), (1, 2, 3)]
+
+    As such, the ``"circular"`` and ``"sca"`` entanglements use ``num_qubits``
+    entangling blocks per layer.
diff --git a/test/python/circuit/library/test_nlocal.py b/test/python/circuit/library/test_nlocal.py
index 2e308af48ff4..dd39aa61ba61 100644
--- a/test/python/circuit/library/test_nlocal.py
+++ b/test/python/circuit/library/test_nlocal.py
@@ -42,6 +42,10 @@
 from qiskit.circuit.random.utils import random_circuit
 from qiskit.converters.circuit_to_dag import circuit_to_dag
 from qiskit.quantum_info import Operator
+from qiskit.exceptions import QiskitError
+
+from qiskit._accelerate.circuit_library import get_entangler_map as fast_entangler_map
+
 from test import QiskitTestCase  # pylint: disable=wrong-import-order
 
 
@@ -339,7 +343,7 @@ def get_expected_entangler_map(rep_num, mode):
                     (2, 3, 4),
                 ]
             else:
-                circular = [(3, 4, 0), (0, 1, 2), (1, 2, 3), (2, 3, 4)]
+                circular = [(3, 4, 0), (4, 0, 1), (0, 1, 2), (1, 2, 3), (2, 3, 4)]
                 if mode == "circular":
                     return circular
                 sca = circular[-rep_num:] + circular[:-rep_num]
@@ -928,5 +932,156 @@ def test_full_vs_reverse_linear(self, num_qubits):
         self.assertEqual(Operator(full), Operator(reverse))
 
 
+@ddt
+class TestEntanglement(QiskitTestCase):
+    """Test getting the entanglement structure."""
+
+    @data(
+        ("linear", [(0, 1), (1, 2), (2, 3)]),
+        ("reverse_linear", [(2, 3), (1, 2), (0, 1)]),
+        ("pairwise", [(0, 1), (2, 3), (1, 2)]),
+        ("circular", [(3, 0), (0, 1), (1, 2), (2, 3)]),
+        ("full", [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]),
+    )
+    @unpack
+    def test_2q_str(self, strategy, expected):
+        """Test getting by string."""
+        entanglement = fast_entangler_map(
+            num_qubits=4, block_size=2, entanglement=strategy, offset=0
+        )
+        self.assertEqual(expected, entanglement)
+
+    @data(
+        ("linear", [(0, 1, 2), (1, 2, 3)]),
+        ("reverse_linear", [(1, 2, 3), (0, 1, 2)]),
+        ("circular", [(2, 3, 0), (3, 0, 1), (0, 1, 2), (1, 2, 3)]),
+        ("full", [(0, 1, 2), (0, 1, 3), (0, 2, 3), (1, 2, 3)]),
+    )
+    @unpack
+    def test_3q_str(self, strategy, expected):
+        """Test getting by string."""
+        entanglement = fast_entangler_map(
+            num_qubits=4, block_size=3, entanglement=strategy, offset=0
+        )
+        self.assertEqual(expected, entanglement)
+
+    def test_2q_sca(self):
+        """Test shift, circular, alternating on 2-qubit blocks."""
+        expected = {  # offset: result
+            0: [(3, 0), (0, 1), (1, 2), (2, 3)],
+            1: [(3, 2), (0, 3), (1, 0), (2, 1)],
+            2: [(1, 2), (2, 3), (3, 0), (0, 1)],
+            3: [(1, 0), (2, 1), (3, 2), (0, 3)],
+        }
+        for offset in range(8):
+            with self.subTest(offset=offset):
+                entanglement = fast_entangler_map(
+                    num_qubits=4, block_size=2, entanglement="sca", offset=offset
+                )
+                self.assertEqual(expected[offset % 4], entanglement)
+
+    def test_3q_sca(self):
+        """Test shift, circular, alternating on 3-qubit blocks."""
+        circular = [(2, 3, 0), (3, 0, 1), (0, 1, 2), (1, 2, 3)]
+        for offset in range(8):
+            expected = circular[-(offset % 4) :] + circular[: -(offset % 4)]
+            if offset % 2 == 1:
+                expected = [tuple(reversed(indices)) for indices in expected]
+            with self.subTest(offset=offset):
+                entanglement = fast_entangler_map(
+                    num_qubits=4, block_size=3, entanglement="sca", offset=offset
+                )
+                self.assertEqual(expected, entanglement)
+
+    @data("full", "reverse_linear", "linear", "circular", "sca", "pairwise")
+    def test_0q(self, entanglement):
+        """Test the corner case of a single qubit block."""
+        entanglement = fast_entangler_map(
+            num_qubits=3, block_size=0, entanglement=entanglement, offset=0
+        )
+        expect = []
+        self.assertEqual(entanglement, expect)
+
+    @data("full", "reverse_linear", "linear", "circular", "sca", "pairwise")
+    def test_1q(self, entanglement):
+        """Test the corner case of a single qubit block."""
+        entanglement = fast_entangler_map(
+            num_qubits=3, block_size=1, entanglement=entanglement, offset=0
+        )
+        expect = [(i,) for i in range(3)]
+
+        self.assertEqual(set(entanglement), set(expect))  # order does not matter for 1 qubit
+
+    @data("full", "reverse_linear", "linear", "circular", "sca")
+    def test_full_block(self, entanglement):
+        """Test the corner case of the block size equal the number of qubits."""
+        entanglement = fast_entangler_map(
+            num_qubits=5, block_size=5, entanglement=entanglement, offset=0
+        )
+        expect = [tuple(range(5))]
+
+        self.assertEqual(entanglement, expect)
+
+    def test_pairwise_limit(self):
+        """Test pairwise raises an error above 2 qubits."""
+        _ = fast_entangler_map(num_qubits=4, block_size=1, entanglement="pairwise", offset=0)
+        _ = fast_entangler_map(num_qubits=4, block_size=2, entanglement="pairwise", offset=0)
+        with self.assertRaises(QiskitError):
+            _ = fast_entangler_map(num_qubits=4, block_size=3, entanglement="pairwise", offset=0)
+
+    def test_invalid_blocksize(self):
+        """Test the block size being too large."""
+        with self.assertRaises(QiskitError):
+            _ = fast_entangler_map(num_qubits=2, block_size=3, entanglement="linear", offset=0)
+
+    def test_invalid_entanglement_str(self):
+        """Test invalid entanglement string."""
+        with self.assertRaises(QiskitError):
+            _ = fast_entangler_map(num_qubits=4, block_size=2, entanglement="lniaer", offset=0)
+
+    def test_as_list(self):
+        """Test passing a list just returns the list."""
+        expected = [(0, 1), (1, 10), (2, 10)]
+        out = fast_entangler_map(num_qubits=20, block_size=2, entanglement=expected, offset=0)
+        self.assertEqual(expected, out)
+
+    def test_invalid_list(self):
+        """Test passing a list that does not match the block size."""
+
+        # TODO this test fails, somehow the error is not propagated correctly!
+        expected = [(0, 1), (1, 2, 10)]
+        with self.assertRaises(QiskitError):
+            _ = fast_entangler_map(num_qubits=20, block_size=2, entanglement=expected, offset=0)
+
+    def test_callable_list(self):
+        """Test using a callable."""
+
+        def my_entanglement(offset):
+            return [(0, 1)] if offset % 2 == 0 else [(1, 2)]
+
+        for offset in range(3):
+            with self.subTest(offset=offset):
+                expect = my_entanglement(offset)
+                result = fast_entangler_map(
+                    num_qubits=3, block_size=2, entanglement=my_entanglement, offset=offset
+                )
+                self.assertEqual(expect, result)
+
+    def test_callable_str(self):
+        """Test using a callable."""
+
+        def my_entanglement(offset):
+            return "linear" if offset % 2 == 0 else "pairwise"
+
+        expected = {"linear": [(0, 1), (1, 2), (2, 3)], "pairwise": [(0, 1), (2, 3), (1, 2)]}
+
+        for offset in range(3):
+            with self.subTest(offset=offset):
+                result = fast_entangler_map(
+                    num_qubits=4, block_size=2, entanglement=my_entanglement, offset=offset
+                )
+                self.assertEqual(expected["linear" if offset % 2 == 0 else "pairwise"], result)
+
+
 if __name__ == "__main__":
     unittest.main()

From 83ecf39656f41dfca811ae73d4d4292d0b935338 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Timoth=C3=A9e=20Dao?=
 <100034085+timmintam@users.noreply.github.com>
Date: Mon, 26 Aug 2024 10:17:49 +0200
Subject: [PATCH 23/85] Fix `UnitaryGate.repeat()` method (#12986)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix: deal with special case for `UnitaryGate`

* add test

* add release note

* typo

* generalize the fix to other gates

* fix seeds

* update unittests

* Add missing unittests

---------

Co-authored-by: Luciano Bello <bel@zurich.ibm.com>
Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>
---
 qiskit/circuit/gate.py                            |  5 ++++-
 .../notes/fix_11990-8551c7250207fc76.yaml         |  6 ++++++
 .../circuit/library/test_linear_function.py       | 13 +++++++++++++
 test/python/circuit/library/test_permutation.py   |  6 ++++++
 test/python/circuit/test_diagonal_gate.py         | 13 +++++++++++++
 test/python/circuit/test_gate_definitions.py      | 14 ++++++++++++++
 test/python/circuit/test_hamiltonian_gate.py      |  6 ++++++
 test/python/circuit/test_initializer.py           | 10 ++++++++++
 test/python/circuit/test_isometry.py              | 15 +++++++++++++++
 test/python/circuit/test_uc.py                    |  7 +++++++
 test/python/circuit/test_unitary.py               |  5 +++++
 11 files changed, 99 insertions(+), 1 deletion(-)
 create mode 100644 releasenotes/notes/fix_11990-8551c7250207fc76.yaml

diff --git a/qiskit/circuit/gate.py b/qiskit/circuit/gate.py
index 37fd19e2022a..2f1c09668252 100644
--- a/qiskit/circuit/gate.py
+++ b/qiskit/circuit/gate.py
@@ -97,7 +97,10 @@ def __pow__(self, exponent: float) -> "Gate":
         return self.power(exponent)
 
     def _return_repeat(self, exponent: float) -> "Gate":
-        return Gate(name=f"{self.name}*{exponent}", num_qubits=self.num_qubits, params=self.params)
+        gate = Gate(name=f"{self.name}*{exponent}", num_qubits=self.num_qubits, params=[])
+        gate.validate_parameter = self.validate_parameter
+        gate.params = self.params
+        return gate
 
     def control(
         self,
diff --git a/releasenotes/notes/fix_11990-8551c7250207fc76.yaml b/releasenotes/notes/fix_11990-8551c7250207fc76.yaml
new file mode 100644
index 000000000000..68912403cd39
--- /dev/null
+++ b/releasenotes/notes/fix_11990-8551c7250207fc76.yaml
@@ -0,0 +1,6 @@
+---
+fixes:
+  - |
+    Fixes an error when calling the method :meth:`.UnitaryGate.repeat`. 
+    Refer to `#11990 <https://github.com/Qiskit/qiskit/issues/11990>`_ for more
+    details.
\ No newline at end of file
diff --git a/test/python/circuit/library/test_linear_function.py b/test/python/circuit/library/test_linear_function.py
index a3df1e9664a2..b7756faa7aa7 100644
--- a/test/python/circuit/library/test_linear_function.py
+++ b/test/python/circuit/library/test_linear_function.py
@@ -502,6 +502,19 @@ def test_clifford_linear_function_equivalence(self, num_qubits):
         self.assertEqual(Clifford(qc_to_linear_function), qc_to_clifford)
         self.assertEqual(qc_to_linear_function, LinearFunction(qc_to_clifford))
 
+    @data(2, 3)
+    def test_repeat_method(self, num_qubits):
+        """Test the repeat() method."""
+        rng = np.random.default_rng(127)
+        for num_gates, seed in zip(
+            [0, 5, 5 * num_qubits], rng.integers(100000, size=10, dtype=np.uint64)
+        ):
+            # create a random linear circuit
+            linear_circuit = random_linear_circuit(num_qubits, num_gates, seed=seed)
+            operator = Operator(linear_circuit)
+            linear_function = LinearFunction(linear_circuit)
+            self.assertTrue(Operator(linear_function.repeat(2)), operator @ operator)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/test/python/circuit/library/test_permutation.py b/test/python/circuit/library/test_permutation.py
index 30d504d7dc8f..a2ec59431fe3 100644
--- a/test/python/circuit/library/test_permutation.py
+++ b/test/python/circuit/library/test_permutation.py
@@ -104,6 +104,12 @@ def test_inverse(self):
         expected_inverse_perm = PermutationGate([3, 0, 5, 1, 4, 2])
         self.assertTrue(np.array_equal(inverse_perm.pattern, expected_inverse_perm.pattern))
 
+    def test_repeat(self):
+        """Test the ``repeat`` method."""
+        pattern = [2, 4, 1, 3, 0]
+        perm = PermutationGate(pattern)
+        self.assertTrue(np.allclose(Operator(perm.repeat(2)), Operator(perm) @ Operator(perm)))
+
 
 class TestPermutationGatesOnCircuit(QiskitTestCase):
     """Tests for quantum circuits containing permutations."""
diff --git a/test/python/circuit/test_diagonal_gate.py b/test/python/circuit/test_diagonal_gate.py
index de8d53e12d3b..bb9259999576 100644
--- a/test/python/circuit/test_diagonal_gate.py
+++ b/test/python/circuit/test_diagonal_gate.py
@@ -83,6 +83,19 @@ def test_npcomplex_params_conversion(self):
                 all(isinstance(p, complex) and not isinstance(p, np.number) for p in params)
             )
 
+    def test_repeat(self):
+        """Test the repeat() method."""
+        for phases in [
+            [0, 0],
+            np.array([0, 0.8, 1, 0]),
+            (2 * np.pi * np.random.rand(2**3)).tolist(),
+        ]:
+            with self.subTest(phases=phases):
+                diag = [np.exp(1j * ph) for ph in phases]
+                gate = DiagonalGate(diag)
+                operator = Operator(gate)
+                self.assertTrue(np.allclose(Operator(gate.repeat(2)), operator @ operator))
+
 
 def _get_diag_gate_matrix(diag):
     return np.diagflat(diag)
diff --git a/test/python/circuit/test_gate_definitions.py b/test/python/circuit/test_gate_definitions.py
index 950b0c478ed8..914ac8bab985 100644
--- a/test/python/circuit/test_gate_definitions.py
+++ b/test/python/circuit/test_gate_definitions.py
@@ -54,6 +54,8 @@
     CZGate,
     RYYGate,
     PhaseGate,
+    PauliGate,
+    UCPauliRotGate,
     CPhaseGate,
     UGate,
     CUGate,
@@ -184,6 +186,18 @@ def test_xx_minus_yy_definition(self):
         self.assertTrue(len(decomposed_circuit) > len(circuit))
         self.assertTrue(Operator(circuit).equiv(Operator(decomposed_circuit), atol=1e-7))
 
+    def test_pauligate_repeat(self):
+        """Test `repeat` method for `PauliGate`."""
+        gate = PauliGate("XYZ")
+        operator = Operator(gate)
+        self.assertTrue(np.allclose(Operator(gate.repeat(2)), operator @ operator))
+
+    def test_ucpaulirotgate_repeat(self):
+        """Test `repeat` method for `UCPauliRotGate`."""
+        gate = UCPauliRotGate([0.3, 0.5], "X")
+        operator = Operator(gate)
+        self.assertTrue(np.allclose(Operator(gate.repeat(2)), operator @ operator))
+
 
 @ddt
 class TestStandardGates(QiskitTestCase):
diff --git a/test/python/circuit/test_hamiltonian_gate.py b/test/python/circuit/test_hamiltonian_gate.py
index 60fb1e9a90a9..e65e2f07ba5e 100644
--- a/test/python/circuit/test_hamiltonian_gate.py
+++ b/test/python/circuit/test_hamiltonian_gate.py
@@ -62,6 +62,12 @@ def test_adjoint(self):
             ham.adjoint().to_matrix(), np.transpose(np.conj(ham.to_matrix()))
         )
 
+    def test_repeat(self):
+        """test repeat operation"""
+        ham = HamiltonianGate(np.array([[1, 0.5 + 4j], [0.5 - 4j, -0.2]]), np.pi * 0.143)
+        operator = Operator(ham)
+        self.assertTrue(np.allclose(Operator(ham.repeat(2)), operator @ operator))
+
 
 class TestHamiltonianCircuit(QiskitTestCase):
     """Hamiltonian gate circuit tests."""
diff --git a/test/python/circuit/test_initializer.py b/test/python/circuit/test_initializer.py
index 2507fbc6c139..990df5755d59 100644
--- a/test/python/circuit/test_initializer.py
+++ b/test/python/circuit/test_initializer.py
@@ -473,6 +473,16 @@ def test_gates_to_uncompute(self):
         vec = Statevector(qc)
         self.assertTrue(vec == Statevector(desired_vector))
 
+    def test_repeat(self):
+        """Test the repeat() method."""
+        desired_vector = np.array([0.5, 0.5, 0.5, 0.5])
+        initialize = Initialize(desired_vector)
+        qr = QuantumRegister(2)
+        qc = QuantumCircuit(qr)
+        qc.append(initialize.repeat(2), qr)
+        statevector = Statevector(qc)
+        self.assertTrue(np.allclose(statevector, desired_vector))
+
 
 class TestInstructionParam(QiskitTestCase):
     """Test conversion of numpy type parameters."""
diff --git a/test/python/circuit/test_isometry.py b/test/python/circuit/test_isometry.py
index 35ff639cedd5..ff497c76f48a 100644
--- a/test/python/circuit/test_isometry.py
+++ b/test/python/circuit/test_isometry.py
@@ -133,6 +133,21 @@ def test_isometry_inverse(self, iso):
         result = Operator(qc)
         np.testing.assert_array_almost_equal(result.data, np.identity(result.dim[0]))
 
+    @data(
+        np.eye(2, 2),
+        random_unitary(2, seed=297102).data,
+        np.eye(4, 4),
+        random_unitary(4, seed=123642).data,
+        random_unitary(8, seed=568288).data,
+    )
+    def test_isometry_repeat(self, iso):
+        """Tests for the repeat of isometries from n to n qubits"""
+        iso_gate = Isometry(iso, 0, 0)
+
+        op = Operator(iso_gate)
+        op_double = Operator(iso_gate.repeat(2))
+        np.testing.assert_array_almost_equal(op @ op, op_double)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/test/python/circuit/test_uc.py b/test/python/circuit/test_uc.py
index 87541d349c3f..0277c4afb43d 100644
--- a/test/python/circuit/test_uc.py
+++ b/test/python/circuit/test_uc.py
@@ -100,6 +100,13 @@ def test_inverse_ucg(self):
 
         self.assertTrue(np.allclose(unitary_desired, unitary))
 
+    def test_repeat(self):
+        """test repeat operation"""
+        gates = [random_unitary(2, seed=seed).data for seed in [124435, 876345, 687462, 928365]]
+
+        uc = UCGate(gates, up_to_diagonal=False)
+        self.assertTrue(np.allclose(Operator(uc.repeat(2)), Operator(uc) @ Operator(uc)))
+
 
 def _get_ucg_matrix(squs):
     return block_diag(*squs)
diff --git a/test/python/circuit/test_unitary.py b/test/python/circuit/test_unitary.py
index 63edbdaffbf9..6ab4a93c3f7d 100644
--- a/test/python/circuit/test_unitary.py
+++ b/test/python/circuit/test_unitary.py
@@ -67,6 +67,11 @@ def test_adjoint(self):
         uni = UnitaryGate([[0, 1j], [-1j, 0]])
         self.assertTrue(numpy.array_equal(uni.adjoint().to_matrix(), uni.to_matrix()))
 
+    def test_repeat(self):
+        """test repeat operation"""
+        uni = UnitaryGate([[1, 0], [0, 1j]])
+        self.assertTrue(numpy.array_equal(Operator(uni.repeat(2)), Operator(uni) @ Operator(uni)))
+
 
 class TestUnitaryCircuit(QiskitTestCase):
     """Matrix gate circuit tests."""

From f537602b8d69c38b4182390ed195899401b4efc5 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 26 Aug 2024 09:06:08 -0400
Subject: [PATCH 24/85] Bump faer from 0.19.1 to 0.19.2 (#13037)

Bumps [faer](https://github.com/sarah-ek/faer-rs) from 0.19.1 to 0.19.2.
- [Changelog](https://github.com/sarah-ek/faer-rs/blob/main/CHANGELOG.md)
- [Commits](https://github.com/sarah-ek/faer-rs/commits)

---
updated-dependencies:
- dependency-name: faer
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock                   | 62 ++++++++++++++++++++++++------------
 crates/accelerate/Cargo.toml |  2 +-
 2 files changed, 42 insertions(+), 22 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 12daf2e6299e..394e03f5d122 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -117,7 +117,7 @@ checksum = "4da9a32f3fed317401fa3c862968128267c3106685286e15d5aaa3d7389c2f60"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.60",
+ "syn 2.0.76",
 ]
 
 [[package]]
@@ -276,7 +276,7 @@ dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn 2.0.60",
+ "syn 2.0.76",
 ]
 
 [[package]]
@@ -285,7 +285,16 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c35da53b5a021d2484a7cc49b2ac7f2d840f8236a286f84202369bd338d761ea"
 dependencies = [
- "equator-macro",
+ "equator-macro 0.2.1",
+]
+
+[[package]]
+name = "equator"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5099e7b6f0b7431c7a1c49f75929e2777693da192784f167066977a2965767af"
+dependencies = [
+ "equator-macro 0.4.1",
 ]
 
 [[package]]
@@ -296,7 +305,18 @@ checksum = "3bf679796c0322556351f287a51b49e48f7c4986e727b5dd78c972d30e2e16cc"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.60",
+ "syn 2.0.76",
+]
+
+[[package]]
+name = "equator-macro"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5322a90066ddae2b705096eb9e10c465c0498ae93bf9bdd6437415327c88e3bb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.76",
 ]
 
 [[package]]
@@ -307,15 +327,15 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
 
 [[package]]
 name = "faer"
-version = "0.19.1"
+version = "0.19.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41543c4de4bfb32efdffdd75cbcca5ef41b800e8a811ea4a41fb9393c6ef3bc0"
+checksum = "fe8894ad9275f1fd708e2f114f4059e80057ad3cc150b77a3f8a7991dd47ab37"
 dependencies = [
  "bytemuck",
  "coe-rs",
  "dbgf",
  "dyn-stack",
- "equator",
+ "equator 0.4.1",
  "faer-entity",
  "gemm",
  "libm",
@@ -335,9 +355,9 @@ dependencies = [
 
 [[package]]
 name = "faer-entity"
-version = "0.19.0"
+version = "0.19.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab968a02be27be95de0f1ad0af901b865fa0866b6a9b553a6cc9cf7f19c2ce71"
+checksum = "c9c752ab2bff6f0b9597c6a1adc0112f7fd41fb343bc5a009a6274ae9d32fd03"
 dependencies = [
  "bytemuck",
  "coe-rs",
@@ -693,7 +713,7 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f563548d38f390ef9893e4883ec38c1fb312f569e98d76bededdd91a3b41a043"
 dependencies = [
- "equator",
+ "equator 0.2.2",
  "nano-gemm-c32",
  "nano-gemm-c64",
  "nano-gemm-codegen",
@@ -970,7 +990,7 @@ dependencies = [
  "pest_meta",
  "proc-macro2",
  "quote",
- "syn 2.0.60",
+ "syn 2.0.76",
 ]
 
 [[package]]
@@ -1043,9 +1063,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.81"
+version = "1.0.86"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d1597b0c024618f09a9c3b8655b7e430397a36d23fdafec26d6965e9eec3eba"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
 dependencies = [
  "unicode-ident",
 ]
@@ -1071,7 +1091,7 @@ checksum = "d315b3197b780e4873bc0e11251cb56a33f65a6032a3d39b8d1405c255513766"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.60",
+ "syn 2.0.76",
 ]
 
 [[package]]
@@ -1139,7 +1159,7 @@ dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
  "quote",
- "syn 2.0.60",
+ "syn 2.0.76",
 ]
 
 [[package]]
@@ -1152,7 +1172,7 @@ dependencies = [
  "proc-macro2",
  "pyo3-build-config",
  "quote",
- "syn 2.0.60",
+ "syn 2.0.76",
 ]
 
 [[package]]
@@ -1457,7 +1477,7 @@ checksum = "856f046b9400cee3c8c94ed572ecdb752444c24528c035cd35882aad6f492bcb"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.60",
+ "syn 2.0.76",
 ]
 
 [[package]]
@@ -1499,9 +1519,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.60"
+version = "2.0.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "909518bc7b1c9b779f1bbf07f2929d35af9f0f37e47c6e9ef7f9dddc1e1821f3"
+checksum = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1551,7 +1571,7 @@ checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.60",
+ "syn 2.0.76",
 ]
 
 [[package]]
@@ -1847,5 +1867,5 @@ checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.60",
+ "syn 2.0.76",
 ]
diff --git a/crates/accelerate/Cargo.toml b/crates/accelerate/Cargo.toml
index 838fc0153577..3248e61e29ac 100644
--- a/crates/accelerate/Cargo.toml
+++ b/crates/accelerate/Cargo.toml
@@ -20,7 +20,7 @@ num-traits = "0.2"
 num-complex.workspace = true
 rustworkx-core.workspace = true
 num-bigint.workspace = true
-faer = "0.19.1"
+faer = "0.19.2"
 itertools.workspace = true
 qiskit-circuit.workspace = true
 thiserror.workspace = true

From cc87318f91fbe828ffc09f4d8865ff76af234b90 Mon Sep 17 00:00:00 2001
From: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>
Date: Mon, 26 Aug 2024 11:38:24 -0400
Subject: [PATCH 25/85] Expose `CircuitData` interners and registers to the
 `qiskit-circuit` crate (#13006)

* Initial: Expose `CircuitData` interners and registers to the `qiskit-circuit` crate.
- Make the `CircuitData` iter method be an exact-size iterator.

* FIx: Expose immutable views of interners, registers and global phase.
- Revert the changes making the interners and registers visible to the crate `qiskit-circuit`.
- Create methods to expose immutable borrowed views of the interners, registers and global_phase to prevent from mutating the DAGCircuit.
- Add `get_qargs` and `get_cargs` to unpack interned qargs ans cargs.
- Other tweaks and fixes.

* Format: Fix typo in comment

Co-authored-by: Eli Arbel <46826214+eliarbel@users.noreply.github.com>

* Refactor: Use naming convention for getters.

* Docs: Apply suggestions from code review

- Correct incorrect docstrings for `qubits()` and `clbits()`

Co-authored-by: Eli Arbel <46826214+eliarbel@users.noreply.github.com>

---------

Co-authored-by: Eli Arbel <46826214+eliarbel@users.noreply.github.com>
---
 crates/circuit/src/circuit_data.rs | 45 ++++++++++++++++++++++++++----
 1 file changed, 40 insertions(+), 5 deletions(-)

diff --git a/crates/circuit/src/circuit_data.rs b/crates/circuit/src/circuit_data.rs
index 4dd3956bee6a..5d3c5aba1877 100644
--- a/crates/circuit/src/circuit_data.rs
+++ b/crates/circuit/src/circuit_data.rs
@@ -16,7 +16,7 @@ use std::cell::OnceCell;
 use crate::bit_data::BitData;
 use crate::circuit_instruction::{CircuitInstruction, OperationFromPython};
 use crate::imports::{ANNOTATED_OPERATION, CLBIT, QUANTUM_CIRCUIT, QUBIT};
-use crate::interner::{IndexedInterner, Interner};
+use crate::interner::{Index, IndexedInterner, Interner};
 use crate::operations::{Operation, OperationRef, Param, StandardGate};
 use crate::packed_instruction::{PackedInstruction, PackedOperation};
 use crate::parameter_table::{ParameterTable, ParameterTableError, ParameterUse, ParameterUuid};
@@ -399,8 +399,8 @@ impl CircuitData {
     ///
     /// Returns:
     ///     list(:class:`.Qubit`): The current sequence of registered qubits.
-    #[getter]
-    pub fn qubits(&self, py: Python<'_>) -> Py<PyList> {
+    #[getter("qubits")]
+    pub fn py_qubits(&self, py: Python<'_>) -> Py<PyList> {
         self.qubits.cached().clone_ref(py)
     }
 
@@ -424,8 +424,8 @@ impl CircuitData {
     ///
     /// Returns:
     ///     list(:class:`.Clbit`): The current sequence of registered clbits.
-    #[getter]
-    pub fn clbits(&self, py: Python<'_>) -> Py<PyList> {
+    #[getter("clbits")]
+    pub fn py_clbits(&self, py: Python<'_>) -> Py<PyList> {
         self.clbits.cached().clone_ref(py)
     }
 
@@ -1137,6 +1137,41 @@ impl CircuitData {
         self.data.iter()
     }
 
+    /// Returns an immutable view of the Interner used for Qargs
+    pub fn qargs_interner(&self) -> &IndexedInterner<Vec<Qubit>> {
+        &self.qargs_interner
+    }
+
+    /// Returns an immutable view of the Interner used for Cargs
+    pub fn cargs_interner(&self) -> &IndexedInterner<Vec<Clbit>> {
+        &self.cargs_interner
+    }
+
+    /// Returns an immutable view of the Global Phase `Param` of the circuit
+    pub fn global_phase(&self) -> &Param {
+        &self.global_phase
+    }
+
+    /// Returns an immutable view of the Qubits registered in the circuit
+    pub fn qubits(&self) -> &BitData<Qubit> {
+        &self.qubits
+    }
+
+    /// Returns an immutable view of the Classical bits registered in the circuit
+    pub fn clbits(&self) -> &BitData<Clbit> {
+        &self.clbits
+    }
+
+    /// Unpacks from InternerIndex to `[Qubit]`
+    pub fn get_qargs(&self, index: Index) -> &[Qubit] {
+        self.qargs_interner().intern(index)
+    }
+
+    /// Unpacks from InternerIndex to `[Clbit]`
+    pub fn get_cargs(&self, index: Index) -> &[Clbit] {
+        self.cargs_interner().intern(index)
+    }
+
     fn assign_parameters_inner<I>(&mut self, py: Python, iter: I) -> PyResult<()>
     where
         I: IntoIterator<Item = (Py<PyAny>, Param, HashSet<ParameterUse>)>,

From 7b2d50cb9d89adc1f252102347090c511466a3d1 Mon Sep 17 00:00:00 2001
From: Jake Lishman <jake.lishman@ibm.com>
Date: Tue, 27 Aug 2024 14:08:33 +0100
Subject: [PATCH 26/85] Move interners from trait to generic structs (#13033)

* Move interners from trait to generic structs

This rewrites the interner mechanisms be defined in terms of two generic
structs (`Interner` and `Interned`) that formalise the idea that the
interned values are owned versions of a given reference type, and move
the logically separate intern-related actions (get a key from the value,
and get the value from the key) into separate functions (`get` and
`insert`, respectively).

This has a few advantages:

1. we now have both `insert` and `insert_owned` methods, which was
   awkward to add within the trait-based structure.  This allows a more
   efficient path when the owned variant has already necessarily been
   constructed.

2. additionally, the standard `insert` path now takes only a reference
   type.  For large circuits, most intern lookups will, in general, find
   a pre-existing key, so in situations where the interned value is
   sufficiently small that it can be within a static allocation (which
   is the case for almost all `qargs` and `cargs`), it's more efficient
   not to construct the owned type on the heap.

3. the type of the values retrieved from an interner are no longer
   indirected through the owned type that's stored.  For example,
   where `IndexedInterner<Vec<Qubit>>` gave out `&Vec<Qubit>`s as its
   lookups, `Interner<[Qubit]>` returns the more standard `&[Qubit]`,
   which is only singly indirect rather than double.

The following replacements are made:

1. The `IndexedInterner` struct from before is now just called
   `Interner` (and internally, it uses an `IndexSet` rather than
   manually tracking the indices).  Its generic type is related to the
   references it returns, rather than the owned value it stores, so
   `IndexedInterner<Vec<Qubit>>` becomes `Interner<[Qubit]>`.

2. The `Interner` trait is now gone.  Everything is just accessed as
   concrete methods on the `Interner` struct.

3. `<&IndexedInterner as Interner>::intern` (lookup of the value from an
   interner key) is now called `Interner::get`.

4. `<&mut IndexedInterner as Interner>::intern` (conversion of an owned
   value to an interner key) is now called `Interner::insert_owned`.

5. A new method, `Interner::insert`, can now be used when one need not
   have an owned allocation of the storage type; the correct value will
   be allocated if required (which is expected to be less frequent).

6. The intern key is no longer called `interner::Index`, but
   `Interned<T>`, where the generic parameter `T` matches the generic of
   the `Interner<T>` that gave out the key.

* Improve internal documentation

* Match names of interners between `CircuitData` and` DAGCircuit`
---
 crates/circuit/src/circuit_data.rs       |  70 +++++----
 crates/circuit/src/dag_circuit.rs        | 162 ++++++++++----------
 crates/circuit/src/interner.rs           | 181 ++++++++++++++++-------
 crates/circuit/src/packed_instruction.rs |   6 +-
 4 files changed, 242 insertions(+), 177 deletions(-)

diff --git a/crates/circuit/src/circuit_data.rs b/crates/circuit/src/circuit_data.rs
index 5d3c5aba1877..640eb22b9401 100644
--- a/crates/circuit/src/circuit_data.rs
+++ b/crates/circuit/src/circuit_data.rs
@@ -16,7 +16,7 @@ use std::cell::OnceCell;
 use crate::bit_data::BitData;
 use crate::circuit_instruction::{CircuitInstruction, OperationFromPython};
 use crate::imports::{ANNOTATED_OPERATION, CLBIT, QUANTUM_CIRCUIT, QUBIT};
-use crate::interner::{Index, IndexedInterner, Interner};
+use crate::interner::{Interned, Interner};
 use crate::operations::{Operation, OperationRef, Param, StandardGate};
 use crate::packed_instruction::{PackedInstruction, PackedOperation};
 use crate::parameter_table::{ParameterTable, ParameterTableError, ParameterUse, ParameterUuid};
@@ -91,9 +91,9 @@ pub struct CircuitData {
     /// The packed instruction listing.
     data: Vec<PackedInstruction>,
     /// The cache used to intern instruction bits.
-    qargs_interner: IndexedInterner<Vec<Qubit>>,
+    qargs_interner: Interner<[Qubit]>,
     /// The cache used to intern instruction bits.
-    cargs_interner: IndexedInterner<Vec<Clbit>>,
+    cargs_interner: Interner<[Clbit]>,
     /// Qubits registered in the circuit.
     qubits: BitData<Qubit>,
     /// Clbits registered in the circuit.
@@ -148,8 +148,8 @@ impl CircuitData {
             global_phase,
         )?;
         for (operation, params, qargs, cargs) in instruction_iter {
-            let qubits = (&mut res.qargs_interner).intern(qargs)?;
-            let clbits = (&mut res.cargs_interner).intern(cargs)?;
+            let qubits = res.qargs_interner.insert_owned(qargs);
+            let clbits = res.cargs_interner.insert_owned(cargs);
             let params = (!params.is_empty()).then(|| Box::new(params));
             res.data.push(PackedInstruction {
                 op: operation,
@@ -199,9 +199,9 @@ impl CircuitData {
             instruction_iter.size_hint().0,
             global_phase,
         )?;
-        let no_clbit_index = (&mut res.cargs_interner).intern(Vec::new())?;
+        let no_clbit_index = res.cargs_interner.insert(&[]);
         for (operation, params, qargs) in instruction_iter {
-            let qubits = (&mut res.qargs_interner).intern(qargs.to_vec())?;
+            let qubits = res.qargs_interner.insert(&qargs);
             let params = (!params.is_empty()).then(|| Box::new(params));
             res.data.push(PackedInstruction {
                 op: operation.into(),
@@ -227,8 +227,8 @@ impl CircuitData {
     ) -> PyResult<Self> {
         let mut res = CircuitData {
             data: Vec::with_capacity(instruction_capacity),
-            qargs_interner: IndexedInterner::new(),
-            cargs_interner: IndexedInterner::new(),
+            qargs_interner: Interner::new(),
+            cargs_interner: Interner::new(),
             qubits: BitData::new(py, "qubits".to_string()),
             clbits: BitData::new(py, "clbits".to_string()),
             param_table: ParameterTable::new(),
@@ -258,9 +258,9 @@ impl CircuitData {
         params: &[Param],
         qargs: &[Qubit],
     ) -> PyResult<()> {
-        let no_clbit_index = (&mut self.cargs_interner).intern(Vec::new())?;
+        let no_clbit_index = self.cargs_interner.insert(&[]);
         let params = (!params.is_empty()).then(|| Box::new(params.iter().cloned().collect()));
-        let qubits = (&mut self.qargs_interner).intern(qargs.to_vec())?;
+        let qubits = self.qargs_interner.insert(qargs);
         self.data.push(PackedInstruction {
             op: operation.into(),
             qubits,
@@ -351,8 +351,8 @@ impl CircuitData {
     ) -> PyResult<Self> {
         let mut self_ = CircuitData {
             data: Vec::new(),
-            qargs_interner: IndexedInterner::new(),
-            cargs_interner: IndexedInterner::new(),
+            qargs_interner: Interner::new(),
+            cargs_interner: Interner::new(),
             qubits: BitData::new(py, "qubits".to_string()),
             clbits: BitData::new(py, "clbits".to_string()),
             param_table: ParameterTable::new(),
@@ -572,10 +572,10 @@ impl CircuitData {
         let qubits = PySet::empty_bound(py)?;
         let clbits = PySet::empty_bound(py)?;
         for inst in self.data.iter() {
-            for b in self.qargs_interner.intern(inst.qubits) {
+            for b in self.qargs_interner.get(inst.qubits) {
                 qubits.add(self.qubits.get(*b).unwrap().clone_ref(py))?;
             }
-            for b in self.cargs_interner.intern(inst.clbits) {
+            for b in self.cargs_interner.get(inst.clbits) {
                 clbits.add(self.clbits.get(*b).unwrap().clone_ref(py))?;
             }
         }
@@ -737,8 +737,8 @@ impl CircuitData {
         // Get a single item, assuming the index is validated as in bounds.
         let get_single = |index: usize| {
             let inst = &self.data[index];
-            let qubits = self.qargs_interner.intern(inst.qubits);
-            let clbits = self.cargs_interner.intern(inst.clbits);
+            let qubits = self.qargs_interner.get(inst.qubits);
+            let clbits = self.cargs_interner.get(inst.clbits);
             CircuitInstruction {
                 operation: inst.op.clone(),
                 qubits: PyTuple::new_bound(py, self.qubits.map_indices(qubits)).unbind(),
@@ -894,7 +894,7 @@ impl CircuitData {
             for inst in other.data.iter() {
                 let qubits = other
                     .qargs_interner
-                    .intern(inst.qubits)
+                    .get(inst.qubits)
                     .iter()
                     .map(|b| {
                         Ok(self
@@ -905,7 +905,7 @@ impl CircuitData {
                     .collect::<PyResult<Vec<Qubit>>>()?;
                 let clbits = other
                     .cargs_interner
-                    .intern(inst.clbits)
+                    .get(inst.clbits)
                     .iter()
                     .map(|b| {
                         Ok(self
@@ -915,8 +915,8 @@ impl CircuitData {
                     })
                     .collect::<PyResult<Vec<Clbit>>>()?;
                 let new_index = self.data.len();
-                let qubits_id = Interner::intern(&mut self.qargs_interner, qubits)?;
-                let clbits_id = Interner::intern(&mut self.cargs_interner, clbits)?;
+                let qubits_id = self.qargs_interner.insert_owned(qubits);
+                let clbits_id = self.cargs_interner.insert_owned(clbits);
                 self.data.push(PackedInstruction {
                     op: inst.op.clone(),
                     qubits: qubits_id,
@@ -1113,14 +1113,12 @@ impl CircuitData {
     }
 
     fn pack(&mut self, py: Python, inst: &CircuitInstruction) -> PyResult<PackedInstruction> {
-        let qubits = Interner::intern(
-            &mut self.qargs_interner,
-            self.qubits.map_bits(inst.qubits.bind(py))?.collect(),
-        )?;
-        let clbits = Interner::intern(
-            &mut self.cargs_interner,
-            self.clbits.map_bits(inst.clbits.bind(py))?.collect(),
-        )?;
+        let qubits = self
+            .qargs_interner
+            .insert_owned(self.qubits.map_bits(inst.qubits.bind(py))?.collect());
+        let clbits = self
+            .cargs_interner
+            .insert_owned(self.clbits.map_bits(inst.clbits.bind(py))?.collect());
         Ok(PackedInstruction {
             op: inst.operation.clone(),
             qubits,
@@ -1138,12 +1136,12 @@ impl CircuitData {
     }
 
     /// Returns an immutable view of the Interner used for Qargs
-    pub fn qargs_interner(&self) -> &IndexedInterner<Vec<Qubit>> {
+    pub fn qargs_interner(&self) -> &Interner<[Qubit]> {
         &self.qargs_interner
     }
 
     /// Returns an immutable view of the Interner used for Cargs
-    pub fn cargs_interner(&self) -> &IndexedInterner<Vec<Clbit>> {
+    pub fn cargs_interner(&self) -> &Interner<[Clbit]> {
         &self.cargs_interner
     }
 
@@ -1162,14 +1160,14 @@ impl CircuitData {
         &self.clbits
     }
 
-    /// Unpacks from InternerIndex to `[Qubit]`
-    pub fn get_qargs(&self, index: Index) -> &[Qubit] {
-        self.qargs_interner().intern(index)
+    /// Unpacks from interned value to `[Qubit]`
+    pub fn get_qargs(&self, index: Interned<[Qubit]>) -> &[Qubit] {
+        self.qargs_interner().get(index)
     }
 
     /// Unpacks from InternerIndex to `[Clbit]`
-    pub fn get_cargs(&self, index: Index) -> &[Clbit] {
-        self.cargs_interner().intern(index)
+    pub fn get_cargs(&self, index: Interned<[Clbit]>) -> &[Clbit] {
+        self.cargs_interner().get(index)
     }
 
     fn assign_parameters_inner<I>(&mut self, py: Python, iter: I) -> PyResult<()>
diff --git a/crates/circuit/src/dag_circuit.rs b/crates/circuit/src/dag_circuit.rs
index bb5fff5e343a..4e1cf88092f8 100644
--- a/crates/circuit/src/dag_circuit.rs
+++ b/crates/circuit/src/dag_circuit.rs
@@ -22,7 +22,7 @@ use crate::dag_node::{DAGInNode, DAGNode, DAGOpNode, DAGOutNode};
 use crate::dot_utils::build_dot;
 use crate::error::DAGCircuitError;
 use crate::imports;
-use crate::interner::{IndexedInterner, Interner};
+use crate::interner::Interner;
 use crate::operations::{Operation, OperationRef, Param, PyInstruction};
 use crate::packed_instruction::PackedInstruction;
 use crate::rustworkx_core_vnext::isomorphism;
@@ -231,9 +231,9 @@ pub struct DAGCircuit {
     cregs: Py<PyDict>,
 
     /// The cache used to intern instruction qargs.
-    qargs_cache: IndexedInterner<Vec<Qubit>>,
+    qargs_interner: Interner<[Qubit]>,
     /// The cache used to intern instruction cargs.
-    cargs_cache: IndexedInterner<Vec<Clbit>>,
+    cargs_interner: Interner<[Clbit]>,
     /// Qubits registered in the circuit.
     pub qubits: BitData<Qubit>,
     /// Clbits registered in the circuit.
@@ -415,8 +415,8 @@ impl DAGCircuit {
             dag: StableDiGraph::default(),
             qregs: PyDict::new_bound(py).unbind(),
             cregs: PyDict::new_bound(py).unbind(),
-            qargs_cache: IndexedInterner::new(),
-            cargs_cache: IndexedInterner::new(),
+            qargs_interner: Interner::new(),
+            cargs_interner: Interner::new(),
             qubits: BitData::new(py, "qubits".to_string()),
             clbits: BitData::new(py, "clbits".to_string()),
             global_phase: Param::Float(0.),
@@ -1210,13 +1210,11 @@ def _format(operand):
         for node_weight in self.dag.node_weights_mut() {
             match node_weight {
                 NodeType::Operation(op) => {
-                    let cargs = self.cargs_cache.intern(op.clbits);
-                    let carg_bits = old_clbits
-                        .map_indices(&cargs[..])
-                        .map(|b| b.bind(py).clone());
-                    let mapped_cargs = self.clbits.map_bits(carg_bits)?.collect();
-                    let clbits = Interner::intern(&mut self.cargs_cache, mapped_cargs)?;
-                    op.clbits = clbits;
+                    let cargs = self.cargs_interner.get(op.clbits);
+                    let carg_bits = old_clbits.map_indices(cargs).map(|b| b.bind(py).clone());
+                    op.clbits = self
+                        .cargs_interner
+                        .insert_owned(self.clbits.map_bits(carg_bits)?.collect());
                 }
                 NodeType::ClbitIn(c) | NodeType::ClbitOut(c) => {
                     *c = self
@@ -1420,13 +1418,11 @@ def _format(operand):
         for node_weight in self.dag.node_weights_mut() {
             match node_weight {
                 NodeType::Operation(op) => {
-                    let qargs = self.qargs_cache.intern(op.qubits);
-                    let qarg_bits = old_qubits
-                        .map_indices(&qargs[..])
-                        .map(|b| b.bind(py).clone());
-                    let mapped_qargs = self.qubits.map_bits(qarg_bits)?.collect();
-                    let qubits = Interner::intern(&mut self.qargs_cache, mapped_qargs)?;
-                    op.qubits = qubits;
+                    let qargs = self.qargs_interner.get(op.qubits);
+                    let qarg_bits = old_qubits.map_indices(qargs).map(|b| b.bind(py).clone());
+                    op.qubits = self
+                        .qargs_interner
+                        .insert_owned(self.qubits.map_bits(qarg_bits)?.collect());
                 }
                 NodeType::QubitIn(q) | NodeType::QubitOut(q) => {
                     *q = self
@@ -1566,8 +1562,8 @@ def _format(operand):
         target_dag.duration = self.duration.as_ref().map(|d| d.clone_ref(py));
         target_dag.unit.clone_from(&self.unit);
         target_dag.metadata = self.metadata.as_ref().map(|m| m.clone_ref(py));
-        target_dag.qargs_cache = self.qargs_cache.clone();
-        target_dag.cargs_cache = self.cargs_cache.clone();
+        target_dag.qargs_interner = self.qargs_interner.clone();
+        target_dag.cargs_interner = self.cargs_interner.clone();
 
         for bit in self.qubits.bits() {
             target_dag.add_qubit_unchecked(py, bit.bind(py))?;
@@ -1677,14 +1673,12 @@ def _format(operand):
         let qargs = qargs.map(|q| q.value);
         let cargs = cargs.map(|c| c.value);
         let node = {
-            let qubits_id = Interner::intern(
-                &mut self.qargs_cache,
-                self.qubits.map_bits(qargs.iter().flatten())?.collect(),
-            )?;
-            let clbits_id = Interner::intern(
-                &mut self.cargs_cache,
-                self.clbits.map_bits(cargs.iter().flatten())?.collect(),
-            )?;
+            let qubits_id = self
+                .qargs_interner
+                .insert_owned(self.qubits.map_bits(qargs.iter().flatten())?.collect());
+            let clbits_id = self
+                .cargs_interner
+                .insert_owned(self.clbits.map_bits(cargs.iter().flatten())?.collect());
             let instr = PackedInstruction {
                 op: py_op.operation,
                 qubits: qubits_id,
@@ -1733,14 +1727,12 @@ def _format(operand):
         let qargs = qargs.map(|q| q.value);
         let cargs = cargs.map(|c| c.value);
         let node = {
-            let qubits_id = Interner::intern(
-                &mut self.qargs_cache,
-                self.qubits.map_bits(qargs.iter().flatten())?.collect(),
-            )?;
-            let clbits_id = Interner::intern(
-                &mut self.cargs_cache,
-                self.clbits.map_bits(cargs.iter().flatten())?.collect(),
-            )?;
+            let qubits_id = self
+                .qargs_interner
+                .insert_owned(self.qubits.map_bits(qargs.iter().flatten())?.collect());
+            let clbits_id = self
+                .cargs_interner
+                .insert_owned(self.clbits.map_bits(cargs.iter().flatten())?.collect());
             let instr = PackedInstruction {
                 op: py_op.operation,
                 qubits: qubits_id,
@@ -1993,7 +1985,7 @@ def _format(operand):
                     let m_qargs = {
                         let qubits = other
                             .qubits
-                            .map_indices(other.qargs_cache.intern(op.qubits).as_slice());
+                            .map_indices(other.qargs_interner.get(op.qubits));
                         let mut mapped = Vec::with_capacity(qubits.len());
                         for bit in qubits {
                             mapped.push(
@@ -2007,7 +1999,7 @@ def _format(operand):
                     let m_cargs = {
                         let clbits = other
                             .clbits
-                            .map_indices(other.cargs_cache.intern(op.clbits).as_slice());
+                            .map_indices(other.cargs_interner.get(op.clbits));
                         let mut mapped = Vec::with_capacity(clbits.len());
                         for bit in clbits {
                             mapped.push(
@@ -2471,10 +2463,10 @@ def _format(operand):
                         return Ok(false);
                     }
                     let check_args = || -> bool {
-                        let node1_qargs = self.qargs_cache.intern(inst1.qubits);
-                        let node2_qargs = other.qargs_cache.intern(inst2.qubits);
-                        let node1_cargs = self.cargs_cache.intern(inst1.clbits);
-                        let node2_cargs = other.cargs_cache.intern(inst2.clbits);
+                        let node1_qargs = self.qargs_interner.get(inst1.qubits);
+                        let node2_qargs = other.qargs_interner.get(inst2.qubits);
+                        let node1_cargs = self.cargs_interner.get(inst1.clbits);
+                        let node2_cargs = other.cargs_interner.get(inst2.clbits);
                         if SEMANTIC_EQ_SYMMETRIC.contains(&inst1.op.name()) {
                             let node1_qargs =
                                 node1_qargs.iter().copied().collect::<HashSet<Qubit>>();
@@ -2752,8 +2744,8 @@ def _format(operand):
             match weight {
                 Some(NodeType::Operation(packed)) => {
                     block_op_names.push(packed.op.name().to_string());
-                    block_qargs.extend(self.qargs_cache.intern(packed.qubits));
-                    block_cargs.extend(self.cargs_cache.intern(packed.clbits));
+                    block_qargs.extend(self.qargs_interner.get(packed.qubits));
+                    block_cargs.extend(self.cargs_interner.get(packed.clbits));
 
                     if let Some(condition) = packed.condition() {
                         block_cargs.extend(
@@ -2828,8 +2820,8 @@ def _format(operand):
         }
 
         let op_name = py_op.operation.name().to_string();
-        let qubits = Interner::intern(&mut self.qargs_cache, block_qargs)?;
-        let clbits = Interner::intern(&mut self.cargs_cache, block_cargs)?;
+        let qubits = self.qargs_interner.insert_owned(block_qargs);
+        let clbits = self.cargs_interner.insert_owned(block_cargs);
         let weight = NodeType::Operation(PackedInstruction {
             op: py_op.operation,
             qubits,
@@ -3182,7 +3174,7 @@ def _format(operand):
                                 "cannot propagate a condition to an element that already has one",
                             ));
                         }
-                        let cargs = input_dag.cargs_cache.intern(inst.clbits);
+                        let cargs = input_dag.cargs_interner.get(inst.clbits);
                         let cargs_bits: Vec<PyObject> = input_dag
                             .clbits
                             .map_indices(cargs)
@@ -3437,13 +3429,13 @@ def _format(operand):
             .map(|e| e.weight().clone())
             .collect();
         let mut new_wires: HashSet<Wire> = self
-            .qargs_cache
-            .intern(old_packed.qubits)
+            .qargs_interner
+            .get(old_packed.qubits)
             .iter()
             .map(|x| Wire::Qubit(*x))
             .chain(
-                self.cargs_cache
-                    .intern(old_packed.clbits)
+                self.cargs_interner
+                    .get(old_packed.clbits)
                     .iter()
                     .map(|x| Wire::Clbit(*x)),
             )
@@ -3966,7 +3958,7 @@ def _format(operand):
                     continue;
                 }
 
-                let qargs = self.qargs_cache.intern(packed.qubits);
+                let qargs = self.qargs_interner.get(packed.qubits);
                 if qargs.len() == 2 {
                     nodes.push(self.unpack_into(py, node, weight)?);
                 }
@@ -3984,7 +3976,7 @@ def _format(operand):
                     continue;
                 }
 
-                let qargs = self.qargs_cache.intern(packed.qubits);
+                let qargs = self.qargs_interner.get(packed.qubits);
                 if qargs.len() >= 3 {
                     nodes.push(self.unpack_into(py, node, weight)?);
                 }
@@ -4348,7 +4340,7 @@ def _format(operand):
                     py,
                     new_layer
                         .qubits
-                        .map_indices(new_layer.qargs_cache.intern(node.qubits)),
+                        .map_indices(new_layer.qargs_interner.get(node.qubits)),
                 )
             });
             let support_list = PyList::empty_bound(py);
@@ -4380,8 +4372,8 @@ def _format(operand):
             let support_list = PyList::empty_bound(py);
             let qubits = PyTuple::new_bound(
                 py,
-                self.qargs_cache
-                    .intern(retrieved_node.qubits)
+                self.qargs_interner
+                    .get(retrieved_node.qubits)
                     .iter()
                     .map(|qubit| self.qubits.get(*qubit)),
             )
@@ -4685,7 +4677,7 @@ def _format(operand):
                     if processed_non_directive_nodes.contains(&cur_index) {
                         continue;
                     }
-                    qubits_in_cone.extend(self.qargs_cache.intern(packed.qubits).iter());
+                    qubits_in_cone.extend(self.qargs_interner.get(packed.qubits));
                     processed_non_directive_nodes.insert(cur_index);
 
                     for pred_index in self.quantum_predecessors(cur_index) {
@@ -4704,8 +4696,8 @@ def _format(operand):
                             self.dag.node_weight(pred_index).unwrap()
                         {
                             if self
-                                .qargs_cache
-                                .intern(pred_packed.qubits)
+                                .qargs_interner
+                                .get(pred_packed.qubits)
                                 .iter()
                                 .any(|x| qubits_in_cone.contains(x))
                             {
@@ -5165,7 +5157,7 @@ impl DAGCircuit {
         let (all_cbits, vars): (Vec<Clbit>, Option<Vec<PyObject>>) = {
             if self.may_have_additional_wires(py, &instr) {
                 let mut clbits: HashSet<Clbit> =
-                    HashSet::from_iter(self.cargs_cache.intern(instr.clbits).iter().copied());
+                    HashSet::from_iter(self.cargs_interner.get(instr.clbits).iter().copied());
                 let (additional_clbits, additional_vars) =
                     self.additional_wires(py, instr.op.view(), instr.condition())?;
                 for clbit in additional_clbits {
@@ -5173,7 +5165,7 @@ impl DAGCircuit {
                 }
                 (clbits.into_iter().collect(), Some(additional_vars))
             } else {
-                (self.cargs_cache.intern(instr.clbits).to_vec(), None)
+                (self.cargs_interner.get(instr.clbits).to_vec(), None)
             }
         };
 
@@ -5185,8 +5177,8 @@ impl DAGCircuit {
         // Put the new node in-between the previously "last" nodes on each wire
         // and the output map.
         let output_nodes: HashSet<NodeIndex> = self
-            .qargs_cache
-            .intern(qubits_id)
+            .qargs_interner
+            .get(qubits_id)
             .iter()
             .map(|q| self.qubit_io_map.get(q.0 as usize).map(|x| x[1]).unwrap())
             .chain(
@@ -5231,7 +5223,7 @@ impl DAGCircuit {
         let (all_cbits, vars): (Vec<Clbit>, Option<Vec<PyObject>>) = {
             if self.may_have_additional_wires(py, &inst) {
                 let mut clbits: HashSet<Clbit> =
-                    HashSet::from_iter(self.cargs_cache.intern(inst.clbits).iter().cloned());
+                    HashSet::from_iter(self.cargs_interner.get(inst.clbits).iter().copied());
                 let (additional_clbits, additional_vars) =
                     self.additional_wires(py, inst.op.view(), inst.condition())?;
                 for clbit in additional_clbits {
@@ -5239,7 +5231,7 @@ impl DAGCircuit {
                 }
                 (clbits.into_iter().collect(), Some(additional_vars))
             } else {
-                (self.cargs_cache.intern(inst.clbits).to_vec(), None)
+                (self.cargs_interner.get(inst.clbits).to_vec(), None)
             }
         };
 
@@ -5251,8 +5243,8 @@ impl DAGCircuit {
         // Put the new node in-between the input map and the previously
         // "first" nodes on each wire.
         let mut input_nodes: Vec<NodeIndex> = self
-            .qargs_cache
-            .intern(qubits_id)
+            .qargs_interner
+            .get(qubits_id)
             .iter()
             .map(|q| self.qubit_io_map[q.0 as usize][0])
             .chain(all_cbits.iter().map(|c| self.clbit_io_map[c.0 as usize][0]))
@@ -5282,8 +5274,8 @@ impl DAGCircuit {
     fn sort_key(&self, node: NodeIndex) -> SortKeyType {
         match &self.dag[node] {
             NodeType::Operation(packed) => (
-                self.qargs_cache.intern(packed.qubits).as_slice(),
-                self.cargs_cache.intern(packed.clbits).as_slice(),
+                self.qargs_interner.get(packed.qubits),
+                self.cargs_interner.get(packed.clbits),
             ),
             NodeType::QubitIn(q) => (std::slice::from_ref(q), &[Clbit(u32::MAX)]),
             NodeType::QubitOut(_q) => (&[Qubit(u32::MAX)], &[Clbit(u32::MAX)]),
@@ -5687,18 +5679,16 @@ impl DAGCircuit {
             }
         } else if let Ok(op_node) = b.downcast::<DAGOpNode>() {
             let op_node = op_node.borrow();
-            let qubits = Interner::intern(
-                &mut self.qargs_cache,
+            let qubits = self.qargs_interner.insert_owned(
                 self.qubits
                     .map_bits(op_node.instruction.qubits.bind(py))?
                     .collect(),
-            )?;
-            let clbits = Interner::intern(
-                &mut self.cargs_cache,
+            );
+            let clbits = self.cargs_interner.insert_owned(
                 self.clbits
                     .map_bits(op_node.instruction.clbits.bind(py))?
                     .collect(),
-            )?;
+            );
             let params = (!op_node.instruction.params.is_empty())
                 .then(|| Box::new(op_node.instruction.params.clone()));
             let inst = PackedInstruction {
@@ -5739,8 +5729,8 @@ impl DAGCircuit {
             )?
             .into_any(),
             NodeType::Operation(packed) => {
-                let qubits = self.qargs_cache.intern(packed.qubits);
-                let clbits = self.cargs_cache.intern(packed.clbits);
+                let qubits = self.qargs_interner.get(packed.qubits);
+                let clbits = self.cargs_interner.get(packed.clbits);
                 Py::new(
                     py,
                     (
@@ -5954,19 +5944,19 @@ impl DAGCircuit {
             let mut new_node = other.dag[old_index].clone();
             if let NodeType::Operation(ref mut new_inst) = new_node {
                 let new_qubit_indices: Vec<Qubit> = other
-                    .qargs_cache
-                    .intern(new_inst.qubits)
+                    .qargs_interner
+                    .get(new_inst.qubits)
                     .iter()
                     .map(|old_qubit| qubit_map[old_qubit])
                     .collect();
                 let new_clbit_indices: Vec<Clbit> = other
-                    .cargs_cache
-                    .intern(new_inst.clbits)
+                    .cargs_interner
+                    .get(new_inst.clbits)
                     .iter()
                     .map(|old_clbit| clbit_map[old_clbit])
                     .collect();
-                new_inst.qubits = Interner::intern(&mut self.qargs_cache, new_qubit_indices)?;
-                new_inst.clbits = Interner::intern(&mut self.cargs_cache, new_clbit_indices)?;
+                new_inst.qubits = self.qargs_interner.insert_owned(new_qubit_indices);
+                new_inst.clbits = self.cargs_interner.insert_owned(new_clbit_indices);
                 self.increment_op(new_inst.op.name());
             }
             let new_index = self.dag.add_node(new_node);
@@ -6128,7 +6118,7 @@ impl DAGCircuit {
             self._check_condition(py, inst.op.name(), condition.bind(py))?;
         }
 
-        for b in self.qargs_cache.intern(inst.qubits) {
+        for b in self.qargs_interner.get(inst.qubits) {
             if self.qubit_io_map.len() - 1 < b.0 as usize {
                 return Err(DAGCircuitError::new_err(format!(
                     "qubit {} not found in output map",
@@ -6137,7 +6127,7 @@ impl DAGCircuit {
             }
         }
 
-        for b in self.cargs_cache.intern(inst.clbits) {
+        for b in self.cargs_interner.get(inst.clbits) {
             if !self.clbit_io_map.len() - 1 < b.0 as usize {
                 return Err(DAGCircuitError::new_err(format!(
                     "clbit {} not found in output map",
diff --git a/crates/circuit/src/interner.rs b/crates/circuit/src/interner.rs
index e19f56e87a7d..007256422e25 100644
--- a/crates/circuit/src/interner.rs
+++ b/crates/circuit/src/interner.rs
@@ -10,79 +10,154 @@
 // copyright notice, and modified files need to carry a notice indicating
 // that they have been altered from the originals.
 
+use std::borrow::Borrow;
+use std::fmt;
 use std::hash::Hash;
-use std::sync::Arc;
+use std::marker::PhantomData;
 
-use hashbrown::HashMap;
-use pyo3::exceptions::PyRuntimeError;
-use pyo3::prelude::*;
+use indexmap::IndexSet;
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub struct Index(u32);
-
-impl IntoPy<PyObject> for Index {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.0.into_py(py)
-    }
+/// A key to retrieve a value (by reference) from an interner of the same type.  This is narrower
+/// than a true reference, at the cost that it is explicitly not lifetime bound to the interner it
+/// came from; it is up to the user to ensure that they never attempt to query an interner with a
+/// key from a different interner.
+#[derive(Debug, Eq, PartialEq)]
+pub struct Interned<T: ?Sized> {
+    index: u32,
+    // Storing the type of the interned value adds a small amount more type safety to the interner
+    // keys when there's several interners in play close to each other.  We use `*const T` because
+    // the `Interned value` is like a non-lifetime-bound reference to data stored in the interner;
+    // `Interned` doesn't own the data (which would be implied by `T`), and it's not using the
+    // static lifetime system (which would be implied by `&'_ T`, and require us to propagate the
+    // lifetime bound).
+    _type: PhantomData<*const T>,
 }
-
-/// An append-only data structure for interning generic
-/// Rust types.
-#[derive(Clone, Debug)]
-pub struct IndexedInterner<T> {
-    entries: Vec<Arc<T>>,
-    index_lookup: HashMap<Arc<T>, Index>,
+// The `PhantomData` marker prevents various useful things from being derived (for `Clone` and
+// `Copy` it's an awkward effect of the derivation system), so we have manual implementations.
+impl<T: ?Sized> Clone for Interned<T> {
+    fn clone(&self) -> Self {
+        *self
+    }
 }
+impl<T: ?Sized> Copy for Interned<T> {}
+unsafe impl<T: ?Sized> Send for Interned<T> {}
+unsafe impl<T: ?Sized> Sync for Interned<T> {}
 
-pub trait Interner<K> {
-    type Output;
+/// An append-only data structure for interning generic Rust types.
+///
+/// The interner can lookup keys using a reference type, and will create the corresponding owned
+/// allocation on demand, if a matching entry is not already stored.  It returns manual keys into
+/// itself (the `Interned` type), rather than raw references; the `Interned` type is narrower than a
+/// true reference.
+///
+/// # Examples
+///
+/// ```rust
+/// let mut interner = Interner::<[usize]>::new();
+///
+/// // These are of type `Interned<[usize]>`.
+/// let empty = interner.insert(&[]);
+/// let other_empty = interner.insert(&[]);
+/// let key = interner.insert(&[0, 1, 2, 3, 4]);
+///
+/// assert_eq!(empty, other_empty);
+/// assert_ne!(empty, key);
+///
+/// assert_eq!(interner.get(empty), &[]);
+/// assert_eq!(interner.get(key), &[0, 1, 2, 3, 4]);
+/// ```
+#[derive(Default)]
+pub struct Interner<T: ?Sized + ToOwned>(IndexSet<<T as ToOwned>::Owned, ::ahash::RandomState>);
 
-    /// Takes ownership of the provided key and returns the interned
-    /// type.
-    fn intern(self, value: K) -> Self::Output;
+// `Clone` and `Debug` can't use the derivation mechanism because the values that are actually
+// stored are of type `<T as ToOwned>::Owned`, which the derive system doesn't reason about.
+impl<T> Clone for Interner<T>
+where
+    T: ?Sized + ToOwned,
+    <T as ToOwned>::Owned: Clone,
+{
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+impl<T> fmt::Debug for Interner<T>
+where
+    T: ?Sized + ToOwned,
+    <T as ToOwned>::Owned: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        f.debug_tuple("Interner").field(&self.0).finish()
+    }
 }
 
-impl<'a, T> Interner<Index> for &'a IndexedInterner<T> {
-    type Output = &'a T;
-
-    fn intern(self, index: Index) -> Self::Output {
-        let value = self.entries.get(index.0 as usize).unwrap();
-        value.as_ref()
+impl<T> Interner<T>
+where
+    T: ?Sized + ToOwned,
+{
+    pub fn new() -> Self {
+        Self(Default::default())
     }
 }
 
-impl<'a, T> Interner<T> for &'a mut IndexedInterner<T>
+impl<T> Interner<T>
 where
-    T: Eq + Hash,
+    T: ?Sized + ToOwned,
+    <T as ToOwned>::Owned: Hash + Eq,
 {
-    type Output = PyResult<Index>;
+    /// Retrieve a reference to the stored value for this key.
+    pub fn get(&self, index: Interned<T>) -> &T {
+        self.0
+            .get_index(index.index as usize)
+            .expect(
+                "the caller is responsible for only using interner keys from the correct interner",
+            )
+            .borrow()
+    }
 
-    fn intern(self, key: T) -> Self::Output {
-        if let Some(index) = self.index_lookup.get(&key).copied() {
-            Ok(index)
-        } else {
-            let args = Arc::new(key);
-            let index: Index = Index(self.entries.len().try_into().map_err(|_| {
-                PyRuntimeError::new_err("The interner has run out of indices (cache is full)!")
-            })?);
-            self.entries.push(args.clone());
-            self.index_lookup.insert_unique_unchecked(args, index);
-            Ok(index)
+    /// Internal worker function that inserts an owned value assuming that the value didn't
+    /// previously exist in the map.
+    fn insert_new(&mut self, value: <T as ToOwned>::Owned) -> u32 {
+        let index = self.0.len();
+        if index == u32::MAX as usize {
+            panic!("interner is out of space");
         }
+        let _inserted = self.0.insert(value);
+        debug_assert!(_inserted);
+        index as u32
     }
-}
 
-impl<T: Eq + Hash> IndexedInterner<T> {
-    pub fn new() -> Self {
-        IndexedInterner {
-            entries: Vec::new(),
-            index_lookup: HashMap::new(),
+    /// Get an interner key corresponding to the given referenced type.  If not already stored, this
+    /// function will allocate a new owned value to use as the storage.
+    ///
+    /// If you already have an owned value, use `insert_owned`, but in general this function will be
+    /// more efficient *unless* you already had the value for other reasons.
+    pub fn insert(&mut self, value: &T) -> Interned<T>
+    where
+        T: Hash + Eq,
+    {
+        let index = match self.0.get_index_of(value) {
+            Some(index) => index as u32,
+            None => self.insert_new(value.to_owned()),
+        };
+        Interned {
+            index,
+            _type: PhantomData,
         }
     }
-}
 
-impl<T: Eq + Hash> Default for IndexedInterner<T> {
-    fn default() -> Self {
-        Self::new()
+    /// Get an interner key corresponding to the given owned type.  If not already stored, the value
+    /// will be used as the key, otherwise it will be dropped.
+    ///
+    /// If you don't already have the owned value, use `insert`; this will only allocate if the
+    /// lookup fails.
+    pub fn insert_owned(&mut self, value: <T as ToOwned>::Owned) -> Interned<T> {
+        let index = match self.0.get_index_of(&value) {
+            Some(index) => index as u32,
+            None => self.insert_new(value),
+        };
+        Interned {
+            index,
+            _type: PhantomData,
+        }
     }
 }
diff --git a/crates/circuit/src/packed_instruction.rs b/crates/circuit/src/packed_instruction.rs
index 7619ecb9c525..77ca0c6c02dd 100644
--- a/crates/circuit/src/packed_instruction.rs
+++ b/crates/circuit/src/packed_instruction.rs
@@ -25,9 +25,11 @@ use smallvec::SmallVec;
 use crate::circuit_data::CircuitData;
 use crate::circuit_instruction::ExtraInstructionAttributes;
 use crate::imports::{get_std_gate_class, DEEPCOPY};
+use crate::interner::Interned;
 use crate::operations::{
     Operation, OperationRef, Param, PyGate, PyInstruction, PyOperation, StandardGate,
 };
+use crate::{Clbit, Qubit};
 
 /// The logical discriminant of `PackedOperation`.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -491,9 +493,9 @@ impl Drop for PackedOperation {
 pub struct PackedInstruction {
     pub op: PackedOperation,
     /// The index under which the interner has stored `qubits`.
-    pub qubits: crate::interner::Index,
+    pub qubits: Interned<[Qubit]>,
     /// The index under which the interner has stored `clbits`.
-    pub clbits: crate::interner::Index,
+    pub clbits: Interned<[Clbit]>,
     pub params: Option<Box<SmallVec<[Param; 3]>>>,
     pub extra_attrs: Option<Box<ExtraInstructionAttributes>>,
 

From 37784c763c205fd8ca885c53d86e9beac7a6d3fe Mon Sep 17 00:00:00 2001
From: Kevin Hartman <kevin@hart.mn>
Date: Wed, 28 Aug 2024 08:51:04 -0400
Subject: [PATCH 27/85] Fully port `Depth` and `Size` passes to Rust (#13040)

* Avoid isinstance check on every node in DAG during
recursive depth and size calls.

* Avoid unnecessary downcast.

* Check if there is control flow before doing loops.

* Avoid py_op_nodes in DAGCircuit::count_ops.
---
 crates/circuit/src/dag_circuit.rs | 193 +++++++++++++++---------------
 1 file changed, 95 insertions(+), 98 deletions(-)

diff --git a/crates/circuit/src/dag_circuit.rs b/crates/circuit/src/dag_circuit.rs
index 4e1cf88092f8..b6e33e78c1b2 100644
--- a/crates/circuit/src/dag_circuit.rs
+++ b/crates/circuit/src/dag_circuit.rs
@@ -2145,53 +2145,46 @@ def _format(operand):
     #[pyo3(signature= (*, recurse=false))]
     fn size(&self, py: Python, recurse: bool) -> PyResult<usize> {
         let mut length = self.dag.node_count() - (self.width() * 2);
-        if !recurse {
-            if CONTROL_FLOW_OP_NAMES
-                .iter()
-                .any(|n| self.op_names.contains_key(&n.to_string()))
-            {
-                return Err(DAGCircuitError::new_err(concat!(
-                    "Size with control flow is ambiguous.",
-                    " You may use `recurse=True` to get a result",
-                    " but see this method's documentation for the meaning of this."
-                )));
-            }
+        if !self.has_control_flow() {
             return Ok(length);
         }
+        if !recurse {
+            return Err(DAGCircuitError::new_err(concat!(
+                "Size with control flow is ambiguous.",
+                " You may use `recurse=True` to get a result",
+                " but see this method's documentation for the meaning of this."
+            )));
+        }
 
+        // Handle recursively.
         let circuit_to_dag = imports::CIRCUIT_TO_DAG.get_bound(py);
-        for node_index in
-            self.op_nodes_by_py_type(imports::CONTROL_FLOW_OP.get_bound(py).downcast()?, true)
-        {
-            let NodeType::Operation(node) = &self.dag[node_index] else {
-                return Err(DAGCircuitError::new_err("unknown control-flow type"));
+        for node in self.dag.node_weights() {
+            let NodeType::Operation(node) = node else {
+                continue;
             };
+            if !node.op.control_flow() {
+                continue;
+            }
             let OperationRef::Instruction(inst) = node.op.view() else {
-                unreachable!("Control Flow operations must be a PyInstruction");
+                panic!("control flow op must be an instruction");
             };
             let inst_bound = inst.instruction.bind(py);
             if inst_bound.is_instance(imports::FOR_LOOP_OP.get_bound(py))? {
-                let raw_blocks = inst_bound.getattr("blocks")?;
-                let blocks: &Bound<PySequence> = raw_blocks.downcast()?;
-                let block_zero = blocks.get_item(0).unwrap();
-                let inner_dag: &DAGCircuit =
-                    &circuit_to_dag.call1((block_zero.clone(),))?.extract()?;
+                let blocks = inst_bound.getattr("blocks")?;
+                let block_zero = blocks.get_item(0)?;
+                let inner_dag: &DAGCircuit = &circuit_to_dag.call1((block_zero,))?.extract()?;
                 length += node.params_view().len() * inner_dag.size(py, true)?
             } else if inst_bound.is_instance(imports::WHILE_LOOP_OP.get_bound(py))? {
-                let raw_blocks = inst_bound.getattr("blocks")?;
-                let blocks: &Bound<PySequence> = raw_blocks.downcast()?;
-                let block_zero = blocks.get_item(0).unwrap();
-                let inner_dag: &DAGCircuit =
-                    &circuit_to_dag.call1((block_zero.clone(),))?.extract()?;
+                let blocks = inst_bound.getattr("blocks")?;
+                let block_zero = blocks.get_item(0)?;
+                let inner_dag: &DAGCircuit = &circuit_to_dag.call1((block_zero,))?.extract()?;
                 length += inner_dag.size(py, true)?
             } else if inst_bound.is_instance(imports::IF_ELSE_OP.get_bound(py))?
                 || inst_bound.is_instance(imports::SWITCH_CASE_OP.get_bound(py))?
             {
-                let raw_blocks = inst_bound.getattr("blocks")?;
-                let blocks: &Bound<PyTuple> = raw_blocks.downcast()?;
-                for block in blocks.iter() {
-                    let inner_dag: &DAGCircuit =
-                        &circuit_to_dag.call1((block.clone(),))?.extract()?;
+                let blocks = inst_bound.getattr("blocks")?;
+                for block in blocks.iter()? {
+                    let inner_dag: &DAGCircuit = &circuit_to_dag.call1((block?,))?.extract()?;
                     length += inner_dag.size(py, true)?;
                 }
             } else {
@@ -2227,62 +2220,60 @@ def _format(operand):
         if self.qubits.is_empty() && self.clbits.is_empty() && self.vars_info.is_empty() {
             return Ok(0);
         }
+        if !self.has_control_flow() {
+            let weight_fn = |_| -> Result<usize, Infallible> { Ok(1) };
+            return match rustworkx_core::dag_algo::longest_path(&self.dag, weight_fn).unwrap() {
+                Some(res) => Ok(res.1 - 1),
+                None => Err(DAGCircuitError::new_err("not a DAG")),
+            };
+        }
+        if !recurse {
+            return Err(DAGCircuitError::new_err(concat!(
+                "Depth with control flow is ambiguous.",
+                " You may use `recurse=True` to get a result",
+                " but see this method's documentation for the meaning of this."
+            )));
+        }
 
-        Ok(if recurse {
-            let circuit_to_dag = imports::CIRCUIT_TO_DAG.get_bound(py);
-            let mut node_lookup: HashMap<NodeIndex, usize> = HashMap::new();
-
-            for node_index in
-                self.op_nodes_by_py_type(imports::CONTROL_FLOW_OP.get_bound(py).downcast()?, true)
-            {
-                if let NodeType::Operation(node) = &self.dag[node_index] {
-                    if let OperationRef::Instruction(inst) = node.op.view() {
-                        let inst_bound = inst.instruction.bind(py);
-                        let weight =
-                            if inst_bound.is_instance(imports::FOR_LOOP_OP.get_bound(py))? {
-                                node.params_view().len()
-                            } else {
-                                1
-                            };
-                        if weight == 0 {
-                            node_lookup.insert(node_index, 0);
-                        } else {
-                            let raw_blocks = inst_bound.getattr("blocks")?;
-                            let blocks = raw_blocks.downcast::<PyTuple>()?;
-                            let mut block_weights: Vec<usize> = Vec::with_capacity(blocks.len());
-                            for block in blocks.iter() {
-                                let inner_dag: &DAGCircuit =
-                                    &circuit_to_dag.call1((block,))?.extract()?;
-                                block_weights.push(inner_dag.depth(py, true)?);
-                            }
-                            node_lookup
-                                .insert(node_index, weight * block_weights.iter().max().unwrap());
-                        }
-                    }
-                }
-            }
-
-            let weight_fn = |edge: EdgeReference<'_, Wire>| -> Result<usize, Infallible> {
-                Ok(*node_lookup.get(&edge.target()).unwrap_or(&1))
+        // Handle recursively.
+        let circuit_to_dag = imports::CIRCUIT_TO_DAG.get_bound(py);
+        let mut node_lookup: HashMap<NodeIndex, usize> = HashMap::new();
+        for (node_index, node) in self.dag.node_references() {
+            let NodeType::Operation(node) = node else {
+                continue;
             };
-            match rustworkx_core::dag_algo::longest_path(&self.dag, weight_fn).unwrap() {
-                Some(res) => res.1,
-                None => return Err(DAGCircuitError::new_err("not a DAG")),
+            if !node.op.control_flow() {
+                continue;
             }
-        } else {
-            if CONTROL_FLOW_OP_NAMES
-                .iter()
-                .any(|x| self.op_names.contains_key(&x.to_string()))
-            {
-                return Err(DAGCircuitError::new_err("Depth with control flow is ambiguous. You may use `recurse=True` to get a result, but see this method's documentation for the meaning of this."));
+            let OperationRef::Instruction(inst) = node.op.view() else {
+                panic!("control flow op must be an instruction")
+            };
+            let inst_bound = inst.instruction.bind(py);
+            let weight = if inst_bound.is_instance(imports::FOR_LOOP_OP.get_bound(py))? {
+                node.params_view().len()
+            } else {
+                1
+            };
+            if weight == 0 {
+                node_lookup.insert(node_index, 0);
+            } else {
+                let blocks = inst_bound.getattr("blocks")?;
+                let mut block_weights: Vec<usize> = Vec::with_capacity(blocks.len()?);
+                for block in blocks.iter()? {
+                    let inner_dag: &DAGCircuit = &circuit_to_dag.call1((block?,))?.extract()?;
+                    block_weights.push(inner_dag.depth(py, true)?);
+                }
+                node_lookup.insert(node_index, weight * block_weights.iter().max().unwrap());
             }
+        }
 
-            let weight_fn = |_| -> Result<usize, Infallible> { Ok(1) };
-            match rustworkx_core::dag_algo::longest_path(&self.dag, weight_fn).unwrap() {
-                Some(res) => res.1,
-                None => return Err(DAGCircuitError::new_err("not a DAG")),
-            }
-        } - 1)
+        let weight_fn = |edge: EdgeReference<'_, Wire>| -> Result<usize, Infallible> {
+            Ok(*node_lookup.get(&edge.target()).unwrap_or(&1))
+        };
+        match rustworkx_core::dag_algo::longest_path(&self.dag, weight_fn).unwrap() {
+            Some(res) => Ok(res.1 - 1),
+            None => Err(DAGCircuitError::new_err("not a DAG")),
+        }
     }
 
     /// Return the total number of qubits + clbits used by the circuit.
@@ -4554,11 +4545,7 @@ def _format(operand):
     ///     Mapping[str, int]: a mapping of operation names to the number of times it appears.
     #[pyo3(signature = (*, recurse=true))]
     fn count_ops(&self, py: Python, recurse: bool) -> PyResult<PyObject> {
-        if !recurse
-            || !CONTROL_FLOW_OP_NAMES
-                .iter()
-                .any(|x| self.op_names.contains_key(*x))
-        {
+        if !recurse || !self.has_control_flow() {
             Ok(self.op_names.to_object(py))
         } else {
             fn inner(
@@ -4573,16 +4560,19 @@ def _format(operand):
                         .or_insert(*value);
                 }
                 let circuit_to_dag = imports::CIRCUIT_TO_DAG.get_bound(py);
-                for node in dag.py_op_nodes(
-                    py,
-                    Some(imports::CONTROL_FLOW_OP.get_bound(py).downcast()?),
-                    true,
-                )? {
-                    let raw_blocks = node.getattr(py, "op")?.getattr(py, "blocks")?;
-                    let blocks: &Bound<PyTuple> = raw_blocks.downcast_bound::<PyTuple>(py)?;
-                    for block in blocks.iter() {
-                        let inner_dag: &DAGCircuit =
-                            &circuit_to_dag.call1((block.clone(),))?.extract()?;
+                for node in dag.dag.node_weights() {
+                    let NodeType::Operation(node) = node else {
+                        continue;
+                    };
+                    if !node.op.control_flow() {
+                        continue;
+                    }
+                    let OperationRef::Instruction(inst) = node.op.view() else {
+                        panic!("control flow op must be an instruction")
+                    };
+                    let blocks = inst.instruction.bind(py).getattr("blocks")?;
+                    for block in blocks.iter()? {
+                        let inner_dag: &DAGCircuit = &circuit_to_dag.call1((block?,))?.extract()?;
                         inner(py, inner_dag, counts)?;
                     }
                 }
@@ -5332,6 +5322,13 @@ impl DAGCircuit {
         )
     }
 
+    #[inline]
+    fn has_control_flow(&self) -> bool {
+        CONTROL_FLOW_OP_NAMES
+            .iter()
+            .any(|x| self.op_names.contains_key(&x.to_string()))
+    }
+
     fn is_wire_idle(&self, py: Python, wire: &Wire) -> PyResult<bool> {
         let (input_node, output_node) = match wire {
             Wire::Qubit(qubit) => (

From cc2edc9f7172d75ec454fdaf5748326cd3720f90 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 28 Aug 2024 08:51:13 -0400
Subject: [PATCH 28/85] Bump bytemuck from 1.17.0 to 1.17.1 (#13049)

Bumps [bytemuck](https://github.com/Lokathor/bytemuck) from 1.17.0 to 1.17.1.
- [Changelog](https://github.com/Lokathor/bytemuck/blob/main/changelog.md)
- [Commits](https://github.com/Lokathor/bytemuck/compare/v1.17.0...v1.17.1)

---
updated-dependencies:
- dependency-name: bytemuck
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 394e03f5d122..136ca4bed376 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -102,9 +102,9 @@ dependencies = [
 
 [[package]]
 name = "bytemuck"
-version = "1.17.0"
+version = "1.17.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fd4c6dcc3b0aea2f5c0b4b82c2b15fe39ddbc76041a310848f4706edf76bb31"
+checksum = "773d90827bc3feecfb67fab12e24de0749aad83c74b9504ecde46237b5cd24e2"
 dependencies = [
  "bytemuck_derive",
 ]

From f37bd68005a88f82715e7b65326e941ff021406e Mon Sep 17 00:00:00 2001
From: Jake Lishman <jake.lishman@ibm.com>
Date: Fri, 30 Aug 2024 00:44:18 +0100
Subject: [PATCH 29/85] Promote `CONTROL_FLOW_OP_NAMES` to public API (#13057)

This is generally useful for Qiskit's built-in transpiler passes, and
we've had some interest in using it for the same reasons from outside
the library.  While the control-flow structure from within Rust might
change in the future, in the immediate term and from Python space, it
feels fair to expose this as public API, since all the information
contained in it is certainly already public.
---
 qiskit/circuit/__init__.py                                | 8 ++++++++
 qiskit/circuit/controlflow/__init__.py                    | 1 +
 .../notes/control-flow-op-names-c66f38f8a0e15ce7.yaml     | 5 +++++
 3 files changed, 14 insertions(+)
 create mode 100644 releasenotes/notes/control-flow-op-names-c66f38f8a0e15ce7.yaml

diff --git a/qiskit/circuit/__init__.py b/qiskit/circuit/__init__.py
index 1ab084ef2072..ebaef39c2a43 100644
--- a/qiskit/circuit/__init__.py
+++ b/qiskit/circuit/__init__.py
@@ -686,6 +686,13 @@
 
     ControlFlowOp
 
+For convenience, there is a :class:`frozenset` instance containing the :attr:`.Instruction.name`
+attributes of each of the control-flow operations.
+
+.. data:: CONTROL_FLOW_OP_NAMES
+
+    Set of the instruction names of Qiskit's known control-flow operations.
+
 These control-flow operations (:class:`IfElseOp`, :class:`WhileLoopOp`,
 :class:`SwitchCaseOp` and :class:`ForLoopOp`) all have specific state that defines the branching
 conditions and strategies, but contain all the different subcircuit blocks that might be entered in
@@ -1257,6 +1264,7 @@ def __array__(self, dtype=None, copy=None):
     CASE_DEFAULT,
     BreakLoopOp,
     ContinueLoopOp,
+    CONTROL_FLOW_OP_NAMES,
 )
 
 from .annotated_operation import AnnotatedOperation, InverseModifier, ControlModifier, PowerModifier
diff --git a/qiskit/circuit/controlflow/__init__.py b/qiskit/circuit/controlflow/__init__.py
index 12831ccaaaed..2679b45d7782 100644
--- a/qiskit/circuit/controlflow/__init__.py
+++ b/qiskit/circuit/controlflow/__init__.py
@@ -25,3 +25,4 @@
 
 
 CONTROL_FLOW_OP_NAMES = frozenset(("for_loop", "while_loop", "if_else", "switch_case"))
+"""Set of the instruction names of Qiskit's known control-flow operations."""
diff --git a/releasenotes/notes/control-flow-op-names-c66f38f8a0e15ce7.yaml b/releasenotes/notes/control-flow-op-names-c66f38f8a0e15ce7.yaml
new file mode 100644
index 000000000000..94a3b11b935b
--- /dev/null
+++ b/releasenotes/notes/control-flow-op-names-c66f38f8a0e15ce7.yaml
@@ -0,0 +1,5 @@
+---
+features_circuits:
+  - |
+    A new data attribute, :data:`qiskit.circuit.CONTROL_FLOW_OP_NAMES`, is available to easily find
+    and check whether a given :class:`~.circuit.Instruction` is a control-flow operation by name.

From edb249ec1a8c783feed61199f64fb7a5af16234c Mon Sep 17 00:00:00 2001
From: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>
Date: Fri, 30 Aug 2024 09:46:05 -0400
Subject: [PATCH 30/85] Add rust friendly `assign parameters` methods (#12913)

* Initial: Add `assign_parameter` methods that can be used from Rust.

* Add: Error message in `from_slice` method.
- Accept owned mapping for `from_mapping`.

* Fix: Use `assign_parameters_from_slice` as inner method for `assign_parameters_sequence`

* Fix: Use `ParameterUuid` as keys for `assign_parameter_from_mapping`

* Fix: Accept Param references in `assign_parameters_inner`

* Fix: Ownership issues
- Remove initial allocation of `Param` instances within a vec in `assign_parameters_iterable`.
- Revert changes in `assign_parameters_mapping`.
- Fix error message in `assign_parameter_from_slice`.
- Return an error if a `uuid` is not found in `assign_parameters from mapping. Also, return error if a valid uuid is not found to avoid panicking.
- Add `clone_ref(py)` method to `Param` to ensure that we use the most efficient cloning methods (either `clone_ref` with gil or copying).
- Implement trait `AsRef<Param>` for `Param` to be able to send both owned and non-owned instances to `assign_parameters_inner`.

* Docs: Add comment on `AsRef<Param>` impl block.
---
 crates/circuit/src/circuit_data.rs | 103 ++++++++++++++++++++---------
 crates/circuit/src/operations.rs   |  18 +++++
 2 files changed, 88 insertions(+), 33 deletions(-)

diff --git a/crates/circuit/src/circuit_data.rs b/crates/circuit/src/circuit_data.rs
index 640eb22b9401..72eaa34d4142 100644
--- a/crates/circuit/src/circuit_data.rs
+++ b/crates/circuit/src/circuit_data.rs
@@ -953,28 +953,16 @@ impl CircuitData {
                 sequence.py(),
                 array
                     .iter()
+                    .map(|value| Param::Float(*value))
                     .zip(old_table.drain_ordered())
-                    .map(|(value, (param_ob, uses))| (param_ob, Param::Float(*value), uses)),
+                    .map(|(value, (obj, uses))| (obj, value, uses)),
             )
         } else {
             let values = sequence
                 .iter()?
                 .map(|ob| Param::extract_no_coerce(&ob?))
                 .collect::<PyResult<Vec<_>>>()?;
-            if values.len() != self.param_table.num_parameters() {
-                return Err(PyValueError::new_err(concat!(
-                    "Mismatching number of values and parameters. For partial binding ",
-                    "please pass a dictionary of {parameter: value} pairs."
-                )));
-            }
-            let mut old_table = std::mem::take(&mut self.param_table);
-            self.assign_parameters_inner(
-                sequence.py(),
-                values
-                    .into_iter()
-                    .zip(old_table.drain_ordered())
-                    .map(|(value, (param_ob, uses))| (param_ob, value, uses)),
-            )
+            self.assign_parameters_from_slice(sequence.py(), &values)
         }
     }
 
@@ -1135,6 +1123,50 @@ impl CircuitData {
         self.data.iter()
     }
 
+    /// Assigns parameters to circuit data based on a slice of `Param`.
+    pub fn assign_parameters_from_slice(&mut self, py: Python, slice: &[Param]) -> PyResult<()> {
+        if slice.len() != self.param_table.num_parameters() {
+            return Err(PyValueError::new_err(concat!(
+                "Mismatching number of values and parameters. For partial binding ",
+                "please pass a mapping of {parameter: value} pairs."
+            )));
+        }
+        let mut old_table = std::mem::take(&mut self.param_table);
+        self.assign_parameters_inner(
+            py,
+            slice
+                .iter()
+                .zip(old_table.drain_ordered())
+                .map(|(value, (param_ob, uses))| (param_ob, value.clone_ref(py), uses)),
+        )
+    }
+
+    /// Assigns parameters to circuit data based on a mapping of `ParameterUuid` : `Param`.
+    /// This mapping assumes that the provided `ParameterUuid` keys are instances
+    /// of `ParameterExpression`.
+    pub fn assign_parameters_from_mapping<I, T>(&mut self, py: Python, iter: I) -> PyResult<()>
+    where
+        I: IntoIterator<Item = (ParameterUuid, T)>,
+        T: AsRef<Param>,
+    {
+        let mut items = Vec::new();
+        for (param_uuid, value) in iter {
+            // Assume all the Parameters are already in the circuit
+            let param_obj = self.get_parameter_by_uuid(param_uuid);
+            if let Some(param_obj) = param_obj {
+                // Copy or increase ref_count for Parameter, avoid acquiring the GIL.
+                items.push((
+                    param_obj.clone_ref(py),
+                    value.as_ref().clone_ref(py),
+                    self.param_table.pop(param_uuid)?,
+                ));
+            } else {
+                return Err(PyValueError::new_err("An invalid parameter was provided."));
+            }
+        }
+        self.assign_parameters_inner(py, items)
+    }
+
     /// Returns an immutable view of the Interner used for Qargs
     pub fn qargs_interner(&self) -> &Interner<[Qubit]> {
         &self.qargs_interner
@@ -1170,9 +1202,10 @@ impl CircuitData {
         self.cargs_interner().get(index)
     }
 
-    fn assign_parameters_inner<I>(&mut self, py: Python, iter: I) -> PyResult<()>
+    fn assign_parameters_inner<I, T>(&mut self, py: Python, iter: I) -> PyResult<()>
     where
-        I: IntoIterator<Item = (Py<PyAny>, Param, HashSet<ParameterUse>)>,
+        I: IntoIterator<Item = (Py<PyAny>, T, HashSet<ParameterUse>)>,
+        T: AsRef<Param> + Clone,
     {
         let inconsistent =
             || PyRuntimeError::new_err("internal error: circuit parameter table is inconsistent");
@@ -1209,7 +1242,7 @@ impl CircuitData {
         for (param_ob, value, uses) in iter {
             debug_assert!(!uses.is_empty());
             uuids.clear();
-            for inner_param_ob in value.iter_parameters(py)? {
+            for inner_param_ob in value.as_ref().iter_parameters(py)? {
                 uuids.push(self.param_table.track(&inner_param_ob?, None)?)
             }
             for usage in uses {
@@ -1220,7 +1253,7 @@ impl CircuitData {
                         };
                         self.set_global_phase(
                             py,
-                            bind_expr(expr.bind_borrowed(py), &param_ob, &value, true)?,
+                            bind_expr(expr.bind_borrowed(py), &param_ob, value.as_ref(), true)?,
                         )?;
                     }
                     ParameterUse::Index {
@@ -1234,17 +1267,21 @@ impl CircuitData {
                             let Param::ParameterExpression(expr) = &params[parameter] else {
                                 return Err(inconsistent());
                             };
-                            params[parameter] =
-                                match bind_expr(expr.bind_borrowed(py), &param_ob, &value, true)? {
-                                    Param::Obj(obj) => {
-                                        return Err(CircuitError::new_err(format!(
-                                            "bad type after binding for gate '{}': '{}'",
-                                            standard.name(),
-                                            obj.bind(py).repr()?,
-                                        )))
-                                    }
-                                    param => param,
-                                };
+                            params[parameter] = match bind_expr(
+                                expr.bind_borrowed(py),
+                                &param_ob,
+                                value.as_ref(),
+                                true,
+                            )? {
+                                Param::Obj(obj) => {
+                                    return Err(CircuitError::new_err(format!(
+                                        "bad type after binding for gate '{}': '{}'",
+                                        standard.name(),
+                                        obj.bind(py).repr()?,
+                                    )))
+                                }
+                                param => param,
+                            };
                             for uuid in uuids.iter() {
                                 self.param_table.add_use(*uuid, usage)?
                             }
@@ -1264,7 +1301,7 @@ impl CircuitData {
                             user_operations
                                 .entry(instruction)
                                 .or_insert_with(Vec::new)
-                                .push((param_ob.clone_ref(py), value.clone()));
+                                .push((param_ob.clone_ref(py), value.as_ref().clone_ref(py)));
 
                             let op = previous.unpack_py_op(py)?.into_bound(py);
                             let previous_param = &previous.params_view()[parameter];
@@ -1276,7 +1313,7 @@ impl CircuitData {
                                     let new_param = bind_expr(
                                         expr.bind_borrowed(py),
                                         &param_ob,
-                                        &value,
+                                        value.as_ref(),
                                         false,
                                     )?;
                                     // Historically, `assign_parameters` called `validate_parameter`
@@ -1305,7 +1342,7 @@ impl CircuitData {
                                     Param::extract_no_coerce(
                                         &obj.call_method(
                                             assign_parameters_attr,
-                                            ([(&param_ob, &value)].into_py_dict_bound(py),),
+                                            ([(&param_ob, value.as_ref())].into_py_dict_bound(py),),
                                             Some(
                                                 &[("inplace", false), ("flat_input", true)]
                                                     .into_py_dict_bound(py),
diff --git a/crates/circuit/src/operations.rs b/crates/circuit/src/operations.rs
index ccf41d7eefb2..f6e087a5680f 100644
--- a/crates/circuit/src/operations.rs
+++ b/crates/circuit/src/operations.rs
@@ -125,6 +125,24 @@ impl Param {
             Param::Obj(ob.clone().unbind())
         })
     }
+
+    /// Clones the [Param] object safely by reference count or copying.
+    pub fn clone_ref(&self, py: Python) -> Self {
+        match self {
+            Param::ParameterExpression(exp) => Param::ParameterExpression(exp.clone_ref(py)),
+            Param::Float(float) => Param::Float(*float),
+            Param::Obj(obj) => Param::Obj(obj.clone_ref(py)),
+        }
+    }
+}
+
+// This impl allows for shared usage between [Param] and &[Param].
+// Such blanked impl doesn't exist inherently due to Rust's type system limitations.
+// See https://doc.rust-lang.org/std/convert/trait.AsRef.html#reflexivity for more information.
+impl AsRef<Param> for Param {
+    fn as_ref(&self) -> &Param {
+        self
+    }
 }
 
 /// Struct to provide iteration over Python-space `Parameter` instances within a `Param`.

From 05a9b55db9e0a4909bd6e2cad0750a29beb3bb60 Mon Sep 17 00:00:00 2001
From: Jake Lishman <jake.lishman@ibm.com>
Date: Fri, 30 Aug 2024 15:25:27 +0100
Subject: [PATCH 31/85] Remove legacy-editable option from setuptools builds
 (#13059)

We needed this back when `setuptools` first introduced the new editable
installations, but at this point it should work more correctly without
it; our non-CI configurations haven't included it for some time.
---
 .azure/test-linux.yml          | 4 ----
 .azure/test-macos.yml          | 2 --
 .azure/test-windows.yml        | 2 --
 .github/workflows/coverage.yml | 1 -
 .github/workflows/slow.yml     | 2 --
 5 files changed, 11 deletions(-)

diff --git a/.azure/test-linux.yml b/.azure/test-linux.yml
index a773c15add50..a641ae215efd 100644
--- a/.azure/test-linux.yml
+++ b/.azure/test-linux.yml
@@ -92,8 +92,6 @@ jobs:
             # Build and install both qiskit and qiskit-terra so that any optionals
             # depending on `qiskit` will resolve correctly.
           displayName: "Install Terra directly"
-          env:
-            SETUPTOOLS_ENABLE_FEATURES: "legacy-editable"
 
       - ${{ if eq(parameters.installOptionals, true) }}:
         - bash: |
@@ -178,8 +176,6 @@ jobs:
             sudo apt-get install -y graphviz pandoc
             image_tests/bin/pip check
           displayName: 'Install dependencies'
-          env:
-            SETUPTOOLS_ENABLE_FEATURES: "legacy-editable"
 
         - bash: |
             echo "##vso[task.setvariable variable=HAVE_VISUAL_TESTS_RUN;]true"
diff --git a/.azure/test-macos.yml b/.azure/test-macos.yml
index b167df3f1c82..9e9620e8ecbb 100644
--- a/.azure/test-macos.yml
+++ b/.azure/test-macos.yml
@@ -48,8 +48,6 @@ jobs:
             # depending on `qiskit` will resolve correctly.
           pip check
         displayName: 'Install dependencies'
-        env:
-          SETUPTOOLS_ENABLE_FEATURES: "legacy-editable"
 
       - ${{ if eq(parameters.installOptionals, true) }}:
         - bash: |
diff --git a/.azure/test-windows.yml b/.azure/test-windows.yml
index eed1ef3eb6f8..8d86456bd72f 100644
--- a/.azure/test-windows.yml
+++ b/.azure/test-windows.yml
@@ -47,8 +47,6 @@ jobs:
           # depending on `qiskit` will resolve correctly.
           pip check
         displayName: 'Install dependencies'
-        env:
-          SETUPTOOLS_ENABLE_FEATURES: "legacy-editable"
 
       - ${{ if eq(parameters.installOptionals, true) }}:
         - bash: |
diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml
index 33dc654801e1..95a0bda5d421 100644
--- a/.github/workflows/coverage.yml
+++ b/.github/workflows/coverage.yml
@@ -47,7 +47,6 @@ jobs:
           CARGO_INCREMENTAL: 0
           RUSTFLAGS: "-Cinstrument-coverage"
           LLVM_PROFILE_FILE: "qiskit-%p-%m.profraw"
-          SETUPTOOLS_ENABLE_FEATURES: "legacy-editable"
 
       - name: Generate unittest coverage report
         run: |
diff --git a/.github/workflows/slow.yml b/.github/workflows/slow.yml
index 7f503b7de735..0207b1ec51f7 100644
--- a/.github/workflows/slow.yml
+++ b/.github/workflows/slow.yml
@@ -21,8 +21,6 @@ jobs:
           python -m pip install -U -r requirements-dev.txt -c constraints.txt
           python -m pip install -c constraints.txt -e .
           python -m pip install "qiskit-aer" "z3-solver" "cplex" -c constraints.txt
-        env:
-          SETUPTOOLS_ENABLE_FEATURES: "legacy-editable"
       - name: Run all tests including slow
         run: stestr run
         env:

From 31fbcacccabf464a56652edb082cb7e69df71622 Mon Sep 17 00:00:00 2001
From: Jake Lishman <jake.lishman@ibm.com>
Date: Fri, 30 Aug 2024 16:07:18 +0100
Subject: [PATCH 32/85] Add no-hash-lookup way to retrieve the default interned
 value (#13035)

* Add no-hash-lookup way to retrieve the default interned value

This makes it possible to do `Interner::get_default()` without any
value, in order to retrieve a key pointing to the default allocation
without making any hash lookups.  While the hashing and equality check
of the default allocation is typically very cheap (like the empty
slice), acquiring it still generally required a function call, which
often needed to be paid frequently.

* Add symmetric method on `Interned`

* Tweak documentation wording

Co-authored-by: Kevin Hartman <kevin@hart.mn>

* Re-remove `Interned::of_default` following review

---------

Co-authored-by: Kevin Hartman <kevin@hart.mn>
---
 crates/circuit/src/circuit_data.rs |  4 ++--
 crates/circuit/src/interner.rs     | 30 +++++++++++++++++++++++++++++-
 2 files changed, 31 insertions(+), 3 deletions(-)

diff --git a/crates/circuit/src/circuit_data.rs b/crates/circuit/src/circuit_data.rs
index 72eaa34d4142..1aed43de0a21 100644
--- a/crates/circuit/src/circuit_data.rs
+++ b/crates/circuit/src/circuit_data.rs
@@ -199,7 +199,7 @@ impl CircuitData {
             instruction_iter.size_hint().0,
             global_phase,
         )?;
-        let no_clbit_index = res.cargs_interner.insert(&[]);
+        let no_clbit_index = res.cargs_interner.get_default();
         for (operation, params, qargs) in instruction_iter {
             let qubits = res.qargs_interner.insert(&qargs);
             let params = (!params.is_empty()).then(|| Box::new(params));
@@ -258,7 +258,7 @@ impl CircuitData {
         params: &[Param],
         qargs: &[Qubit],
     ) -> PyResult<()> {
-        let no_clbit_index = self.cargs_interner.insert(&[]);
+        let no_clbit_index = self.cargs_interner.get_default();
         let params = (!params.is_empty()).then(|| Box::new(params.iter().cloned().collect()));
         let qubits = self.qargs_interner.insert(qargs);
         self.data.push(PackedInstruction {
diff --git a/crates/circuit/src/interner.rs b/crates/circuit/src/interner.rs
index 007256422e25..39c5364aa1cc 100644
--- a/crates/circuit/src/interner.rs
+++ b/crates/circuit/src/interner.rs
@@ -50,17 +50,23 @@ unsafe impl<T: ?Sized> Sync for Interned<T> {}
 /// itself (the `Interned` type), rather than raw references; the `Interned` type is narrower than a
 /// true reference.
 ///
+/// This is only implemented for owned types that implement `Default`, so that the convenience
+/// method `Interner::get_default` can work reliably and correctly; the "default" index needs to be
+/// guaranteed to be reserved and present for safety.
+///
 /// # Examples
 ///
 /// ```rust
 /// let mut interner = Interner::<[usize]>::new();
 ///
 /// // These are of type `Interned<[usize]>`.
+/// let default_empty = interner.get_default();
 /// let empty = interner.insert(&[]);
 /// let other_empty = interner.insert(&[]);
 /// let key = interner.insert(&[0, 1, 2, 3, 4]);
 ///
 /// assert_eq!(empty, other_empty);
+/// assert_eq!(empty, default_empty);
 /// assert_ne!(empty, key);
 ///
 /// assert_eq!(interner.get(empty), &[]);
@@ -93,9 +99,31 @@ where
 impl<T> Interner<T>
 where
     T: ?Sized + ToOwned,
+    <T as ToOwned>::Owned: Hash + Eq + Default,
 {
+    /// Construct a new interner.  The stored type must have a default value, in order for
+    /// `Interner::get_default` to reliably work correctly without a hash lookup (though ideally
+    /// we'd just use specialisation to do that).
     pub fn new() -> Self {
-        Self(Default::default())
+        let mut set = IndexSet::with_capacity_and_hasher(1, Default::default());
+        set.insert(Default::default());
+        Self(set)
+    }
+
+    /// Retrieve the key corresponding to the default store, without any hash or equality lookup.
+    /// For example, if the interned type is `[Clbit]`, the default key corresponds to the empty
+    /// slice `&[]`.  This is a common operation with the cargs interner, for things like pushing
+    /// gates.
+    ///
+    /// In an ideal world, we wouldn't have the `Default` trait bound on `new`, but would use
+    /// specialisation to insert the default key only if the stored value implemented `Default`
+    /// (we'd still trait-bound this method).
+    #[inline(always)]
+    pub fn get_default(&self) -> Interned<T> {
+        Interned {
+            index: 0,
+            _type: PhantomData,
+        }
     }
 }
 

From 8e5fab6c7176edcb134e9b00d141efa32f2fe3db Mon Sep 17 00:00:00 2001
From: Matthew Treinish <mtreinish@kortar.org>
Date: Fri, 30 Aug 2024 12:06:35 -0400
Subject: [PATCH 33/85] Fully port Optimize1qGatesDecomposition to Rust
 (#12959)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Fully port Optimize1qGatesDecomposition to Rust

This commit builds off of #12550 and the other data model in Rust
infrastructure and migrates the Optimize1qGatesDecomposition pass to
operate fully in Rust. The full path of the transpiler pass now never
leaves rust until it has finished modifying the DAGCircuit. There is
still some python interaction necessary to handle parts of the data
model that are still in Python, mainly calibrations and parameter
expressions (for global phase). But otherwise the entirety of the pass
operates in rust now.

This is just a first pass at the migration here, it moves the pass to be
a single for loop in rust. The next steps here are to look at operating
the pass in parallel. There is no data dependency between the
optimizations being done by the pass so we should be able to the
throughput of the pass by leveraging multithreading to handle each run
in parallel. This commit does not attempt this though, because of the
Python dependency and also the data structures around gates and the
dag aren't really setup for multithreading yet and there likely will
need to be some work to support that (this pass is a good candidate to
work through the bugs on that).

Part of #12208

* Tweak control_flow_op_nodes() method to avoid dag traversal when not necessary

* Store target basis set without heap allocation

Since we only are storing 12 enum fields (which are a single byte) using
any heap allocated collection is completely overkill and will have more
overhead that storing a statically sized array for all 12 variants. This
commit adds a new struct that wraps a `[bool; 12]` to track which
basis are supported and an API for tracking this. This simplifies the
tracking of which qubit supports which EulerBasis, it also means other
internal users of the 1q decomposition have a simplified API for working
with the euler basis.

* Remove From trait for Qubit->PhysicalQubit conversion

* Fix merge conflict

* Use new DAGCircuit::has_control_flow() for control_flow_op_nodes() pymethod

* Move _basis_gates set creation to __init__

* Update releasenotes/notes/optimize-1q-gates-decomposition-ce111961b6782ee0.yaml

Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>

---------

Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>
---
 .../src/euler_one_qubit_decomposer.rs         | 427 +++++++++++++-----
 crates/accelerate/src/nlayout.rs              |   3 +-
 .../accelerate/src/target_transpiler/mod.rs   |  11 +
 crates/accelerate/src/two_qubit_decompose.rs  |  14 +-
 crates/circuit/src/dag_circuit.rs             | 181 ++++++--
 .../optimization/optimize_1q_decomposition.py |  52 +--
 .../transpiler/passes/utils/control_flow.py   |  10 +-
 ...-gates-decomposition-ce111961b6782ee0.yaml |  12 +
 8 files changed, 519 insertions(+), 191 deletions(-)
 create mode 100644 releasenotes/notes/optimize-1q-gates-decomposition-ce111961b6782ee0.yaml

diff --git a/crates/accelerate/src/euler_one_qubit_decomposer.rs b/crates/accelerate/src/euler_one_qubit_decomposer.rs
index 75a2f7993f86..a3cb11ea45a2 100644
--- a/crates/accelerate/src/euler_one_qubit_decomposer.rs
+++ b/crates/accelerate/src/euler_one_qubit_decomposer.rs
@@ -13,7 +13,7 @@
 #![allow(clippy::too_many_arguments)]
 #![allow(clippy::upper_case_acronyms)]
 
-use hashbrown::HashMap;
+use hashbrown::{HashMap, HashSet};
 use num_complex::{Complex64, ComplexFloat};
 use smallvec::{smallvec, SmallVec};
 use std::cmp::Ordering;
@@ -29,14 +29,19 @@ use pyo3::Python;
 use ndarray::prelude::*;
 use numpy::PyReadonlyArray2;
 use pyo3::pybacked::PyBackedStr;
+use rustworkx_core::petgraph::stable_graph::NodeIndex;
 
 use qiskit_circuit::circuit_data::CircuitData;
+use qiskit_circuit::dag_circuit::{DAGCircuit, NodeType};
 use qiskit_circuit::dag_node::DAGOpNode;
 use qiskit_circuit::operations::{Operation, Param, StandardGate};
 use qiskit_circuit::slice::{PySequenceIndex, SequenceIndex};
 use qiskit_circuit::util::c64;
 use qiskit_circuit::Qubit;
 
+use crate::nlayout::PhysicalQubit;
+use crate::target_transpiler::Target;
+
 pub const ANGLE_ZERO_EPSILON: f64 = 1e-12;
 
 #[pyclass(module = "qiskit._accelerate.euler_one_qubit_decomposer")]
@@ -69,6 +74,7 @@ impl OneQubitGateErrorMap {
     }
 }
 
+#[derive(Debug)]
 #[pyclass(sequence)]
 pub struct OneQubitGateSequence {
     pub gates: Vec<(StandardGate, SmallVec<[f64; 3]>)>,
@@ -571,21 +577,116 @@ pub fn generate_circuit(
     Ok(res)
 }
 
-#[derive(Clone, Debug, Copy)]
+const EULER_BASIS_SIZE: usize = 12;
+
+static EULER_BASES: [&[&str]; EULER_BASIS_SIZE] = [
+    &["u3"],
+    &["u3", "u2", "u1"],
+    &["u"],
+    &["p", "sx"],
+    &["u1", "rx"],
+    &["r"],
+    &["rz", "ry"],
+    &["rz", "rx"],
+    &["rz", "rx"],
+    &["rx", "ry"],
+    &["rz", "sx", "x"],
+    &["rz", "sx"],
+];
+static EULER_BASIS_NAMES: [EulerBasis; EULER_BASIS_SIZE] = [
+    EulerBasis::U3,
+    EulerBasis::U321,
+    EulerBasis::U,
+    EulerBasis::PSX,
+    EulerBasis::U1X,
+    EulerBasis::RR,
+    EulerBasis::ZYZ,
+    EulerBasis::ZXZ,
+    EulerBasis::XZX,
+    EulerBasis::XYX,
+    EulerBasis::ZSXX,
+    EulerBasis::ZSX,
+];
+
+/// A structure containing a set of supported `EulerBasis` for running 1q synthesis
+#[derive(Debug, Clone)]
+pub struct EulerBasisSet {
+    basis: [bool; EULER_BASIS_SIZE],
+    initialized: bool,
+}
+
+impl EulerBasisSet {
+    // Instantiate a new EulerBasisSet
+    pub fn new() -> Self {
+        EulerBasisSet {
+            basis: [false; EULER_BASIS_SIZE],
+            initialized: false,
+        }
+    }
+
+    /// Return true if this has been initialized any basis is supported
+    pub fn initialized(&self) -> bool {
+        self.initialized
+    }
+
+    /// Add a basis to the set
+    pub fn add_basis(&mut self, basis: EulerBasis) {
+        self.basis[basis as usize] = true;
+        self.initialized = true;
+    }
+
+    /// Get an iterator of all the supported EulerBasis
+    pub fn get_bases(&self) -> impl Iterator<Item = EulerBasis> + '_ {
+        self.basis
+            .iter()
+            .enumerate()
+            .filter_map(|(index, supported)| {
+                if *supported {
+                    Some(EULER_BASIS_NAMES[index])
+                } else {
+                    None
+                }
+            })
+    }
+
+    /// Check if a basis is supported by this set
+    pub fn basis_supported(&self, basis: EulerBasis) -> bool {
+        self.basis[basis as usize]
+    }
+
+    /// Modify this set to support all EulerBasis
+    pub fn support_all(&mut self) {
+        self.basis = [true; 12];
+        self.initialized = true;
+    }
+
+    /// Remove an basis from the set
+    pub fn remove(&mut self, basis: EulerBasis) {
+        self.basis[basis as usize] = false;
+    }
+}
+
+impl Default for EulerBasisSet {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[derive(Clone, Debug, Copy, Eq, Hash, PartialEq)]
 #[pyclass(module = "qiskit._accelerate.euler_one_qubit_decomposer")]
 pub enum EulerBasis {
-    U321,
-    U3,
-    U,
-    PSX,
-    ZSX,
-    ZSXX,
-    U1X,
-    RR,
-    ZYZ,
-    ZXZ,
-    XYX,
-    XZX,
+    U3 = 0,
+    U321 = 1,
+    U = 2,
+    PSX = 3,
+    U1X = 4,
+    RR = 5,
+    ZYZ = 6,
+    ZXZ = 7,
+    XZX = 8,
+    XYX = 9,
+    ZSXX = 10,
+    ZSX = 11,
 }
 
 impl EulerBasis {
@@ -684,24 +785,6 @@ fn compare_error_fn(
     }
 }
 
-fn compute_error(
-    gates: &[(StandardGate, SmallVec<[f64; 3]>)],
-    error_map: Option<&OneQubitGateErrorMap>,
-    qubit: usize,
-) -> (f64, usize) {
-    match error_map {
-        Some(err_map) => {
-            let num_gates = gates.len();
-            let gate_fidelities: f64 = gates
-                .iter()
-                .map(|gate| 1. - err_map.error_map[qubit].get(gate.0.name()).unwrap_or(&0.))
-                .product();
-            (1. - gate_fidelities, num_gates)
-        }
-        None => (gates.len() as f64, gates.len()),
-    }
-}
-
 fn compute_error_term(gate: &str, error_map: &OneQubitGateErrorMap, qubit: usize) -> f64 {
     1. - error_map.error_map[qubit].get(gate).unwrap_or(&0.)
 }
@@ -724,15 +807,6 @@ fn compute_error_str(
     }
 }
 
-#[pyfunction]
-pub fn compute_error_one_qubit_sequence(
-    circuit: &OneQubitGateSequence,
-    qubit: usize,
-    error_map: Option<&OneQubitGateErrorMap>,
-) -> (f64, usize) {
-    compute_error(&circuit.gates, error_map, qubit)
-}
-
 #[pyfunction]
 pub fn compute_error_list(
     circuit: Vec<PyRef<DAGOpNode>>,
@@ -761,13 +835,16 @@ pub fn unitary_to_gate_sequence(
     simplify: bool,
     atol: Option<f64>,
 ) -> PyResult<Option<OneQubitGateSequence>> {
-    let target_basis_vec: PyResult<Vec<EulerBasis>> = target_basis_list
+    let mut target_basis_set = EulerBasisSet::new();
+    for basis in target_basis_list
         .iter()
         .map(|basis| EulerBasis::__new__(basis))
-        .collect();
+    {
+        target_basis_set.add_basis(basis?);
+    }
     Ok(unitary_to_gate_sequence_inner(
         unitary.as_array(),
-        &target_basis_vec?,
+        &target_basis_set,
         qubit,
         error_map,
         simplify,
@@ -778,17 +855,17 @@ pub fn unitary_to_gate_sequence(
 #[inline]
 pub fn unitary_to_gate_sequence_inner(
     unitary_mat: ArrayView2<Complex64>,
-    target_basis_list: &[EulerBasis],
+    target_basis_list: &EulerBasisSet,
     qubit: usize,
     error_map: Option<&OneQubitGateErrorMap>,
     simplify: bool,
     atol: Option<f64>,
 ) -> Option<OneQubitGateSequence> {
     target_basis_list
-        .iter()
+        .get_bases()
         .map(|target_basis| {
-            let [theta, phi, lam, phase] = angles_from_unitary(unitary_mat, *target_basis);
-            generate_circuit(target_basis, theta, phi, lam, phase, simplify, atol).unwrap()
+            let [theta, phi, lam, phase] = angles_from_unitary(unitary_mat, target_basis);
+            generate_circuit(&target_basis, theta, phi, lam, phase, simplify, atol).unwrap()
         })
         .min_by(|a, b| {
             let error_a = compare_error_fn(a, &error_map, qubit);
@@ -808,13 +885,16 @@ pub fn unitary_to_circuit(
     simplify: bool,
     atol: Option<f64>,
 ) -> PyResult<Option<CircuitData>> {
-    let target_basis_vec: PyResult<Vec<EulerBasis>> = target_basis_list
+    let mut target_basis_set = EulerBasisSet::new();
+    for basis in target_basis_list
         .iter()
         .map(|basis| EulerBasis::__new__(basis))
-        .collect();
+    {
+        target_basis_set.add_basis(basis?);
+    }
     let circuit_sequence = unitary_to_gate_sequence_inner(
         unitary.as_array(),
-        &target_basis_vec?,
+        &target_basis_set,
         qubit,
         error_map,
         simplify,
@@ -965,70 +1045,198 @@ pub fn params_zxz(unitary: PyReadonlyArray2<Complex64>) -> [f64; 4] {
     params_zxz_inner(mat)
 }
 
-type OptimizeDecompositionReturn = Option<((f64, usize), (f64, usize), OneQubitGateSequence)>;
+fn compute_error_term_from_target(gate: &str, target: &Target, qubit: PhysicalQubit) -> f64 {
+    1. - target.get_error(gate, &[qubit]).unwrap_or(0.)
+}
+
+fn compute_error_from_target_one_qubit_sequence(
+    circuit: &OneQubitGateSequence,
+    qubit: PhysicalQubit,
+    target: Option<&Target>,
+) -> (f64, usize) {
+    match target {
+        Some(target) => {
+            let num_gates = circuit.gates.len();
+            let gate_fidelities: f64 = circuit
+                .gates
+                .iter()
+                .map(|gate| compute_error_term_from_target(gate.0.name(), target, qubit))
+                .product();
+            (1. - gate_fidelities, num_gates)
+        }
+        None => (circuit.gates.len() as f64, circuit.gates.len()),
+    }
+}
 
 #[pyfunction]
-pub fn optimize_1q_gates_decomposition(
-    runs: Vec<Vec<PyRef<DAGOpNode>>>,
-    qubits: Vec<usize>,
-    bases: Vec<Vec<PyBackedStr>>,
-    simplify: bool,
-    error_map: Option<&OneQubitGateErrorMap>,
-    atol: Option<f64>,
-) -> Vec<OptimizeDecompositionReturn> {
-    runs.iter()
-        .enumerate()
-        .map(|(index, raw_run)| -> OptimizeDecompositionReturn {
-            let mut error = match error_map {
-                Some(_) => 1.,
-                None => raw_run.len() as f64,
+#[pyo3(signature = (dag, *, target=None, basis_gates=None, global_decomposers=None))]
+pub(crate) fn optimize_1q_gates_decomposition(
+    py: Python,
+    dag: &mut DAGCircuit,
+    target: Option<&Target>,
+    basis_gates: Option<HashSet<String>>,
+    global_decomposers: Option<Vec<String>>,
+) -> PyResult<()> {
+    let runs: Vec<Vec<NodeIndex>> = dag.collect_1q_runs().unwrap().collect();
+    let dag_qubits = dag.num_qubits();
+    let mut target_basis_per_qubit: Vec<EulerBasisSet> = vec![EulerBasisSet::new(); dag_qubits];
+    let mut basis_gates_per_qubit: Vec<Option<HashSet<&str>>> = vec![None; dag_qubits];
+    for raw_run in runs {
+        let mut error = match target {
+            Some(_) => 1.,
+            None => raw_run.len() as f64,
+        };
+        let qubit: PhysicalQubit = if let NodeType::Operation(inst) = &dag.dag[raw_run[0]] {
+            PhysicalQubit::new(dag.get_qargs(inst.qubits)[0].0)
+        } else {
+            unreachable!("nodes in runs will always be op nodes")
+        };
+        if !dag.calibrations_empty() {
+            let mut has_calibration = false;
+            for node in &raw_run {
+                if dag.has_calibration_for_index(py, *node)? {
+                    has_calibration = true;
+                    break;
+                }
+            }
+            if has_calibration {
+                continue;
+            }
+        }
+        if basis_gates_per_qubit[qubit.0 as usize].is_none() {
+            let basis_gates = match target {
+                Some(target) => Some(
+                    target
+                        .operation_names_for_qargs(Some(&smallvec![qubit]))
+                        .unwrap(),
+                ),
+                None => {
+                    let basis = basis_gates.as_ref();
+                    basis.map(|basis| basis.iter().map(|x| x.as_str()).collect())
+                }
             };
-            let qubit = qubits[index];
-            let operator = &raw_run
-                .iter()
-                .map(|node| {
-                    if let Some(err_map) = error_map {
-                        error *=
-                            compute_error_term(node.instruction.operation.name(), err_map, qubit)
-                    }
-                    node.instruction
-                        .operation
-                        .matrix(&node.instruction.params)
-                        .expect("No matrix defined for operation")
-                })
-                .fold(
-                    [
-                        [Complex64::new(1., 0.), Complex64::new(0., 0.)],
-                        [Complex64::new(0., 0.), Complex64::new(1., 0.)],
-                    ],
-                    |mut operator, node| {
-                        matmul_1q(&mut operator, node);
-                        operator
+            basis_gates_per_qubit[qubit.0 as usize] = basis_gates;
+        }
+        let basis_gates = &basis_gates_per_qubit[qubit.0 as usize].as_ref();
+
+        let target_basis_set = &mut target_basis_per_qubit[qubit.0 as usize];
+        if !target_basis_set.initialized() {
+            match target {
+                Some(_target) => EULER_BASES
+                    .iter()
+                    .enumerate()
+                    .filter_map(|(idx, gates)| {
+                        if !gates
+                            .iter()
+                            .all(|gate| basis_gates.as_ref().unwrap().contains(gate))
+                        {
+                            return None;
+                        }
+                        let basis = EULER_BASIS_NAMES[idx];
+                        Some(basis)
+                    })
+                    .for_each(|basis| target_basis_set.add_basis(basis)),
+                None => match &global_decomposers {
+                    Some(bases) => bases
+                        .iter()
+                        .map(|basis| EulerBasis::__new__(basis).unwrap())
+                        .for_each(|basis| target_basis_set.add_basis(basis)),
+                    None => match basis_gates {
+                        Some(gates) => EULER_BASES
+                            .iter()
+                            .enumerate()
+                            .filter_map(|(idx, basis_gates)| {
+                                if !gates.iter().all(|gate| basis_gates.as_ref().contains(gate)) {
+                                    return None;
+                                }
+                                let basis = EULER_BASIS_NAMES[idx];
+                                Some(basis)
+                            })
+                            .for_each(|basis| target_basis_set.add_basis(basis)),
+                        None => target_basis_set.support_all(),
                     },
-                );
-            let old_error = if error_map.is_some() {
-                (1. - error, raw_run.len())
-            } else {
-                (error, raw_run.len())
+                },
             };
-            let target_basis_vec: Vec<EulerBasis> = bases[index]
-                .iter()
-                .map(|basis| EulerBasis::__new__(basis).unwrap())
-                .collect();
-            unitary_to_gate_sequence_inner(
-                aview2(operator),
-                &target_basis_vec,
-                qubit,
-                error_map,
-                simplify,
-                atol,
-            )
-            .map(|out_seq| {
-                let new_error = compute_error_one_qubit_sequence(&out_seq, qubit, error_map);
-                (old_error, new_error, out_seq)
+            if target_basis_set.basis_supported(EulerBasis::U3)
+                && target_basis_set.basis_supported(EulerBasis::U321)
+            {
+                target_basis_set.remove(EulerBasis::U3);
+            }
+            if target_basis_set.basis_supported(EulerBasis::ZSX)
+                && target_basis_set.basis_supported(EulerBasis::ZSXX)
+            {
+                target_basis_set.remove(EulerBasis::ZSX);
+            }
+        }
+        let target_basis_set = &target_basis_per_qubit[qubit.0 as usize];
+        let operator = raw_run
+            .iter()
+            .map(|node_index| {
+                let node = &dag.dag[*node_index];
+                if let NodeType::Operation(inst) = node {
+                    if let Some(target) = target {
+                        error *= compute_error_term_from_target(inst.op.name(), target, qubit);
+                    }
+                    inst.op.matrix(inst.params_view()).unwrap()
+                } else {
+                    unreachable!("Can only have op nodes here")
+                }
             })
-        })
-        .collect()
+            .fold(
+                [
+                    [Complex64::new(1., 0.), Complex64::new(0., 0.)],
+                    [Complex64::new(0., 0.), Complex64::new(1., 0.)],
+                ],
+                |mut operator, node| {
+                    matmul_1q(&mut operator, node);
+                    operator
+                },
+            );
+
+        let old_error = if target.is_some() {
+            (1. - error, raw_run.len())
+        } else {
+            (error, raw_run.len())
+        };
+        let sequence = unitary_to_gate_sequence_inner(
+            aview2(&operator),
+            target_basis_set,
+            qubit.0 as usize,
+            None,
+            true,
+            None,
+        );
+        let sequence = match sequence {
+            Some(seq) => seq,
+            None => continue,
+        };
+        let new_error = compute_error_from_target_one_qubit_sequence(&sequence, qubit, target);
+
+        let mut outside_basis = false;
+        if let Some(basis) = basis_gates {
+            for node in &raw_run {
+                if let NodeType::Operation(inst) = &dag.dag[*node] {
+                    if !basis.contains(inst.op.name()) {
+                        outside_basis = true;
+                        break;
+                    }
+                }
+            }
+        } else {
+            outside_basis = false;
+        }
+        if outside_basis
+            || new_error < old_error
+            || new_error.0.abs() < 1e-9 && old_error.0.abs() >= 1e-9
+        {
+            for gate in sequence.gates {
+                dag.insert_1q_on_incoming_qubit((gate.0, &gate.1), raw_run[0]);
+            }
+            dag.add_global_phase(py, &Param::Float(sequence.global_phase))?;
+            dag.remove_1q_sequence(&raw_run);
+        }
+    }
+    Ok(())
 }
 
 fn matmul_1q(operator: &mut [[Complex64; 2]; 2], other: Array2<Complex64>) {
@@ -1054,7 +1262,6 @@ pub fn euler_one_qubit_decomposer(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(generate_circuit))?;
     m.add_wrapped(wrap_pyfunction!(unitary_to_gate_sequence))?;
     m.add_wrapped(wrap_pyfunction!(unitary_to_circuit))?;
-    m.add_wrapped(wrap_pyfunction!(compute_error_one_qubit_sequence))?;
     m.add_wrapped(wrap_pyfunction!(compute_error_list))?;
     m.add_wrapped(wrap_pyfunction!(optimize_1q_gates_decomposition))?;
     m.add_class::<OneQubitGateSequence>()?;
diff --git a/crates/accelerate/src/nlayout.rs b/crates/accelerate/src/nlayout.rs
index e0235e5c954a..93b1036b608e 100644
--- a/crates/accelerate/src/nlayout.rs
+++ b/crates/accelerate/src/nlayout.rs
@@ -24,7 +24,7 @@ use hashbrown::HashMap;
 macro_rules! qubit_newtype {
     ($id: ident) => {
         #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-        pub struct $id(u32);
+        pub struct $id(pub u32);
 
         impl $id {
             #[inline]
@@ -72,6 +72,7 @@ impl PhysicalQubit {
         layout.phys_to_virt[self.index()]
     }
 }
+
 qubit_newtype!(VirtualQubit);
 impl VirtualQubit {
     /// Get the physical qubit that currently corresponds to this index of virtual qubit in the
diff --git a/crates/accelerate/src/target_transpiler/mod.rs b/crates/accelerate/src/target_transpiler/mod.rs
index 6d6e105b265d..08b3e90eabba 100644
--- a/crates/accelerate/src/target_transpiler/mod.rs
+++ b/crates/accelerate/src/target_transpiler/mod.rs
@@ -940,6 +940,17 @@ impl Target {
         });
     }
 
+    /// Get the error rate of a given instruction in the target
+    pub fn get_error(&self, name: &str, qargs: &[PhysicalQubit]) -> Option<f64> {
+        self.gate_map.get(name).and_then(|gate_props| {
+            let qargs_key: Qargs = qargs.iter().cloned().collect();
+            match gate_props.get(Some(&qargs_key)) {
+                Some(props) => props.as_ref().and_then(|inst_props| inst_props.error),
+                None => None,
+            }
+        })
+    }
+
     /// Get an iterator over the indices of all physical qubits of the target
     pub fn physical_qubits(&self) -> impl ExactSizeIterator<Item = usize> {
         0..self.num_qubits.unwrap_or_default()
diff --git a/crates/accelerate/src/two_qubit_decompose.rs b/crates/accelerate/src/two_qubit_decompose.rs
index 77ebb3f9433c..2c745b199e9e 100644
--- a/crates/accelerate/src/two_qubit_decompose.rs
+++ b/crates/accelerate/src/two_qubit_decompose.rs
@@ -41,7 +41,7 @@ use pyo3::types::PyList;
 
 use crate::convert_2q_block_matrix::change_basis;
 use crate::euler_one_qubit_decomposer::{
-    angles_from_unitary, det_one_qubit, unitary_to_gate_sequence_inner, EulerBasis,
+    angles_from_unitary, det_one_qubit, unitary_to_gate_sequence_inner, EulerBasis, EulerBasisSet,
     OneQubitGateSequence, ANGLE_ZERO_EPSILON,
 };
 use crate::utils;
@@ -1060,7 +1060,8 @@ impl TwoQubitWeylDecomposition {
             Some(basis) => EulerBasis::__new__(basis.deref())?,
             None => self.default_euler_basis,
         };
-        let target_1q_basis_list: Vec<EulerBasis> = vec![euler_basis];
+        let mut target_1q_basis_list = EulerBasisSet::new();
+        target_1q_basis_list.add_basis(euler_basis);
 
         let mut gate_sequence = CircuitData::with_capacity(py, 2, 0, 21, Param::Float(0.))?;
         let mut global_phase: f64 = self.global_phase;
@@ -1507,7 +1508,8 @@ impl TwoQubitBasisDecomposer {
         unitary: ArrayView2<Complex64>,
         qubit: u8,
     ) {
-        let target_1q_basis_list = vec![self.euler_basis];
+        let mut target_1q_basis_list = EulerBasisSet::new();
+        target_1q_basis_list.add_basis(self.euler_basis);
         let sequence = unitary_to_gate_sequence_inner(
             unitary,
             &target_1q_basis_list,
@@ -1751,7 +1753,8 @@ impl TwoQubitBasisDecomposer {
         if let Some(seq) = sequence {
             return Ok(seq);
         }
-        let target_1q_basis_list = vec![self.euler_basis];
+        let mut target_1q_basis_list = EulerBasisSet::new();
+        target_1q_basis_list.add_basis(self.euler_basis);
         let euler_decompositions: SmallVec<[Option<OneQubitGateSequence>; 8]> = decomposition
             .iter()
             .map(|decomp| {
@@ -1993,7 +1996,8 @@ impl TwoQubitBasisDecomposer {
         if let Some(seq) = sequence {
             return Ok(seq);
         }
-        let target_1q_basis_list = vec![self.euler_basis];
+        let mut target_1q_basis_list = EulerBasisSet::new();
+        target_1q_basis_list.add_basis(self.euler_basis);
         let euler_decompositions: SmallVec<[Option<OneQubitGateSequence>; 8]> = decomposition
             .iter()
             .map(|decomp| {
diff --git a/crates/circuit/src/dag_circuit.rs b/crates/circuit/src/dag_circuit.rs
index b6e33e78c1b2..afe6797596d9 100644
--- a/crates/circuit/src/dag_circuit.rs
+++ b/crates/circuit/src/dag_circuit.rs
@@ -22,8 +22,8 @@ use crate::dag_node::{DAGInNode, DAGNode, DAGOpNode, DAGOutNode};
 use crate::dot_utils::build_dot;
 use crate::error::DAGCircuitError;
 use crate::imports;
-use crate::interner::Interner;
-use crate::operations::{Operation, OperationRef, Param, PyInstruction};
+use crate::interner::{Interned, Interner};
+use crate::operations::{Operation, OperationRef, Param, PyInstruction, StandardGate};
 use crate::packed_instruction::PackedInstruction;
 use crate::rustworkx_core_vnext::isomorphism;
 use crate::{BitType, Clbit, Qubit, TupleLikeArg};
@@ -3867,7 +3867,7 @@ def _format(operand):
     ///     include_directives (bool): include `barrier`, `snapshot` etc.
     ///
     /// Returns:
-    ///     list[DAGOpNode]: the list of node ids containing the given op.
+    ///     list[DAGOpNode]: the list of dag nodes containing the given op.
     #[pyo3(name= "op_nodes", signature=(op=None, include_directives=true))]
     fn py_op_nodes(
         &self,
@@ -3903,6 +3903,33 @@ def _format(operand):
         Ok(nodes)
     }
 
+    /// Get a list of "op" nodes in the dag that contain control flow instructions.
+    ///
+    /// Returns:
+    ///     list[DAGOpNode] | None: The list of dag nodes containing control flow ops. If there
+    ///         are no control flow nodes None is returned
+    fn control_flow_op_nodes(&self, py: Python) -> PyResult<Option<Vec<Py<PyAny>>>> {
+        if self.has_control_flow() {
+            let result: PyResult<Vec<Py<PyAny>>> = self
+                .dag
+                .node_references()
+                .filter_map(|(node_index, node_type)| match node_type {
+                    NodeType::Operation(ref node) => {
+                        if node.op.control_flow() {
+                            Some(self.unpack_into(py, node_index, node_type))
+                        } else {
+                            None
+                        }
+                    }
+                    _ => None,
+                })
+                .collect();
+            Ok(Some(result?))
+        } else {
+            Ok(None)
+        }
+    }
+
     /// Get the list of gate nodes in the dag.
     ///
     /// Returns:
@@ -4978,31 +5005,6 @@ def _format(operand):
         Ok(result)
     }
 
-    fn _insert_1q_on_incoming_qubit(
-        &mut self,
-        py: Python,
-        node: &Bound<PyAny>,
-        old_index: usize,
-    ) -> PyResult<()> {
-        if let NodeType::Operation(inst) = self.pack_into(py, node)? {
-            self.increment_op(inst.op.name());
-            let new_index = self.dag.add_node(NodeType::Operation(inst));
-            let old_index: NodeIndex = NodeIndex::new(old_index);
-            let (parent_index, edge_index, weight) = self
-                .dag
-                .edges_directed(old_index, Incoming)
-                .map(|edge| (edge.source(), edge.id(), edge.weight().clone()))
-                .next()
-                .unwrap();
-            self.dag.add_edge(parent_index, new_index, weight.clone());
-            self.dag.add_edge(new_index, old_index, weight);
-            self.dag.remove_edge(edge_index);
-            Ok(())
-        } else {
-            Err(PyTypeError::new_err("Invalid node type input"))
-        }
-    }
-
     fn _edges(&self, py: Python) -> Vec<PyObject> {
         self.dag
             .edge_indices()
@@ -5604,7 +5606,7 @@ impl DAGCircuit {
     /// Remove an operation node n.
     ///
     /// Add edges from predecessors to successors.
-    fn remove_op_node(&mut self, index: NodeIndex) {
+    pub fn remove_op_node(&mut self, index: NodeIndex) {
         let mut edge_list: Vec<(NodeIndex, NodeIndex, Wire)> = Vec::new();
         for (source, in_weight) in self
             .dag
@@ -6154,6 +6156,127 @@ impl DAGCircuit {
         }
         Ok(())
     }
+    /// Get qargs from an intern index
+    pub fn get_qargs(&self, index: Interned<[Qubit]>) -> &[Qubit] {
+        self.qargs_interner.get(index)
+    }
+
+    /// Get cargs from an intern index
+    pub fn get_cargs(&self, index: Interned<[Clbit]>) -> &[Clbit] {
+        self.cargs_interner.get(index)
+    }
+
+    /// Insert a new 1q standard gate on incoming qubit
+    pub fn insert_1q_on_incoming_qubit(
+        &mut self,
+        new_gate: (StandardGate, &[f64]),
+        old_index: NodeIndex,
+    ) {
+        self.increment_op(new_gate.0.name());
+        let old_node = &self.dag[old_index];
+        let inst = if let NodeType::Operation(old_node) = old_node {
+            PackedInstruction {
+                op: new_gate.0.into(),
+                qubits: old_node.qubits,
+                clbits: old_node.clbits,
+                params: (!new_gate.1.is_empty())
+                    .then(|| Box::new(new_gate.1.iter().map(|x| Param::Float(*x)).collect())),
+                extra_attrs: None,
+                #[cfg(feature = "cache_pygates")]
+                py_op: OnceCell::new(),
+            }
+        } else {
+            panic!("This method only works if provided index is an op node");
+        };
+        let new_index = self.dag.add_node(NodeType::Operation(inst));
+        let (parent_index, edge_index, weight) = self
+            .dag
+            .edges_directed(old_index, Incoming)
+            .map(|edge| (edge.source(), edge.id(), edge.weight().clone()))
+            .next()
+            .unwrap();
+        self.dag.add_edge(parent_index, new_index, weight.clone());
+        self.dag.add_edge(new_index, old_index, weight);
+        self.dag.remove_edge(edge_index);
+    }
+
+    /// Remove a sequence of 1 qubit nodes from the dag
+    /// This must only be called if all the nodes operate
+    /// on a single qubit with no other wires in or out of any nodes
+    pub fn remove_1q_sequence(&mut self, sequence: &[NodeIndex]) {
+        let (parent_index, weight) = self
+            .dag
+            .edges_directed(*sequence.first().unwrap(), Incoming)
+            .map(|edge| (edge.source(), edge.weight().clone()))
+            .next()
+            .unwrap();
+        let child_index = self
+            .dag
+            .edges_directed(*sequence.last().unwrap(), Outgoing)
+            .map(|edge| edge.target())
+            .next()
+            .unwrap();
+        self.dag.add_edge(parent_index, child_index, weight);
+        for node in sequence {
+            match self.dag.remove_node(*node) {
+                Some(NodeType::Operation(packed)) => {
+                    let op_name = packed.op.name();
+                    self.decrement_op(op_name);
+                }
+                _ => panic!("Must be called with valid operation node!"),
+            }
+        }
+    }
+
+    pub fn add_global_phase(&mut self, py: Python, value: &Param) -> PyResult<()> {
+        match value {
+            Param::Obj(_) => {
+                return Err(PyTypeError::new_err(
+                    "Invalid parameter type, only float and parameter expression are supported",
+                ))
+            }
+            _ => self.set_global_phase(add_global_phase(py, &self.global_phase, value)?)?,
+        }
+        Ok(())
+    }
+
+    pub fn calibrations_empty(&self) -> bool {
+        self.calibrations.is_empty()
+    }
+
+    pub fn has_calibration_for_index(&self, py: Python, node_index: NodeIndex) -> PyResult<bool> {
+        let node = &self.dag[node_index];
+        if let NodeType::Operation(instruction) = node {
+            if !self.calibrations.contains_key(instruction.op.name()) {
+                return Ok(false);
+            }
+            let params = match &instruction.params {
+                Some(params) => {
+                    let mut out_params = Vec::new();
+                    for p in params.iter() {
+                        if let Param::ParameterExpression(exp) = p {
+                            let exp = exp.bind(py);
+                            if !exp.getattr(intern!(py, "parameters"))?.is_truthy()? {
+                                let as_py_float = exp.call_method0(intern!(py, "__float__"))?;
+                                out_params.push(as_py_float.unbind());
+                                continue;
+                            }
+                        }
+                        out_params.push(p.to_object(py));
+                    }
+                    PyTuple::new_bound(py, out_params)
+                }
+                None => PyTuple::empty_bound(py),
+            };
+            let qargs = self.qargs_interner.get(instruction.qubits);
+            let qubits = PyTuple::new_bound(py, qargs.iter().map(|x| x.0));
+            self.calibrations[instruction.op.name()]
+                .bind(py)
+                .contains((qubits, params).to_object(py))
+        } else {
+            Err(DAGCircuitError::new_err("Specified node is not an op node"))
+        }
+    }
 }
 
 /// Add to global phase. Global phase can only be Float or ParameterExpression so this
diff --git a/qiskit/transpiler/passes/optimization/optimize_1q_decomposition.py b/qiskit/transpiler/passes/optimization/optimize_1q_decomposition.py
index 181f02e312b3..ac7673060746 100644
--- a/qiskit/transpiler/passes/optimization/optimize_1q_decomposition.py
+++ b/qiskit/transpiler/passes/optimization/optimize_1q_decomposition.py
@@ -35,7 +35,6 @@
 from qiskit.circuit import Qubit
 from qiskit.circuit.quantumcircuitdata import CircuitInstruction
 from qiskit.dagcircuit.dagcircuit import DAGCircuit
-from qiskit.dagcircuit.dagnode import DAGOpNode
 
 
 logger = logging.getLogger(__name__)
@@ -82,9 +81,12 @@ def __init__(self, basis=None, target=None):
         """
         super().__init__()
 
-        self._basis_gates = basis
+        if basis:
+            self._basis_gates = set(basis)
+        else:
+            self._basis_gates = None
         self._target = target
-        self._global_decomposers = []
+        self._global_decomposers = None
         self._local_decomposers_cache = {}
 
         if basis:
@@ -209,46 +211,12 @@ def run(self, dag):
         Returns:
             DAGCircuit: the optimized DAG.
         """
-        runs = []
-        qubits = []
-        bases = []
-        for run in dag.collect_1q_runs():
-            qubit = dag.find_bit(run[0].qargs[0]).index
-            runs.append(run)
-            qubits.append(qubit)
-            bases.append(self._get_decomposer(qubit))
-        best_sequences = euler_one_qubit_decomposer.optimize_1q_gates_decomposition(
-            runs, qubits, bases, simplify=True, error_map=self.error_map
+        euler_one_qubit_decomposer.optimize_1q_gates_decomposition(
+            dag,
+            target=self._target,
+            global_decomposers=self._global_decomposers,
+            basis_gates=self._basis_gates,
         )
-        for index, best_circuit_sequence in enumerate(best_sequences):
-            run = runs[index]
-            qubit = qubits[index]
-            if self._target is None:
-                basis = self._basis_gates
-            else:
-                basis = self._target.operation_names_for_qargs((qubit,))
-            if best_circuit_sequence is not None:
-                (old_error, new_error, best_circuit_sequence) = best_circuit_sequence
-                if self._substitution_checks(
-                    dag,
-                    run,
-                    best_circuit_sequence,
-                    basis,
-                    qubit,
-                    old_error=old_error,
-                    new_error=new_error,
-                ):
-                    first_node_id = run[0]._node_id
-                    qubit = run[0].qargs
-                    for gate, angles in best_circuit_sequence:
-                        op = CircuitInstruction.from_standard(gate, qubit, angles)
-                        node = DAGOpNode.from_instruction(op)
-                        dag._insert_1q_on_incoming_qubit(node, first_node_id)
-                    dag.global_phase += best_circuit_sequence.global_phase
-                    # Delete the other nodes in the run
-                    for current_node in run:
-                        dag.remove_op_node(current_node)
-
         return dag
 
     def _error(self, circuit, qubit):
diff --git a/qiskit/transpiler/passes/utils/control_flow.py b/qiskit/transpiler/passes/utils/control_flow.py
index 27c3c83d53c7..4fc95587e782 100644
--- a/qiskit/transpiler/passes/utils/control_flow.py
+++ b/qiskit/transpiler/passes/utils/control_flow.py
@@ -54,10 +54,12 @@ def out(self, dag):
         def bound_wrapped_method(dag):
             return out(self, dag)
 
-        for node in dag.op_nodes(ControlFlowOp):
-            dag.substitute_node(
-                node, map_blocks(bound_wrapped_method, node.op), propagate_condition=False
-            )
+        control_flow_nodes = dag.control_flow_op_nodes()
+        if control_flow_nodes is not None:
+            for node in control_flow_nodes:
+                dag.substitute_node(
+                    node, map_blocks(bound_wrapped_method, node.op), propagate_condition=False
+                )
         return method(self, dag)
 
     return out
diff --git a/releasenotes/notes/optimize-1q-gates-decomposition-ce111961b6782ee0.yaml b/releasenotes/notes/optimize-1q-gates-decomposition-ce111961b6782ee0.yaml
new file mode 100644
index 000000000000..dbb095827b00
--- /dev/null
+++ b/releasenotes/notes/optimize-1q-gates-decomposition-ce111961b6782ee0.yaml
@@ -0,0 +1,12 @@
+---
+features_transpiler:
+  - |
+    Added a new method :meth:`.DAGCircuit.control_flow_ops` which provides a fast
+    path to get all the :class:`.DAGOpNode` in a :class:`.DAGCircuit` that
+    contain a :class:`.ControlFlowOp`. This was possible before using the
+    :meth:`.DAGCircuit.op_nodes` method and passing the :class:`.ControlFlowOp` class
+    as a filter, but this new function will perform the operation faster.
+  - |
+    Ported the entirety of the :class:`.Optimize1qGatesDecomposition` transpiler
+    pass to Rust. This improves the runtime performance of the pass between 5x
+    to 10x.

From 623415cdb740fd6e164f0f5fd2b55fba081cd437 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Elena=20Pe=C3=B1a=20Tapia?=
 <57907331+ElePT@users.noreply.github.com>
Date: Fri, 30 Aug 2024 21:10:26 +0200
Subject: [PATCH 34/85] Fix  use of `node.op` in `Split2QUnitaries` (#13015)

* Replace node.op with node.matrix

* Add docstring to test gate

* Fix black
---
 .../passes/optimization/split_2q_unitaries.py |  2 +-
 ...nitaries-custom-gate-d10f7670a35548f4.yaml |  6 +++
 .../transpiler/test_split_2q_unitaries.py     | 39 ++++++++++++++++++-
 3 files changed, 45 insertions(+), 2 deletions(-)
 create mode 100644 releasenotes/notes/fix-split-2q-unitaries-custom-gate-d10f7670a35548f4.yaml

diff --git a/qiskit/transpiler/passes/optimization/split_2q_unitaries.py b/qiskit/transpiler/passes/optimization/split_2q_unitaries.py
index ac04043a27fa..0b1788e5bbe6 100644
--- a/qiskit/transpiler/passes/optimization/split_2q_unitaries.py
+++ b/qiskit/transpiler/passes/optimization/split_2q_unitaries.py
@@ -51,7 +51,7 @@ def run(self, dag: DAGCircuit):
             ):
                 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
diff --git a/releasenotes/notes/fix-split-2q-unitaries-custom-gate-d10f7670a35548f4.yaml b/releasenotes/notes/fix-split-2q-unitaries-custom-gate-d10f7670a35548f4.yaml
new file mode 100644
index 000000000000..331156cf6012
--- /dev/null
+++ b/releasenotes/notes/fix-split-2q-unitaries-custom-gate-d10f7670a35548f4.yaml
@@ -0,0 +1,6 @@
+---
+fixes:
+  - |
+    Fixed a bug in :class:`.Split2QUnitaries` where it would fail to run on circuits
+    with custom gates that didn't implement :meth:`__array__`.
+    See `#12984 <https://github.com/Qiskit/qiskit/issues/12970>`__.
\ No newline at end of file
diff --git a/test/python/transpiler/test_split_2q_unitaries.py b/test/python/transpiler/test_split_2q_unitaries.py
index 616d93e5b3f8..7fbb93c2419d 100644
--- a/test/python/transpiler/test_split_2q_unitaries.py
+++ b/test/python/transpiler/test_split_2q_unitaries.py
@@ -19,7 +19,7 @@
 
 from qiskit import QuantumCircuit, QuantumRegister, transpile
 from qiskit.circuit.library import UnitaryGate, XGate, ZGate, HGate
-from qiskit.circuit import Parameter, CircuitInstruction
+from qiskit.circuit import Parameter, CircuitInstruction, Gate
 from qiskit.providers.fake_provider import GenericBackendV2
 from qiskit.quantum_info import Operator
 from qiskit.transpiler import PassManager
@@ -223,3 +223,40 @@ def test_split_qft(self):
         pm.append(Split2QUnitaries())
         qc_split = pm.run(qc)
         self.assertEqual(26, qc_split.num_nonlocal_gates())
+
+    def test_gate_no_array(self):
+        """
+        Test that the pass doesn't fail when the circuit contains a custom gate
+        with no ``__array__`` implementation.
+
+        Reproduce from: https://github.com/Qiskit/qiskit/issues/12970
+        """
+
+        class MyGate(Gate):
+            """Custom gate"""
+
+            def __init__(self):
+                super().__init__("mygate", 2, [])
+
+            def to_matrix(self):
+                return np.eye(4, dtype=complex)
+                # return np.eye(4, dtype=float)
+
+        def mygate(self, qubit1, qubit2):
+            return self.append(MyGate(), [qubit1, qubit2], [])
+
+        QuantumCircuit.mygate = mygate
+
+        qc = QuantumCircuit(2)
+        qc.mygate(0, 1)
+
+        pm = PassManager()
+        pm.append(Collect2qBlocks())
+        pm.append(ConsolidateBlocks())
+        pm.append(Split2QUnitaries())
+        qc_split = pm.run(qc)
+
+        self.assertTrue(Operator(qc).equiv(qc_split))
+        self.assertTrue(
+            matrix_equal(Operator(qc).data, Operator(qc_split).data, ignore_phase=False)
+        )

From 5fc1635b6c447e910dbf9f390eb1e6ec789e70a4 Mon Sep 17 00:00:00 2001
From: melechlapson <melechlapson@yahoo.com>
Date: Fri, 30 Aug 2024 16:55:00 -0500
Subject: [PATCH 35/85] Port the count_ops method in QuantumCircuit to Rust
 (#13050)

* added get_ops method to CircuitData Rust class

* Updated count_ops method in QuantumCircuit

* remove extra indexmap dependency

* fixed linting issues

* moved import

* removed return statement

* updated method names

* added release note

* add blank line

* revert changes to Cargo.lock

* removed unnecessary features

* Apply suggestions from Matthew's review

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>

* added docstring to count_ops method

* Update crates/circuit/src/circuit_data.rs

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>

---------

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>
---
 crates/circuit/src/circuit_data.rs              | 17 +++++++++++++++++
 qiskit/circuit/quantumcircuit.py                |  6 ++----
 .../port-countops-method-3ad362c20b13182c.yaml  |  5 +++++
 3 files changed, 24 insertions(+), 4 deletions(-)
 create mode 100644 releasenotes/notes/port-countops-method-3ad362c20b13182c.yaml

diff --git a/crates/circuit/src/circuit_data.rs b/crates/circuit/src/circuit_data.rs
index 1aed43de0a21..da49f9edc605 100644
--- a/crates/circuit/src/circuit_data.rs
+++ b/crates/circuit/src/circuit_data.rs
@@ -31,6 +31,7 @@ use pyo3::types::{IntoPyDict, PyDict, PyList, PySet, PyTuple, PyType};
 use pyo3::{import_exception, intern, PyTraverseError, PyVisit};
 
 use hashbrown::{HashMap, HashSet};
+use indexmap::IndexMap;
 use smallvec::SmallVec;
 
 import_exception!(qiskit.circuit.exceptions, CircuitError);
@@ -983,6 +984,22 @@ impl CircuitData {
         self.param_table.clear();
     }
 
+    /// Counts the number of times each operation is used in the circuit.
+    ///
+    /// # Parameters
+    /// - `self` - A mutable reference to the CircuitData struct.
+    ///
+    /// # Returns
+    /// An IndexMap containing the operation names as keys and their respective counts as values.
+    pub fn count_ops(&self) -> IndexMap<&str, usize, ::ahash::RandomState> {
+        let mut ops_count: IndexMap<&str, usize, ::ahash::RandomState> = IndexMap::default();
+        for instruction in &self.data {
+            *ops_count.entry(instruction.op.name()).or_insert(0) += 1;
+        }
+        ops_count.par_sort_by(|_k1, v1, _k2, v2| v2.cmp(v1));
+        ops_count
+    }
+
     // Marks this pyclass as NOT hashable.
     #[classattr]
     const __hash__: Option<Py<PyAny>> = None;
diff --git a/qiskit/circuit/quantumcircuit.py b/qiskit/circuit/quantumcircuit.py
index 487f1e28e382..ebc63511ca7b 100644
--- a/qiskit/circuit/quantumcircuit.py
+++ b/qiskit/circuit/quantumcircuit.py
@@ -3516,10 +3516,8 @@ def count_ops(self) -> "OrderedDict[Instruction, int]":
         Returns:
             OrderedDict: a breakdown of how many operations of each kind, sorted by amount.
         """
-        count_ops: dict[Instruction, int] = {}
-        for instruction in self._data:
-            count_ops[instruction.operation.name] = count_ops.get(instruction.operation.name, 0) + 1
-        return OrderedDict(sorted(count_ops.items(), key=lambda kv: kv[1], reverse=True))
+        ops_dict = self._data.count_ops()
+        return OrderedDict(ops_dict)
 
     def num_nonlocal_gates(self) -> int:
         """Return number of non-local gates (i.e. involving 2+ qubits).
diff --git a/releasenotes/notes/port-countops-method-3ad362c20b13182c.yaml b/releasenotes/notes/port-countops-method-3ad362c20b13182c.yaml
new file mode 100644
index 000000000000..93a92fa4c316
--- /dev/null
+++ b/releasenotes/notes/port-countops-method-3ad362c20b13182c.yaml
@@ -0,0 +1,5 @@
+---
+features_circuits:
+  - |
+    The :meth:`~.QuantumCircuit.count_ops` method in :class:`.QuantumCircuit` 
+    has been re-written in Rust. It now runs between 3 and 9 times faster.

From f4ca088644b4461b856b4b49c33e23b04a995019 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 2 Sep 2024 12:14:16 +0000
Subject: [PATCH 36/85] Bump indexmap from 2.4.0 to 2.5.0 (#13068)

Bumps [indexmap](https://github.com/indexmap-rs/indexmap) from 2.4.0 to 2.5.0.
- [Changelog](https://github.com/indexmap-rs/indexmap/blob/master/RELEASES.md)
- [Commits](https://github.com/indexmap-rs/indexmap/compare/2.4.0...2.5.0)

---
updated-dependencies:
- dependency-name: indexmap
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 136ca4bed376..10344e611726 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -570,9 +570,9 @@ checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
 
 [[package]]
 name = "indexmap"
-version = "2.4.0"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93ead53efc7ea8ed3cfb0c79fc8023fbb782a5432b52830b6518941cebe6505c"
+checksum = "68b900aa2f7301e21c36462b170ee99994de34dff39a4a6a528e80e7376d07e5"
 dependencies = [
  "equivalent",
  "hashbrown 0.14.5",
diff --git a/Cargo.toml b/Cargo.toml
index a35a87d4d3b1..4f7f8ad86b96 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,7 +15,7 @@ license = "Apache-2.0"
 # Each crate can add on specific features freely as it inherits.
 [workspace.dependencies]
 bytemuck = "1.17"
-indexmap.version = "2.4.0"
+indexmap.version = "2.5.0"
 hashbrown.version = "0.14.5"
 num-bigint = "0.4"
 num-complex = "0.4"

From 3fac5da41e2aba66e5d0735e9e9e8159b9ba24f2 Mon Sep 17 00:00:00 2001
From: Max Rossmannek <oss@zurich.ibm.com>
Date: Mon, 2 Sep 2024 17:08:20 +0200
Subject: [PATCH 37/85] docs: ensure CollectAndCollapse is part of the public
 API (#13071)

---
 qiskit/transpiler/passes/__init__.py              | 2 ++
 qiskit/transpiler/passes/optimization/__init__.py | 1 +
 2 files changed, 3 insertions(+)

diff --git a/qiskit/transpiler/passes/__init__.py b/qiskit/transpiler/passes/__init__.py
index 1feabeaef048..ca4e3545a98b 100644
--- a/qiskit/transpiler/passes/__init__.py
+++ b/qiskit/transpiler/passes/__init__.py
@@ -71,6 +71,7 @@
    Collect1qRuns
    Collect2qBlocks
    CollectMultiQBlocks
+   CollectAndCollapse
    CollectLinearFunctions
    CollectCliffords
    ConsolidateBlocks
@@ -238,6 +239,7 @@
 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
diff --git a/qiskit/transpiler/passes/optimization/__init__.py b/qiskit/transpiler/passes/optimization/__init__.py
index a9796850a689..8e2883b27781 100644
--- a/qiskit/transpiler/passes/optimization/__init__.py
+++ b/qiskit/transpiler/passes/optimization/__init__.py
@@ -39,3 +39,4 @@
 from .normalize_rx_angle import NormalizeRXAngle
 from .optimize_annotated import OptimizeAnnotated
 from .split_2q_unitaries import Split2QUnitaries
+from .collect_and_collapse import CollectAndCollapse

From f30f851c98fdc7369d1d710937438c13d0e13f08 Mon Sep 17 00:00:00 2001
From: Shravan Patel <78003234+shravanpatel30@users.noreply.github.com>
Date: Tue, 3 Sep 2024 02:51:38 -0500
Subject: [PATCH 38/85] Fixed ZZFeatureMap not accepting a list of entanglement
 (#12767)

* Added a get_entangler_map() and _selective_entangler_map() functions to PauliFeatureMap

* Added some logic to handle the List[List[List[List[int]]]] case. Refer to the comments in the code.

* `entanglement` can now be specified as dictionary `{num_qubits: entanglement}`

* Added logic to handle cases when entanglement is not specified for some pauli blocks.

* Added tests cases for `PauliFeatureMap`

* Added test and releasenotes. Also modified the typing hints and doc strings to reflect new changes.

* Replaced all tab characters with spaces to fix the linting error.

* Formatted releasenotes as per the suggestion to fix the issue in reno.

* Added `Callable[[int], Union[str | Dict[...]]]` to the typing hints and included some logic to handle that.

* Removed `List[List[int]]` from typing hints as this is equivalent to List[Tuple[int]]

Co-authored-by: Julien Gacon <gaconju@gmail.com>

* updated the release notes

Co-authored-by: Julien Gacon <gaconju@gmail.com>

* Updated typing hints in `ZZFeatureMap`

---------

Co-authored-by: Julien Gacon <gaconju@gmail.com>
---
 .../data_preparation/pauli_feature_map.py     | 57 +++++++++++++--
 .../data_preparation/zz_feature_map.py        | 10 ++-
 ...nary-as-entanglement-02037cb2d46e1c41.yaml | 26 +++++++
 .../circuit/library/test_pauli_feature_map.py | 73 +++++++++++++++++++
 4 files changed, 158 insertions(+), 8 deletions(-)
 create mode 100644 releasenotes/notes/paulifeaturemap-takes-dictionary-as-entanglement-02037cb2d46e1c41.yaml

diff --git a/qiskit/circuit/library/data_preparation/pauli_feature_map.py b/qiskit/circuit/library/data_preparation/pauli_feature_map.py
index 03bbc031ec63..8cad7d23835b 100644
--- a/qiskit/circuit/library/data_preparation/pauli_feature_map.py
+++ b/qiskit/circuit/library/data_preparation/pauli_feature_map.py
@@ -11,8 +11,7 @@
 # that they have been altered from the originals.
 
 """The Pauli expansion circuit module."""
-
-from typing import Optional, Callable, List, Union
+from typing import Optional, Callable, List, Union, Sequence, Dict, Tuple
 from functools import reduce
 import numpy as np
 
@@ -116,7 +115,11 @@ def __init__(
         self,
         feature_dimension: Optional[int] = None,
         reps: int = 2,
-        entanglement: Union[str, List[List[int]], Callable[[int], List[int]]] = "full",
+        entanglement: Union[
+            str,
+            Dict[int, List[Tuple[int]]],
+            Callable[[int], Union[str, Dict[int, List[Tuple[int]]]]],
+        ] = "full",
         alpha: float = 2.0,
         paulis: Optional[List[str]] = None,
         data_map_func: Optional[Callable[[np.ndarray], float]] = None,
@@ -129,8 +132,13 @@ def __init__(
         Args:
             feature_dimension: Number of qubits in the circuit.
             reps: The number of repeated circuits.
-            entanglement: Specifies the entanglement structure. Refer to
-                :class:`~qiskit.circuit.library.NLocal` for detail.
+            entanglement: Specifies the entanglement structure. Can be a string (``'full'``,
+                ``'linear'``, ``'reverse_linear'``, ``'circular'`` or ``'sca'``) or can be a
+                dictionary where the keys represent the number of qubits and the values are list
+                of integer-pairs specifying the indices of qubits that are entangled with one
+                another, for example: ``{1: [(0,), (2,)], 2: [(0,1), (2,0)]}`` or can be a
+                ``Callable[[int], Union[str | Dict[...]]]`` to return an entanglement specific for
+                a repetition
             alpha: The Pauli rotation factor, multiplicative to the pauli rotations
             paulis: A list of strings for to-be-used paulis. If None are provided, ``['Z', 'ZZ']``
                 will be used.
@@ -281,6 +289,45 @@ def cx_chain(circuit, inverse=False):
         basis_change(evo, inverse=True)
         return evo
 
+    def get_entangler_map(
+        self, rep_num: int, block_num: int, num_block_qubits: int
+    ) -> Sequence[Sequence[int]]:
+
+        # if entanglement is a Callable[[int], Union[str | Dict[...]]]
+        if callable(self._entanglement):
+            entanglement = self._entanglement(rep_num)
+        else:
+            entanglement = self._entanglement
+
+        # entanglement is Dict[int, List[List[int]]]
+        if isinstance(entanglement, dict):
+            if all(
+                isinstance(e2, (int, np.int32, np.int64))
+                for key in entanglement.keys()
+                for en in entanglement[key]
+                for e2 in en
+            ):
+                for qb, ent in entanglement.items():
+                    for en in ent:
+                        if len(en) != qb:
+                            raise ValueError(
+                                f"For num_qubits = {qb}, entanglement must be a "
+                                f"tuple of length {qb}. You specified {en}."
+                            )
+
+            # Check if the entanglement is specified for all the pauli blocks being used
+            for pauli in self.paulis:
+                if len(pauli) not in entanglement.keys():
+                    raise ValueError(f"No entanglement specified for {pauli} pauli.")
+
+            return entanglement[num_block_qubits]
+
+        else:
+            # if the entanglement is not Dict[int, List[List[int]]] or
+            # Dict[int, List[Tuple[int]]] then we fall back on the original
+            # `get_entangler_map()` method from NLocal
+            return super().get_entangler_map(rep_num, block_num, num_block_qubits)
+
 
 def self_product(x: np.ndarray) -> float:
     """
diff --git a/qiskit/circuit/library/data_preparation/zz_feature_map.py b/qiskit/circuit/library/data_preparation/zz_feature_map.py
index 5500bb6691be..2f51b8f63482 100644
--- a/qiskit/circuit/library/data_preparation/zz_feature_map.py
+++ b/qiskit/circuit/library/data_preparation/zz_feature_map.py
@@ -12,7 +12,7 @@
 
 """Second-order Pauli-Z expansion circuit."""
 
-from typing import Callable, List, Union, Optional
+from typing import Callable, List, Union, Optional, Dict, Tuple
 import numpy as np
 from .pauli_feature_map import PauliFeatureMap
 
@@ -75,7 +75,11 @@ def __init__(
         self,
         feature_dimension: int,
         reps: int = 2,
-        entanglement: Union[str, List[List[int]], Callable[[int], List[int]]] = "full",
+        entanglement: Union[
+            str,
+            Dict[int, List[Tuple[int]]],
+            Callable[[int], Union[str, Dict[int, List[Tuple[int]]]]],
+        ] = "full",
         data_map_func: Optional[Callable[[np.ndarray], float]] = None,
         parameter_prefix: str = "x",
         insert_barriers: bool = False,
@@ -87,7 +91,7 @@ def __init__(
             feature_dimension: Number of features.
             reps: The number of repeated circuits, has a min. value of 1.
             entanglement: Specifies the entanglement structure. Refer to
-                :class:`~qiskit.circuit.library.NLocal` for detail.
+                :class:`~qiskit.circuit.library.PauliFeatureMap` for detail.
             data_map_func: A mapping function for data x.
             parameter_prefix: The prefix used if default parameters are generated.
             insert_barriers: If True, barriers are inserted in between the evolution instructions
diff --git a/releasenotes/notes/paulifeaturemap-takes-dictionary-as-entanglement-02037cb2d46e1c41.yaml b/releasenotes/notes/paulifeaturemap-takes-dictionary-as-entanglement-02037cb2d46e1c41.yaml
new file mode 100644
index 000000000000..8acfe5439a50
--- /dev/null
+++ b/releasenotes/notes/paulifeaturemap-takes-dictionary-as-entanglement-02037cb2d46e1c41.yaml
@@ -0,0 +1,26 @@
+---
+fixes:
+  - |
+    Fixed that the entanglement in :class:`.PauliFeatureMap` and :class:`.ZZFeatureMap`
+    could be given as ``List[int]`` or ``List[List[int]]``, which was incompatible with the fact
+    that entanglement blocks of different sizes are used. Instead, the entanglement can be 
+    given as dictionary with ``{block_size: entanglement}`` pairs.
+features_circuits:
+  - |
+    :class:`.PauliFeatureMap` and :class:`.ZZFeatureMap` now support specifying the 
+    entanglement as a dictionary where the keys represent the number of qubits, and 
+    the values are lists of integer tuples that define which qubits are entangled with one another. This
+    allows for more flexibility in constructing feature maps tailored to specific quantum algorithms. 
+    Example usage::
+
+      from qiskit.circuit.library import PauliFeatureMap
+      entanglement = {
+        1: [(0,), (2,)],
+        2: [(0, 1), (1, 2)],
+        3: [(0, 1, 2)],
+      }
+      qc = PauliFeatureMap(3, reps=2, paulis=['Z', 'ZZ', 'ZZZ'], entanglement=entanglement, insert_barriers=True)
+      qc.decompose().draw('mpl')
+
+
+
diff --git a/test/python/circuit/library/test_pauli_feature_map.py b/test/python/circuit/library/test_pauli_feature_map.py
index 60b7e5c28b9c..0e15af654edd 100644
--- a/test/python/circuit/library/test_pauli_feature_map.py
+++ b/test/python/circuit/library/test_pauli_feature_map.py
@@ -221,6 +221,79 @@ def test_parameter_prefix(self):
         self.assertEqual(str(encoding_z_param_y.parameters), "ParameterView([Parameter(y)])")
         self.assertEqual(str(encoding_zz_param_y.parameters), "ParameterView([Parameter(y)])")
 
+    def test_entanglement_as_dictionary(self):
+        """Test whether PauliFeatureMap accepts entanglement as a dictionary and generates
+        correct feature map circuit"""
+        n_qubits = 3
+        entanglement = {
+            1: [(0,), (2,)],
+            2: [(0, 1), (1, 2)],
+            3: [(0, 1, 2)],
+        }
+        params = [np.pi / 4, np.pi / 2, np.pi]
+
+        def z_block(circuit, q1):
+            circuit.p(2 * params[q1], q1)
+
+        def zz_block(circuit, q1, q2):
+            param = (np.pi - params[q1]) * (np.pi - params[q2])
+            circuit.cx(q1, q2)
+            circuit.p(2 * param, q2)
+            circuit.cx(q1, q2)
+
+        def zzz_block(circuit, q1, q2, q3):
+            param = (np.pi - params[q1]) * (np.pi - params[q2]) * (np.pi - params[q3])
+            circuit.cx(q1, q2)
+            circuit.cx(q2, q3)
+            circuit.p(2 * param, q3)
+            circuit.cx(q2, q3)
+            circuit.cx(q1, q2)
+
+        feat_map = PauliFeatureMap(
+            n_qubits, reps=2, paulis=["Z", "ZZ", "ZZZ"], entanglement=entanglement
+        ).assign_parameters(params)
+
+        qc = QuantumCircuit(n_qubits)
+        for _ in range(2):
+            qc.h([0, 1, 2])
+            for e1 in entanglement[1]:
+                z_block(qc, *e1)
+            for e2 in entanglement[2]:
+                zz_block(qc, *e2)
+            for e3 in entanglement[3]:
+                zzz_block(qc, *e3)
+
+        self.assertTrue(Operator(feat_map).equiv(qc))
+
+    def test_invalid_entanglement(self):
+        """Test if a ValueError is raised when an invalid entanglement is passed"""
+        n_qubits = 3
+        entanglement = {
+            1: [(0, 1), (2,)],
+            2: [(0, 1), (1, 2)],
+            3: [(0, 1, 2)],
+        }
+
+        with self.assertRaises(ValueError):
+            feat_map = PauliFeatureMap(
+                n_qubits, reps=2, paulis=["Z", "ZZ", "ZZZ"], entanglement=entanglement
+            )
+            feat_map.count_ops()
+
+    def test_entanglement_not_specified(self):
+        """Test if an error is raised when entanglement is not explicitly specified for
+        all n-qubit pauli blocks"""
+        n_qubits = 3
+        entanglement = {
+            1: [(0, 1), (2,)],
+            3: [(0, 1, 2)],
+        }
+        with self.assertRaises(ValueError):
+            feat_map = PauliFeatureMap(
+                n_qubits, reps=2, paulis=["Z", "ZZ", "ZZZ"], entanglement=entanglement
+            )
+            feat_map.count_ops()
+
 
 if __name__ == "__main__":
     unittest.main()

From f882fd53d3903b002ebc97b2b23bc8a70200763e Mon Sep 17 00:00:00 2001
From: Alexander Ivrii <alexi@il.ibm.com>
Date: Tue, 3 Sep 2024 14:10:01 +0300
Subject: [PATCH 39/85] Oxidize random clifford (#12695)

* starting to experiment

* porting code

* messy code porting

* printing statements to enable debugging

* fixes

* fixing phase

* removing some of the printing statements

* fixing inaccuracy for cost computation

* Moving some of the functionality to SymplecticMatrix class

* reducing the number of warnings

* formatting

* replacing expensive adjoint and compose operations for symplectic matrices by significantly cheaper in-place prepend operations

* resolving merge conflicts

* cleanup

* code cleanup

* cleanup

* cleanup

* cleanup

* cleanup

* cleanup

* cleanup

* cleanup

* using fast lookup

* cleanup

* clippy

* including params in gate_seq to avoid mapping

* removing unnecessary inner function

* cleanup

* renaming

* changes on the python side

* reno

* adding error handling

* improved error handling

* removing redundant Ok(Some(...))

* using random_clifford in tests

* reorganizing clifford code

* fixes

* formatting

* improved error handling

* do not panic

* formatting

* initial implementation

* cleanup

* changing return to be the full tableau

* parallelized computation for binary matrix multiplication for matrices with >= 10 qubits

* updating python code and adding release notes

* lint, test, reno

* removing obsolete python code

* removing todo (after experimenting with alternative implementation)

* removing another obsolete todo

* unused import

* adding comment
---
 .../accelerate/src/synthesis/clifford/mod.rs  |  26 ++-
 .../src/synthesis/clifford/random_clifford.rs | 162 ++++++++++++++++++
 .../accelerate/src/synthesis/linear/utils.rs  |  51 +++++-
 .../operators/symplectic/random.py            | 156 +----------------
 ...dize-random-clifford-934f45876c14c8a0.yaml |   5 +
 .../operators/symplectic/test_clifford.py     |   4 +-
 6 files changed, 243 insertions(+), 161 deletions(-)
 create mode 100644 crates/accelerate/src/synthesis/clifford/random_clifford.rs
 create mode 100644 releasenotes/notes/oxidize-random-clifford-934f45876c14c8a0.yaml

diff --git a/crates/accelerate/src/synthesis/clifford/mod.rs b/crates/accelerate/src/synthesis/clifford/mod.rs
index 4828a5666734..d2c1e36fab4f 100644
--- a/crates/accelerate/src/synthesis/clifford/mod.rs
+++ b/crates/accelerate/src/synthesis/clifford/mod.rs
@@ -12,12 +12,13 @@
 
 mod bm_synthesis;
 mod greedy_synthesis;
+mod random_clifford;
 mod utils;
 
 use crate::synthesis::clifford::bm_synthesis::synth_clifford_bm_inner;
 use crate::synthesis::clifford::greedy_synthesis::GreedyCliffordSynthesis;
 use crate::QiskitError;
-use numpy::PyReadonlyArray2;
+use numpy::{IntoPyArray, PyArray2, PyReadonlyArray2};
 use pyo3::prelude::*;
 use qiskit_circuit::circuit_data::CircuitData;
 use qiskit_circuit::operations::Param;
@@ -43,6 +44,28 @@ fn synth_clifford_greedy(py: Python, clifford: PyReadonlyArray2<bool>) -> PyResu
     CircuitData::from_standard_gates(py, num_qubits as u32, clifford_gates, Param::Float(0.0))
 }
 
+/// Generate a random Clifford tableau.
+///
+/// The Clifford is sampled using the method of the paper "Hadamard-free circuits
+/// expose the structure of the Clifford group" by S. Bravyi and D. Maslov (2020),
+/// `https://arxiv.org/abs/2003.09412`__.
+///
+/// Args:
+///     num_qubits: the number of qubits.
+///     seed: an optional random seed.
+/// Returns:
+///     result: a random clifford tableau.
+#[pyfunction]
+#[pyo3(signature = (num_qubits, seed=None))]
+fn random_clifford_tableau(
+    py: Python,
+    num_qubits: usize,
+    seed: Option<u64>,
+) -> PyResult<Py<PyArray2<bool>>> {
+    let tableau = random_clifford::random_clifford_tableau_inner(num_qubits, seed);
+    Ok(tableau.into_pyarray_bound(py).unbind())
+}
+
 /// Create a circuit that optimally synthesizes a given Clifford operator represented as
 /// a tableau for Cliffords up to 3 qubits.
 ///
@@ -60,5 +83,6 @@ fn synth_clifford_bm(py: Python, clifford: PyReadonlyArray2<bool>) -> PyResult<C
 pub fn clifford(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(synth_clifford_greedy, m)?)?;
     m.add_function(wrap_pyfunction!(synth_clifford_bm, m)?)?;
+    m.add_function(wrap_pyfunction!(random_clifford_tableau, m)?)?;
     Ok(())
 }
diff --git a/crates/accelerate/src/synthesis/clifford/random_clifford.rs b/crates/accelerate/src/synthesis/clifford/random_clifford.rs
new file mode 100644
index 000000000000..fee3ac8e9650
--- /dev/null
+++ b/crates/accelerate/src/synthesis/clifford/random_clifford.rs
@@ -0,0 +1,162 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// 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.
+
+use crate::synthesis::linear::utils::{
+    binary_matmul_inner, calc_inverse_matrix_inner, replace_row_inner, swap_rows_inner,
+};
+use ndarray::{concatenate, s, Array1, Array2, ArrayView2, ArrayViewMut2, Axis};
+use rand::{Rng, SeedableRng};
+use rand_pcg::Pcg64Mcg;
+
+/// Sample from the quantum Mallows distribution.
+fn sample_qmallows(n: usize, rng: &mut Pcg64Mcg) -> (Array1<bool>, Array1<usize>) {
+    // Hadamard layer
+    let mut had = Array1::from_elem(n, false);
+
+    // Permutation layer
+    let mut perm = Array1::from_elem(n, 0);
+    let mut inds: Vec<usize> = (0..n).collect();
+
+    for i in 0..n {
+        let m = n - i;
+        let eps: f64 = 4f64.powi(-(m as i32));
+        let r: f64 = rng.gen();
+        let index: usize = -((r + (1f64 - r) * eps).log2().ceil() as isize) as usize;
+        had[i] = index < m;
+        let k = if index < m { index } else { 2 * m - index - 1 };
+        perm[i] = inds[k];
+        inds.remove(k);
+    }
+    (had, perm)
+}
+
+/// Add symmetric random boolean value to off diagonal entries.
+fn fill_tril(mut mat: ArrayViewMut2<bool>, rng: &mut Pcg64Mcg, symmetric: bool) {
+    let n = mat.shape()[0];
+    for i in 0..n {
+        for j in 0..i {
+            mat[[i, j]] = rng.gen();
+            if symmetric {
+                mat[[j, i]] = mat[[i, j]];
+            }
+        }
+    }
+}
+
+/// Invert a lower-triangular matrix with unit diagonal.
+fn inverse_tril(mat: ArrayView2<bool>) -> Array2<bool> {
+    calc_inverse_matrix_inner(mat, false).unwrap()
+}
+
+/// Generate a random Clifford tableau.
+///
+/// The Clifford is sampled using the method of the paper "Hadamard-free circuits
+/// expose the structure of the Clifford group" by S. Bravyi and D. Maslov (2020),
+/// `https://arxiv.org/abs/2003.09412`__.
+///
+/// The function returns a random clifford tableau.
+pub fn random_clifford_tableau_inner(num_qubits: usize, seed: Option<u64>) -> Array2<bool> {
+    let mut rng = match seed {
+        Some(seed) => Pcg64Mcg::seed_from_u64(seed),
+        None => Pcg64Mcg::from_entropy(),
+    };
+
+    let (had, perm) = sample_qmallows(num_qubits, &mut rng);
+
+    let mut gamma1: Array2<bool> = Array2::from_elem((num_qubits, num_qubits), false);
+    for i in 0..num_qubits {
+        gamma1[[i, i]] = rng.gen();
+    }
+    fill_tril(gamma1.view_mut(), &mut rng, true);
+
+    let mut gamma2: Array2<bool> = Array2::from_elem((num_qubits, num_qubits), false);
+    for i in 0..num_qubits {
+        gamma2[[i, i]] = rng.gen();
+    }
+    fill_tril(gamma2.view_mut(), &mut rng, true);
+
+    let mut delta1: Array2<bool> = Array2::from_shape_fn((num_qubits, num_qubits), |(i, j)| i == j);
+    fill_tril(delta1.view_mut(), &mut rng, false);
+
+    let mut delta2: Array2<bool> = Array2::from_shape_fn((num_qubits, num_qubits), |(i, j)| i == j);
+    fill_tril(delta2.view_mut(), &mut rng, false);
+
+    // Compute stabilizer table
+    let zero = Array2::from_elem((num_qubits, num_qubits), false);
+    let prod1 = binary_matmul_inner(gamma1.view(), delta1.view()).unwrap();
+    let prod2 = binary_matmul_inner(gamma2.view(), delta2.view()).unwrap();
+    let inv1 = inverse_tril(delta1.view()).t().to_owned();
+    let inv2 = inverse_tril(delta2.view()).t().to_owned();
+
+    let table1 = concatenate(
+        Axis(0),
+        &[
+            concatenate(Axis(1), &[delta1.view(), zero.view()])
+                .unwrap()
+                .view(),
+            concatenate(Axis(1), &[prod1.view(), inv1.view()])
+                .unwrap()
+                .view(),
+        ],
+    )
+    .unwrap();
+
+    let table2 = concatenate(
+        Axis(0),
+        &[
+            concatenate(Axis(1), &[delta2.view(), zero.view()])
+                .unwrap()
+                .view(),
+            concatenate(Axis(1), &[prod2.view(), inv2.view()])
+                .unwrap()
+                .view(),
+        ],
+    )
+    .unwrap();
+
+    // Compute the full stabilizer tableau
+
+    // The code below is identical to the Python implementation, but is based on the original
+    // code in the paper.
+
+    let mut table = Array2::from_elem((2 * num_qubits, 2 * num_qubits), false);
+
+    // Apply qubit permutation
+    for i in 0..num_qubits {
+        replace_row_inner(table.view_mut(), i, table2.slice(s![i, ..]));
+        replace_row_inner(
+            table.view_mut(),
+            perm[i] + num_qubits,
+            table2.slice(s![perm[i] + num_qubits, ..]),
+        );
+    }
+
+    // Apply layer of Hadamards
+    for i in 0..num_qubits {
+        if had[i] {
+            swap_rows_inner(table.view_mut(), i, i + num_qubits);
+        }
+    }
+
+    // Apply table
+    let random_symplectic_mat = binary_matmul_inner(table1.view(), table.view()).unwrap();
+
+    // Generate random phases
+    let random_phases: Array2<bool> = Array2::from_shape_fn((2 * num_qubits, 1), |_| rng.gen());
+
+    let random_tableau: Array2<bool> = concatenate(
+        Axis(1),
+        &[random_symplectic_mat.view(), random_phases.view()],
+    )
+    .unwrap();
+    random_tableau
+}
diff --git a/crates/accelerate/src/synthesis/linear/utils.rs b/crates/accelerate/src/synthesis/linear/utils.rs
index b4dbf4993081..5f1fb99fa682 100644
--- a/crates/accelerate/src/synthesis/linear/utils.rs
+++ b/crates/accelerate/src/synthesis/linear/utils.rs
@@ -10,9 +10,17 @@
 // copyright notice, and modified files need to carry a notice indicating
 // that they have been altered from the originals.
 
-use ndarray::{concatenate, s, Array2, ArrayView2, ArrayViewMut2, Axis};
+use ndarray::{azip, concatenate, s, Array2, ArrayView1, ArrayView2, ArrayViewMut2, Axis, Zip};
 use rand::{Rng, SeedableRng};
 use rand_pcg::Pcg64Mcg;
+use rayon::iter::{IndexedParallelIterator, ParallelIterator};
+use rayon::prelude::IntoParallelIterator;
+
+use crate::getenv_use_multiple_threads;
+
+/// Specifies the minimum number of qubits in order to parallelize computations
+/// (this number is chosen based on several local experiments).
+const PARALLEL_THRESHOLD: usize = 10;
 
 /// Binary matrix multiplication
 pub fn binary_matmul_inner(
@@ -30,11 +38,29 @@ pub fn binary_matmul_inner(
         ));
     }
 
-    Ok(Array2::from_shape_fn((n1_rows, n2_cols), |(i, j)| {
-        (0..n2_rows)
-            .map(|k| mat1[[i, k]] & mat2[[k, j]])
-            .fold(false, |acc, v| acc ^ v)
-    }))
+    let run_in_parallel = getenv_use_multiple_threads();
+
+    if n1_rows < PARALLEL_THRESHOLD || !run_in_parallel {
+        Ok(Array2::from_shape_fn((n1_rows, n2_cols), |(i, j)| {
+            (0..n2_rows)
+                .map(|k| mat1[[i, k]] & mat2[[k, j]])
+                .fold(false, |acc, v| acc ^ v)
+        }))
+    } else {
+        let mut result = Array2::from_elem((n1_rows, n2_cols), false);
+        result
+            .axis_iter_mut(Axis(0))
+            .into_par_iter()
+            .enumerate()
+            .for_each(|(i, mut row)| {
+                for j in 0..n2_cols {
+                    row[j] = (0..n2_rows)
+                        .map(|k| mat1[[i, k]] & mat2[[k, j]])
+                        .fold(false, |acc, v| acc ^ v)
+                }
+            });
+        Ok(result)
+    }
 }
 
 /// Gauss elimination of a matrix mat with m rows and n columns.
@@ -198,3 +224,16 @@ pub fn check_invertible_binary_matrix_inner(mat: ArrayView2<bool>) -> bool {
     let rank = compute_rank_inner(mat);
     rank == mat.nrows()
 }
+
+/// Mutate matrix ``mat`` in-place by swapping the contents of rows ``i`` and ``j``.
+pub fn swap_rows_inner(mut mat: ArrayViewMut2<bool>, i: usize, j: usize) {
+    let (mut x, mut y) = mat.multi_slice_mut((s![i, ..], s![j, ..]));
+    azip!((x in &mut x, y in &mut y) (*x, *y) = (*y, *x));
+}
+
+/// Mutate matrix ``mat`` in-place by replacing the contents of row ``i`` by ``row``.
+pub fn replace_row_inner(mut mat: ArrayViewMut2<bool>, i: usize, row: ArrayView1<bool>) {
+    let mut x = mat.slice_mut(s![i, ..]);
+    let y = row.slice(s![..]);
+    Zip::from(&mut x).and(&y).for_each(|x, &y| *x = y);
+}
diff --git a/qiskit/quantum_info/operators/symplectic/random.py b/qiskit/quantum_info/operators/symplectic/random.py
index 06b23ca29803..848bce73aa35 100644
--- a/qiskit/quantum_info/operators/symplectic/random.py
+++ b/qiskit/quantum_info/operators/symplectic/random.py
@@ -14,11 +14,12 @@
 """
 
 from __future__ import annotations
-import math
 
 import numpy as np
 from numpy.random import default_rng
 
+from qiskit._accelerate.synthesis.clifford import random_clifford_tableau
+
 from .clifford import Clifford
 from .pauli import Pauli
 from .pauli_list import PauliList
@@ -111,155 +112,6 @@ def random_clifford(num_qubits: int, seed: int | np.random.Generator | None = No
     else:
         rng = default_rng(seed)
 
-    had, perm = _sample_qmallows(num_qubits, rng)
-
-    gamma1 = np.diag(rng.integers(2, size=num_qubits, dtype=np.int8))
-    gamma2 = np.diag(rng.integers(2, size=num_qubits, dtype=np.int8))
-    delta1 = np.eye(num_qubits, dtype=np.int8)
-    delta2 = delta1.copy()
-
-    _fill_tril(gamma1, rng, symmetric=True)
-    _fill_tril(gamma2, rng, symmetric=True)
-    _fill_tril(delta1, rng)
-    _fill_tril(delta2, rng)
-
-    # For large num_qubits numpy.inv function called below can
-    # return invalid output leading to a non-symplectic Clifford
-    # being generated. This can be prevented by manually forcing
-    # block inversion of the matrix.
-    block_inverse_threshold = 50
-
-    # Compute stabilizer table
-    zero = np.zeros((num_qubits, num_qubits), dtype=np.int8)
-    prod1 = np.matmul(gamma1, delta1) % 2
-    prod2 = np.matmul(gamma2, delta2) % 2
-    inv1 = _inverse_tril(delta1, block_inverse_threshold).transpose()
-    inv2 = _inverse_tril(delta2, block_inverse_threshold).transpose()
-    table1 = np.block([[delta1, zero], [prod1, inv1]])
-    table2 = np.block([[delta2, zero], [prod2, inv2]])
-
-    # Apply qubit permutation
-    table = table2[np.concatenate([perm, num_qubits + perm])]
-
-    # Apply layer of Hadamards
-    inds = had * np.arange(1, num_qubits + 1)
-    inds = inds[inds > 0] - 1
-    lhs_inds = np.concatenate([inds, inds + num_qubits])
-    rhs_inds = np.concatenate([inds + num_qubits, inds])
-    table[lhs_inds, :] = table[rhs_inds, :]
-
-    # Apply table
-    tableau = np.zeros((2 * num_qubits, 2 * num_qubits + 1), dtype=bool)
-    tableau[:, :-1] = np.mod(np.matmul(table1, table), 2)
-
-    # Generate random phases
-    tableau[:, -1] = rng.integers(2, size=2 * num_qubits)
+    seed = rng.integers(100000, size=1, dtype=np.uint64)[0]
+    tableau = random_clifford_tableau(num_qubits, seed=seed)
     return Clifford(tableau, validate=False)
-
-
-def _sample_qmallows(n, rng=None):
-    """Sample from the quantum Mallows distribution"""
-
-    if rng is None:
-        rng = np.random.default_rng()
-
-    # Hadamard layer
-    had = np.zeros(n, dtype=bool)
-
-    # Permutation layer
-    perm = np.zeros(n, dtype=int)
-
-    inds = list(range(n))
-    for i in range(n):
-        m = n - i
-        eps = 4 ** (-m)
-        r = rng.uniform(0, 1)
-        index = -math.ceil(math.log2(r + (1 - r) * eps))
-        had[i] = index < m
-        if index < m:
-            k = index
-        else:
-            k = 2 * m - index - 1
-        perm[i] = inds[k]
-        del inds[k]
-    return had, perm
-
-
-def _fill_tril(mat, rng, symmetric=False):
-    """Add symmetric random ints to off diagonals"""
-    dim = mat.shape[0]
-    # Optimized for low dimensions
-    if dim == 1:
-        return
-
-    if dim <= 4:
-        mat[1, 0] = rng.integers(2, dtype=np.int8)
-        if symmetric:
-            mat[0, 1] = mat[1, 0]
-        if dim > 2:
-            mat[2, 0] = rng.integers(2, dtype=np.int8)
-            mat[2, 1] = rng.integers(2, dtype=np.int8)
-            if symmetric:
-                mat[0, 2] = mat[2, 0]
-                mat[1, 2] = mat[2, 1]
-        if dim > 3:
-            mat[3, 0] = rng.integers(2, dtype=np.int8)
-            mat[3, 1] = rng.integers(2, dtype=np.int8)
-            mat[3, 2] = rng.integers(2, dtype=np.int8)
-            if symmetric:
-                mat[0, 3] = mat[3, 0]
-                mat[1, 3] = mat[3, 1]
-                mat[2, 3] = mat[3, 2]
-        return
-
-    # Use numpy indices for larger dimensions
-    rows, cols = np.tril_indices(dim, -1)
-    vals = rng.integers(2, size=rows.size, dtype=np.int8)
-    mat[(rows, cols)] = vals
-    if symmetric:
-        mat[(cols, rows)] = vals
-
-
-def _inverse_tril(mat, block_inverse_threshold):
-    """Invert a lower-triangular matrix with unit diagonal."""
-    # Optimized inversion function for low dimensions
-    dim = mat.shape[0]
-
-    if dim <= 2:
-        return mat
-
-    if dim <= 5:
-        inv = mat.copy()
-        inv[2, 0] = mat[2, 0] ^ (mat[1, 0] & mat[2, 1])
-        if dim > 3:
-            inv[3, 1] = mat[3, 1] ^ (mat[2, 1] & mat[3, 2])
-            inv[3, 0] = mat[3, 0] ^ (mat[3, 2] & mat[2, 0]) ^ (mat[1, 0] & inv[3, 1])
-        if dim > 4:
-            inv[4, 2] = (mat[4, 2] ^ (mat[3, 2] & mat[4, 3])) & 1
-            inv[4, 1] = mat[4, 1] ^ (mat[4, 3] & mat[3, 1]) ^ (mat[2, 1] & inv[4, 2])
-            inv[4, 0] = (
-                mat[4, 0]
-                ^ (mat[1, 0] & inv[4, 1])
-                ^ (mat[2, 0] & inv[4, 2])
-                ^ (mat[3, 0] & mat[4, 3])
-            )
-        return inv % 2
-
-    # For higher dimensions we use Numpy's inverse function
-    # however this function tends to fail and result in a non-symplectic
-    # final matrix if n is too large.
-    if dim <= block_inverse_threshold:
-        return np.linalg.inv(mat).astype(np.int8) % 2
-
-    # For very large matrices  we divide the matrix into 4 blocks of
-    # roughly equal size and use the analytic formula for the inverse
-    # of a block lower-triangular matrix:
-    # inv([[A, 0],[C, D]]) = [[inv(A), 0], [inv(D).C.inv(A), inv(D)]]
-    # call the inverse function recursively to compute inv(A) and invD
-
-    dim1 = dim // 2
-    mat_a = _inverse_tril(mat[0:dim1, 0:dim1], block_inverse_threshold)
-    mat_d = _inverse_tril(mat[dim1:dim, dim1:dim], block_inverse_threshold)
-    mat_c = np.matmul(np.matmul(mat_d, mat[dim1:dim, 0:dim1]), mat_a)
-    inv = np.block([[mat_a, np.zeros((dim1, dim - dim1), dtype=int)], [mat_c, mat_d]])
-    return inv % 2
diff --git a/releasenotes/notes/oxidize-random-clifford-934f45876c14c8a0.yaml b/releasenotes/notes/oxidize-random-clifford-934f45876c14c8a0.yaml
new file mode 100644
index 000000000000..236ad441992d
--- /dev/null
+++ b/releasenotes/notes/oxidize-random-clifford-934f45876c14c8a0.yaml
@@ -0,0 +1,5 @@
+---
+features_synthesis:
+  - |
+    The function :func:`~qiskit.quantum_info.random_clifford` was ported to Rust,
+    improving the runtime by a factor of 3.
diff --git a/test/python/quantum_info/operators/symplectic/test_clifford.py b/test/python/quantum_info/operators/symplectic/test_clifford.py
index 36d716d2d85a..061348c78cdb 100644
--- a/test/python/quantum_info/operators/symplectic/test_clifford.py
+++ b/test/python/quantum_info/operators/symplectic/test_clifford.py
@@ -492,8 +492,8 @@ def test_from_circuit_with_all_types(self):
 
         # Additionally, make sure that it produces the correct clifford.
         expected_clifford_dict = {
-            "stabilizer": ["-IZX", "+ZYZ", "+ZII"],
-            "destabilizer": ["+ZIZ", "+ZXZ", "-XIX"],
+            "stabilizer": ["-IZX", "+XXZ", "-YYZ"],
+            "destabilizer": ["-YYI", "-XZI", "-ZXY"],
         }
         expected_clifford = Clifford.from_dict(expected_clifford_dict)
         self.assertEqual(combined_clifford, expected_clifford)

From b501db1e218817abc353f150011b4f2e79e53b1f Mon Sep 17 00:00:00 2001
From: tglanz <talglanzman@gmail.com>
Date: Tue, 3 Sep 2024 16:35:31 +0300
Subject: [PATCH 40/85] skip test unless HAS_PIL (#13077)

---
 test/python/visualization/test_dag_drawer.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/python/visualization/test_dag_drawer.py b/test/python/visualization/test_dag_drawer.py
index d789b1e70682..56138c12cf00 100644
--- a/test/python/visualization/test_dag_drawer.py
+++ b/test/python/visualization/test_dag_drawer.py
@@ -46,6 +46,7 @@ def test_dag_drawer_invalid_style(self):
             dag_drawer(self.dag, style="multicolor")
 
     @unittest.skipUnless(_optionals.HAS_GRAPHVIZ, "Graphviz not installed")
+    @unittest.skipUnless(_optionals.HAS_PIL, "PIL not installed")
     def test_dag_drawer_checks_filename_correct_format(self):
         """filename must contain name and extension"""
         with self.assertRaisesRegex(

From df0ad77fd592aae2ad071bcd9160b181b915172d Mon Sep 17 00:00:00 2001
From: Sebastian Brandhofer <148463728+sbrandhsn@users.noreply.github.com>
Date: Tue, 3 Sep 2024 15:37:57 +0200
Subject: [PATCH 41/85] Oxidize commutation checker (#12870)

* init

* up

* lint

* .

* up

* before cache

* with cache

* correct

* cleaned up

* lint reno

* Update Cargo.lock

* .

* up

* .

* revert op

* .

* .

* .

* .

* Delete Cargo.lock

* .

* corrected string comparison

* removed Operator class from operation.rs

* .

* Apply suggestions from code review

Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>

* comments from code review

* Apply suggestions from code review

Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>

* code review

* remove with_gil in favor of passing python tokens as params

* Apply suggestions from code review

Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>

* fmt

* python serialization

* deprecation

* Update commutation_checker.py

* heh

* let Pytuple collect

* lint

* First set of comments

- use Qubit/Clbit
- more info on unsafe
- update reno
- use LazySet less
- use OperationRef, avoid CircuitInstruction creation

* Second part

- clippy
- no BigInt
- more comments

* Matrix speed & fix string sort

-- could not use op.name() directly since sorted differently than Python, hence it's back to BigInt

* have the Python implementation use Rust

* lint & tools

* remove unsafe blocks

* One more try to avoid segfaulty windows

-- if that doesn't work maybe revert the change the the Py CommChecker uses Rust

* Debug: disable cache

trying to figure out why the windows CI fails (after being unable to locally reproduce we're using CI with a reduced set of tests)

* ... second try

* Update crates/accelerate/src/commutation_checker.rs

Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>

* Restore azure config

* Remove unused import

* Revert "Debug: disable cache"

This reverts commit c564b806c9ff31d5faa6aa3f02c18cfe6a5ff2c5.

* Don't overallocate cache

We were allocating a the cache hashmap with a capacity for max cache
size entries every time we instantiated a new CommutationChecker. The
max cache size is 1 million. This meant we were allocating 162MB
everytime CommutationChecker.__new__ was called, which includes each
time we instantiate it manually (which happens once on import), the
CommutationAnalysis pass gets instantiated (twice per preset pass
manager created with level 2 or 3), or a commutation checker instance is
pickle deserialized. This ends up causing a fairly large memory
regression and is the source of the CI failures on windows.

Co-authored-by: Jake Lishman <jake.lishman@ibm.com>

* Cleanup parameter key type to handle edge conditions better

This commit cleans up the ParameterKey type and usage to make it handle
edge conditions better. The first is that the type just doesn't do the
right thing for NaN, -0, or the infinities. Canonicalization is added
for hash on -0 and the only constructor of the newtype adds a runtime
guard against NaN and inifinity (positive or negative) to avoid that
issue. The approach only makes sense as the cache is really there to
guard us against unnecessary re-computing when we reiterate over the
circuit > 1 time and nothing has changed for gates. Otherwise comparing
floats like done in this PR does would not be a sound or an effective
approach.

* Remove unnecessary cache hit rate tracking

* Undo test assertion changes

* Undo unrelated test changes

* Undo pending deprecation and unify commutation classes

This commit removes the pending deprecation decorator from the python
class definition as the Python class just internally is using the rust
implementation now. This also removes directly using the rust
implementation for the standard commutation library global as using the
python class is exactly the same now.

We can revisit if there is anything we want to deprecate and remove in
2.0 in a follow up PR. Personally, I think the cache management methods
are all we really want to remove as the cache should be an internal
implementation detail and not part of the public interface.

* Undo gha config changes

* Make serialization explicit

This commit makes the pickling of cache entries explicit. Previously it
was relying on conversion traits which hid some of the complexity but
this uses a pair of conversion functions instead.

* Remove stray SAFETY comment

* Remove ddt usage from the tests

Now that the python commutation checker and the rust commutation checker
are the same thing the ddt parameterization of the commutation checker
tests was unecessary duplication. This commit removes the ddt usage to
restore having a single run of all the tests.

* Update release note

* Fix CommutationChecker class import

* Remove invalid test assertion for no longer public attribute

* Ray's review comments

Co-authored-by: Raynel Sanchez <raynelfss@hotmail.com>

* Handle ``atol/rtol``, more error propagation

* re-use expensive quantities

such as the relative placement and the parameter hash

---------

Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>
Co-authored-by: Matthew Treinish <mtreinish@kortar.org>
Co-authored-by: Julien Gacon <jules.gacon@googlemail.com>
Co-authored-by: Jake Lishman <jake.lishman@ibm.com>
Co-authored-by: Raynel Sanchez <raynelfss@hotmail.com>
---
 Cargo.lock                                    |  74 +-
 crates/accelerate/Cargo.toml                  |   2 +
 crates/accelerate/src/commutation_checker.rs  | 775 ++++++++++++++++++
 crates/accelerate/src/lib.rs                  |   2 +
 crates/accelerate/src/unitary_compose.rs      | 240 ++++++
 crates/pyext/src/lib.rs                       |  18 +-
 qiskit/__init__.py                            |   1 +
 qiskit/circuit/commutation_checker.py         | 396 +--------
 .../commutative_inverse_cancellation.py       |  13 +-
 ...-commutation-checker-c738e67efa9d292f.yaml |   6 +
 .../circuit/test_commutation_checker.py       | 309 +++----
 tools/build_standard_commutations.py          |  60 +-
 12 files changed, 1287 insertions(+), 609 deletions(-)
 create mode 100644 crates/accelerate/src/commutation_checker.rs
 create mode 100644 crates/accelerate/src/unitary_compose.rs
 create mode 100644 releasenotes/notes/rust-commutation-checker-c738e67efa9d292f.yaml

diff --git a/Cargo.lock b/Cargo.lock
index 10344e611726..7921b7aeba83 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -26,6 +26,15 @@ dependencies = [
  "zerocopy",
 ]
 
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "allocator-api2"
 version = "0.2.18"
@@ -41,6 +50,15 @@ dependencies = [
  "log",
 ]
 
+[[package]]
+name = "approx"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f2a05fd1bd10b2527e20a2cd32d8873d115b8b39fe219ee25f42a8aca6ba278"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "approx"
 version = "0.5.1"
@@ -629,6 +647,12 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b23360e99b8717f20aaa4598f5a6541efbe30630039fbc7706cf954a87947ae"
 
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
 [[package]]
 name = "libc"
 version = "0.2.154"
@@ -783,7 +807,8 @@ version = "0.15.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "adb12d4e967ec485a5f71c6311fe28158e9d6f4bc4a447b474184d0f91a8fa32"
 dependencies = [
- "approx",
+ "approx 0.4.0",
+ "approx 0.5.1",
  "matrixmultiply",
  "num-complex",
  "num-integer",
@@ -792,6 +817,18 @@ dependencies = [
  "rayon",
 ]
 
+[[package]]
+name = "ndarray_einsum_beta"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "668b3abeae3e0637740340e0e32a9bf9308380e146ea6797950f9ff16e88d88a"
+dependencies = [
+ "lazy_static",
+ "ndarray",
+ "num-traits",
+ "regex",
+]
+
 [[package]]
 name = "npyz"
 version = "0.8.3"
@@ -1180,17 +1217,19 @@ name = "qiskit-accelerate"
 version = "1.3.0"
 dependencies = [
  "ahash 0.8.11",
- "approx",
+ "approx 0.5.1",
  "faer",
  "faer-ext",
  "hashbrown 0.14.5",
  "indexmap",
  "itertools 0.13.0",
  "ndarray",
+ "ndarray_einsum_beta",
  "num-bigint",
  "num-complex",
  "num-traits",
  "numpy",
+ "once_cell",
  "pulp",
  "pyo3",
  "qiskit-circuit",
@@ -1208,7 +1247,7 @@ name = "qiskit-circuit"
 version = "1.3.0"
 dependencies = [
  "ahash 0.8.11",
- "approx",
+ "approx 0.5.1",
  "bytemuck",
  "hashbrown 0.14.5",
  "indexmap",
@@ -1394,6 +1433,35 @@ dependencies = [
  "bitflags 2.5.0",
 ]
 
+[[package]]
+name = "regex"
+version = "1.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4219d74c6b67a3654a9fbebc4b419e22126d13d2f3c4a07ee0cb61ff79a79619"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b"
+
 [[package]]
 name = "rowan"
 version = "0.15.15"
diff --git a/crates/accelerate/Cargo.toml b/crates/accelerate/Cargo.toml
index 3248e61e29ac..f444a5c8ed66 100644
--- a/crates/accelerate/Cargo.toml
+++ b/crates/accelerate/Cargo.toml
@@ -24,6 +24,8 @@ faer = "0.19.2"
 itertools.workspace = true
 qiskit-circuit.workspace = true
 thiserror.workspace = true
+ndarray_einsum_beta = "0.7"
+once_cell = "1.19.0"
 
 [dependencies.smallvec]
 workspace = true
diff --git a/crates/accelerate/src/commutation_checker.rs b/crates/accelerate/src/commutation_checker.rs
new file mode 100644
index 000000000000..6fd9d58a7c23
--- /dev/null
+++ b/crates/accelerate/src/commutation_checker.rs
@@ -0,0 +1,775 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// 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.
+
+use hashbrown::{HashMap, HashSet};
+use ndarray::linalg::kron;
+use ndarray::Array2;
+use num_complex::Complex64;
+use once_cell::sync::Lazy;
+use smallvec::SmallVec;
+
+use numpy::PyReadonlyArray2;
+use pyo3::exceptions::PyRuntimeError;
+use pyo3::intern;
+use pyo3::prelude::*;
+use pyo3::types::{IntoPyDict, PyBool, PyDict, PySequence, PyTuple};
+
+use qiskit_circuit::bit_data::BitData;
+use qiskit_circuit::circuit_instruction::{ExtraInstructionAttributes, OperationFromPython};
+use qiskit_circuit::dag_node::DAGOpNode;
+use qiskit_circuit::imports::QI_OPERATOR;
+use qiskit_circuit::operations::OperationRef::{Gate as PyGateType, Operation as PyOperationType};
+use qiskit_circuit::operations::{Operation, OperationRef, Param};
+use qiskit_circuit::{BitType, Clbit, Qubit};
+
+use crate::unitary_compose;
+use crate::QiskitError;
+
+static SKIPPED_NAMES: [&str; 4] = ["measure", "reset", "delay", "initialize"];
+static NO_CACHE_NAMES: [&str; 2] = ["annotated", "linear_function"];
+static SUPPORTED_OP: Lazy<HashSet<&str>> = Lazy::new(|| {
+    HashSet::from([
+        "h", "x", "y", "z", "sx", "sxdg", "t", "tdg", "s", "sdg", "cx", "cy", "cz", "swap",
+        "iswap", "ecr", "ccx", "cswap",
+    ])
+});
+
+fn get_bits<T>(
+    py: Python,
+    bits1: &Bound<PyTuple>,
+    bits2: &Bound<PyTuple>,
+) -> PyResult<(Vec<T>, Vec<T>)>
+where
+    T: From<BitType> + Copy,
+    BitType: From<T>,
+{
+    let mut bitdata: BitData<T> = BitData::new(py, "bits".to_string());
+
+    for bit in bits1.iter().chain(bits2.iter()) {
+        bitdata.add(py, &bit, false)?;
+    }
+
+    Ok((
+        bitdata.map_bits(bits1)?.collect(),
+        bitdata.map_bits(bits2)?.collect(),
+    ))
+}
+
+/// This is the internal structure for the Python CommutationChecker class
+/// It handles the actual commutation checking, cache management, and library
+/// lookups. It's not meant to be a public facing Python object though and only used
+/// internally by the Python class.
+#[pyclass(module = "qiskit._accelerate.commutation_checker")]
+struct CommutationChecker {
+    library: CommutationLibrary,
+    cache_max_entries: usize,
+    cache: HashMap<(String, String), CommutationCacheEntry>,
+    current_cache_entries: usize,
+    #[pyo3(get)]
+    gates: Option<HashSet<String>>,
+}
+
+#[pymethods]
+impl CommutationChecker {
+    #[pyo3(signature = (standard_gate_commutations=None, cache_max_entries=1_000_000, gates=None))]
+    #[new]
+    fn py_new(
+        standard_gate_commutations: Option<Bound<PyAny>>,
+        cache_max_entries: usize,
+        gates: Option<HashSet<String>>,
+    ) -> Self {
+        // Initialize sets before they are used in the commutation checker
+        Lazy::force(&SUPPORTED_OP);
+        CommutationChecker {
+            library: CommutationLibrary::new(standard_gate_commutations),
+            cache: HashMap::new(),
+            cache_max_entries,
+            current_cache_entries: 0,
+            gates,
+        }
+    }
+
+    #[pyo3(signature=(op1, op2, max_num_qubits=3))]
+    fn commute_nodes(
+        &mut self,
+        py: Python,
+        op1: &DAGOpNode,
+        op2: &DAGOpNode,
+        max_num_qubits: u32,
+    ) -> PyResult<bool> {
+        let (qargs1, qargs2) = get_bits::<Qubit>(
+            py,
+            op1.instruction.qubits.bind(py),
+            op2.instruction.qubits.bind(py),
+        )?;
+        let (cargs1, cargs2) = get_bits::<Clbit>(
+            py,
+            op1.instruction.clbits.bind(py),
+            op2.instruction.clbits.bind(py),
+        )?;
+
+        self.commute_inner(
+            py,
+            &op1.instruction.operation.view(),
+            &op1.instruction.params,
+            op1.instruction.extra_attrs.as_deref(),
+            &qargs1,
+            &cargs1,
+            &op2.instruction.operation.view(),
+            &op2.instruction.params,
+            op2.instruction.extra_attrs.as_deref(),
+            &qargs2,
+            &cargs2,
+            max_num_qubits,
+        )
+    }
+
+    #[pyo3(signature=(op1, qargs1, cargs1, op2, qargs2, cargs2, max_num_qubits=3))]
+    #[allow(clippy::too_many_arguments)]
+    fn commute(
+        &mut self,
+        py: Python,
+        op1: OperationFromPython,
+        qargs1: Option<&Bound<PySequence>>,
+        cargs1: Option<&Bound<PySequence>>,
+        op2: OperationFromPython,
+        qargs2: Option<&Bound<PySequence>>,
+        cargs2: Option<&Bound<PySequence>>,
+        max_num_qubits: u32,
+    ) -> PyResult<bool> {
+        let qargs1 =
+            qargs1.map_or_else(|| Ok(PyTuple::empty_bound(py)), PySequenceMethods::to_tuple)?;
+        let cargs1 =
+            cargs1.map_or_else(|| Ok(PyTuple::empty_bound(py)), PySequenceMethods::to_tuple)?;
+        let qargs2 =
+            qargs2.map_or_else(|| Ok(PyTuple::empty_bound(py)), PySequenceMethods::to_tuple)?;
+        let cargs2 =
+            cargs2.map_or_else(|| Ok(PyTuple::empty_bound(py)), PySequenceMethods::to_tuple)?;
+
+        let (qargs1, qargs2) = get_bits::<Qubit>(py, &qargs1, &qargs2)?;
+        let (cargs1, cargs2) = get_bits::<Clbit>(py, &cargs1, &cargs2)?;
+
+        self.commute_inner(
+            py,
+            &op1.operation.view(),
+            &op1.params,
+            op1.extra_attrs.as_deref(),
+            &qargs1,
+            &cargs1,
+            &op2.operation.view(),
+            &op2.params,
+            op2.extra_attrs.as_deref(),
+            &qargs2,
+            &cargs2,
+            max_num_qubits,
+        )
+    }
+
+    /// Return the current number of cache entries
+    fn num_cached_entries(&self) -> usize {
+        self.current_cache_entries
+    }
+
+    /// Clear the cache
+    fn clear_cached_commutations(&mut self) {
+        self.clear_cache()
+    }
+
+    fn __getstate__(&self, py: Python) -> PyResult<Py<PyDict>> {
+        let out_dict = PyDict::new_bound(py);
+        out_dict.set_item("cache_max_entries", self.cache_max_entries)?;
+        out_dict.set_item("current_cache_entries", self.current_cache_entries)?;
+        let cache_dict = PyDict::new_bound(py);
+        for (key, value) in &self.cache {
+            cache_dict.set_item(key, commutation_entry_to_pydict(py, value)?)?;
+        }
+        out_dict.set_item("cache", cache_dict)?;
+        out_dict.set_item("library", self.library.library.to_object(py))?;
+        out_dict.set_item("gates", self.gates.clone())?;
+        Ok(out_dict.unbind())
+    }
+
+    fn __setstate__(&mut self, py: Python, state: PyObject) -> PyResult<()> {
+        let dict_state = state.downcast_bound::<PyDict>(py)?;
+        self.cache_max_entries = dict_state
+            .get_item("cache_max_entries")?
+            .unwrap()
+            .extract()?;
+        self.current_cache_entries = dict_state
+            .get_item("current_cache_entries")?
+            .unwrap()
+            .extract()?;
+        self.library = CommutationLibrary {
+            library: dict_state.get_item("library")?.unwrap().extract()?,
+        };
+        let raw_cache: Bound<PyDict> = dict_state.get_item("cache")?.unwrap().extract()?;
+        self.cache = HashMap::with_capacity(raw_cache.len());
+        for (key, value) in raw_cache.iter() {
+            let value_dict: &Bound<PyDict> = value.downcast()?;
+            self.cache.insert(
+                key.extract()?,
+                commutation_cache_entry_from_pydict(value_dict)?,
+            );
+        }
+        self.gates = dict_state.get_item("gates")?.unwrap().extract()?;
+        Ok(())
+    }
+}
+
+impl CommutationChecker {
+    #[allow(clippy::too_many_arguments)]
+    fn commute_inner(
+        &mut self,
+        py: Python,
+        op1: &OperationRef,
+        params1: &[Param],
+        attrs1: Option<&ExtraInstructionAttributes>,
+        qargs1: &[Qubit],
+        cargs1: &[Clbit],
+        op2: &OperationRef,
+        params2: &[Param],
+        attrs2: Option<&ExtraInstructionAttributes>,
+        qargs2: &[Qubit],
+        cargs2: &[Clbit],
+        max_num_qubits: u32,
+    ) -> PyResult<bool> {
+        if let Some(gates) = &self.gates {
+            if !gates.is_empty() && (!gates.contains(op1.name()) || !gates.contains(op2.name())) {
+                return Ok(false);
+            }
+        }
+
+        let commutation: Option<bool> = commutation_precheck(
+            op1,
+            params1,
+            attrs1,
+            qargs1,
+            cargs1,
+            op2,
+            params2,
+            attrs2,
+            qargs2,
+            cargs2,
+            max_num_qubits,
+        );
+        if let Some(is_commuting) = commutation {
+            return Ok(is_commuting);
+        }
+
+        let reversed = if op1.num_qubits() != op2.num_qubits() {
+            op1.num_qubits() > op2.num_qubits()
+        } else {
+            (op1.name().len(), op1.name()) >= (op2.name().len(), op2.name())
+        };
+        let (first_params, second_params) = if reversed {
+            (params2, params1)
+        } else {
+            (params1, params2)
+        };
+        let (first_op, second_op) = if reversed { (op2, op1) } else { (op1, op2) };
+        let (first_qargs, second_qargs) = if reversed {
+            (qargs2, qargs1)
+        } else {
+            (qargs1, qargs2)
+        };
+
+        let skip_cache: bool = NO_CACHE_NAMES.contains(&first_op.name()) ||
+            NO_CACHE_NAMES.contains(&second_op.name()) ||
+            // Skip params that do not evaluate to floats for caching and commutation library
+            first_params.iter().any(|p| !matches!(p, Param::Float(_))) ||
+            second_params.iter().any(|p| !matches!(p, Param::Float(_)));
+
+        if skip_cache {
+            return self.commute_matmul(
+                py,
+                first_op,
+                first_params,
+                first_qargs,
+                second_op,
+                second_params,
+                second_qargs,
+            );
+        }
+
+        // Query commutation library
+        let relative_placement = get_relative_placement(first_qargs, second_qargs);
+        if let Some(is_commuting) =
+            self.library
+                .check_commutation_entries(first_op, second_op, &relative_placement)
+        {
+            return Ok(is_commuting);
+        }
+
+        // Query cache
+        let key1 = hashable_params(first_params)?;
+        let key2 = hashable_params(second_params)?;
+        if let Some(commutation_dict) = self
+            .cache
+            .get(&(first_op.name().to_string(), second_op.name().to_string()))
+        {
+            let hashes = (key1.clone(), key2.clone());
+            if let Some(commutation) = commutation_dict.get(&(relative_placement.clone(), hashes)) {
+                return Ok(*commutation);
+            }
+        }
+
+        // Perform matrix multiplication to determine commutation
+        let is_commuting = self.commute_matmul(
+            py,
+            first_op,
+            first_params,
+            first_qargs,
+            second_op,
+            second_params,
+            second_qargs,
+        )?;
+
+        // TODO: implement a LRU cache for this
+        if self.current_cache_entries >= self.cache_max_entries {
+            self.clear_cache();
+        }
+        // Cache results from is_commuting
+        self.cache
+            .entry((first_op.name().to_string(), second_op.name().to_string()))
+            .and_modify(|entries| {
+                let key = (relative_placement.clone(), (key1.clone(), key2.clone()));
+                entries.insert(key, is_commuting);
+                self.current_cache_entries += 1;
+            })
+            .or_insert_with(|| {
+                let mut entries = HashMap::with_capacity(1);
+                let key = (relative_placement, (key1, key2));
+                entries.insert(key, is_commuting);
+                self.current_cache_entries += 1;
+                entries
+            });
+        Ok(is_commuting)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn commute_matmul(
+        &self,
+        py: Python,
+        first_op: &OperationRef,
+        first_params: &[Param],
+        first_qargs: &[Qubit],
+        second_op: &OperationRef,
+        second_params: &[Param],
+        second_qargs: &[Qubit],
+    ) -> PyResult<bool> {
+        // Compute relative positioning of qargs of the second gate to the first gate.
+        // Since the qargs come out the same BitData, we already know there are no accidential
+        // bit-duplications, but this code additionally maps first_qargs to [0..n] and then
+        // computes second_qargs relative to that. For example, it performs the mappings
+        //  (first_qargs, second_qargs) = ( [1, 2], [0, 2] ) --> ( [0, 1], [2, 1] )
+        //  (first_qargs, second_qargs) = ( [1, 2, 0], [0, 3, 4] ) --> ( [0, 1, 2], [2, 3, 4] )
+        // This re-shuffling is done to compute the correct kronecker product later.
+        let mut qarg: HashMap<&Qubit, Qubit> = HashMap::from_iter(
+            first_qargs
+                .iter()
+                .enumerate()
+                .map(|(i, q)| (q, Qubit(i as u32))),
+        );
+        let mut num_qubits = first_qargs.len() as u32;
+        for q in second_qargs {
+            if !qarg.contains_key(q) {
+                qarg.insert(q, Qubit(num_qubits));
+                num_qubits += 1;
+            }
+        }
+
+        let first_qarg: Vec<Qubit> = Vec::from_iter((0..first_qargs.len() as u32).map(Qubit));
+        let second_qarg: Vec<Qubit> = second_qargs.iter().map(|q| qarg[q]).collect();
+
+        if first_qarg.len() > second_qarg.len() {
+            return Err(QiskitError::new_err(
+                "first instructions must have at most as many qubits as the second instruction",
+            ));
+        };
+        let first_mat = match get_matrix(py, first_op, first_params)? {
+            Some(matrix) => matrix,
+            None => return Ok(false),
+        };
+
+        let second_mat = match get_matrix(py, second_op, second_params)? {
+            Some(matrix) => matrix,
+            None => return Ok(false),
+        };
+
+        let rtol = 1e-5;
+        let atol = 1e-8;
+        if first_qarg == second_qarg {
+            match first_qarg.len() {
+                1 => Ok(unitary_compose::commute_1q(
+                    &first_mat.view(),
+                    &second_mat.view(),
+                    rtol,
+                    atol,
+                )),
+                2 => Ok(unitary_compose::commute_2q(
+                    &first_mat.view(),
+                    &second_mat.view(),
+                    &[Qubit(0), Qubit(1)],
+                    rtol,
+                    atol,
+                )),
+                _ => Ok(unitary_compose::allclose(
+                    &second_mat.dot(&first_mat).view(),
+                    &first_mat.dot(&second_mat).view(),
+                    rtol,
+                    atol,
+                )),
+            }
+        } else {
+            // TODO Optimize this bit to avoid unnecessary Kronecker products:
+            //  1. We currently sort the operations for the cache by operation size, putting the
+            //     *smaller* operation first: (smaller op, larger op)
+            //  2. This code here expands the first op to match the second -- hence we always
+            //     match the operator sizes.
+            // This whole extension logic could be avoided since we know the second one is larger.
+            let extra_qarg2 = num_qubits - first_qarg.len() as u32;
+            let first_mat = if extra_qarg2 > 0 {
+                let id_op = Array2::<Complex64>::eye(usize::pow(2, extra_qarg2));
+                kron(&id_op, &first_mat)
+            } else {
+                first_mat
+            };
+
+            // the 1 qubit case cannot happen, since that would already have been captured
+            // by the previous if clause; first_qarg == second_qarg (if they overlap they must
+            // be the same)
+            if num_qubits == 2 {
+                return Ok(unitary_compose::commute_2q(
+                    &first_mat.view(),
+                    &second_mat.view(),
+                    &second_qarg,
+                    rtol,
+                    atol,
+                ));
+            };
+
+            let op12 = match unitary_compose::compose(
+                &first_mat.view(),
+                &second_mat.view(),
+                &second_qarg,
+                false,
+            ) {
+                Ok(matrix) => matrix,
+                Err(e) => return Err(PyRuntimeError::new_err(e)),
+            };
+            let op21 = match unitary_compose::compose(
+                &first_mat.view(),
+                &second_mat.view(),
+                &second_qarg,
+                true,
+            ) {
+                Ok(matrix) => matrix,
+                Err(e) => return Err(PyRuntimeError::new_err(e)),
+            };
+            Ok(unitary_compose::allclose(
+                &op12.view(),
+                &op21.view(),
+                rtol,
+                atol,
+            ))
+        }
+    }
+
+    fn clear_cache(&mut self) {
+        self.cache.clear();
+        self.current_cache_entries = 0;
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn commutation_precheck(
+    op1: &OperationRef,
+    params1: &[Param],
+    attrs1: Option<&ExtraInstructionAttributes>,
+    qargs1: &[Qubit],
+    cargs1: &[Clbit],
+    op2: &OperationRef,
+    params2: &[Param],
+    attrs2: Option<&ExtraInstructionAttributes>,
+    qargs2: &[Qubit],
+    cargs2: &[Clbit],
+    max_num_qubits: u32,
+) -> Option<bool> {
+    if op1.control_flow()
+        || op2.control_flow()
+        || attrs1.is_some_and(|attr| attr.condition.is_some())
+        || attrs2.is_some_and(|attr| attr.condition.is_some())
+    {
+        return Some(false);
+    }
+
+    // assuming the number of involved qubits to be small, this might be faster than set operations
+    if !qargs1.iter().any(|e| qargs2.contains(e)) && !cargs1.iter().any(|e| cargs2.contains(e)) {
+        return Some(true);
+    }
+
+    if qargs1.len() > max_num_qubits as usize || qargs2.len() > max_num_qubits as usize {
+        return Some(false);
+    }
+
+    if SUPPORTED_OP.contains(op1.name()) && SUPPORTED_OP.contains(op2.name()) {
+        return None;
+    }
+
+    if is_commutation_skipped(op1, params1) || is_commutation_skipped(op2, params2) {
+        return Some(false);
+    }
+
+    None
+}
+
+fn get_matrix(
+    py: Python,
+    operation: &OperationRef,
+    params: &[Param],
+) -> PyResult<Option<Array2<Complex64>>> {
+    match operation.matrix(params) {
+        Some(matrix) => Ok(Some(matrix)),
+        None => match operation {
+            PyGateType(gate) => Ok(Some(matrix_via_operator(py, &gate.gate)?)),
+            PyOperationType(op) => Ok(Some(matrix_via_operator(py, &op.operation)?)),
+            _ => Ok(None),
+        },
+    }
+}
+
+fn matrix_via_operator(py: Python, py_obj: &PyObject) -> PyResult<Array2<Complex64>> {
+    Ok(QI_OPERATOR
+        .get_bound(py)
+        .call1((py_obj,))?
+        .getattr(intern!(py, "data"))?
+        .extract::<PyReadonlyArray2<Complex64>>()?
+        .as_array()
+        .to_owned())
+}
+
+fn is_commutation_skipped<T>(op: &T, params: &[Param]) -> bool
+where
+    T: Operation,
+{
+    op.directive()
+        || SKIPPED_NAMES.contains(&op.name())
+        || params
+            .iter()
+            .any(|x| matches!(x, Param::ParameterExpression(_)))
+}
+
+fn get_relative_placement(
+    first_qargs: &[Qubit],
+    second_qargs: &[Qubit],
+) -> SmallVec<[Option<Qubit>; 2]> {
+    let mut qubits_g2: HashMap<&Qubit, Qubit> = HashMap::with_capacity(second_qargs.len());
+    second_qargs.iter().enumerate().for_each(|(i_g1, q_g1)| {
+        qubits_g2.insert_unique_unchecked(q_g1, Qubit(i_g1 as u32));
+    });
+
+    first_qargs
+        .iter()
+        .map(|q_g0| qubits_g2.get(q_g0).copied())
+        .collect()
+}
+
+#[derive(Clone, Debug)]
+#[pyclass]
+pub struct CommutationLibrary {
+    pub library: Option<HashMap<(String, String), CommutationLibraryEntry>>,
+}
+
+impl CommutationLibrary {
+    fn check_commutation_entries(
+        &self,
+        first_op: &OperationRef,
+        second_op: &OperationRef,
+        relative_placement: &SmallVec<[Option<Qubit>; 2]>,
+    ) -> Option<bool> {
+        if let Some(library) = &self.library {
+            match library.get(&(first_op.name().to_string(), second_op.name().to_string())) {
+                Some(CommutationLibraryEntry::Commutes(b)) => Some(*b),
+                Some(CommutationLibraryEntry::QubitMapping(qm)) => {
+                    qm.get(relative_placement).copied()
+                }
+                _ => None,
+            }
+        } else {
+            None
+        }
+    }
+}
+
+#[pymethods]
+impl CommutationLibrary {
+    #[new]
+    fn new(py_any: Option<Bound<PyAny>>) -> Self {
+        match py_any {
+            Some(pyob) => CommutationLibrary {
+                library: pyob
+                    .extract::<HashMap<(String, String), CommutationLibraryEntry>>()
+                    .ok(),
+            },
+            None => CommutationLibrary {
+                library: Some(HashMap::new()),
+            },
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum CommutationLibraryEntry {
+    Commutes(bool),
+    QubitMapping(HashMap<SmallVec<[Option<Qubit>; 2]>, bool>),
+}
+
+impl<'py> FromPyObject<'py> for CommutationLibraryEntry {
+    fn extract_bound(b: &Bound<'py, PyAny>) -> Result<Self, PyErr> {
+        if let Ok(b) = b.extract::<bool>() {
+            return Ok(CommutationLibraryEntry::Commutes(b));
+        }
+        let dict = b.downcast::<PyDict>()?;
+        let mut ret = hashbrown::HashMap::with_capacity(dict.len());
+        for (k, v) in dict {
+            let raw_key: SmallVec<[Option<u32>; 2]> = k.extract()?;
+            let v: bool = v.extract()?;
+            let key = raw_key.into_iter().map(|key| key.map(Qubit)).collect();
+            ret.insert(key, v);
+        }
+        Ok(CommutationLibraryEntry::QubitMapping(ret))
+    }
+}
+
+impl ToPyObject for CommutationLibraryEntry {
+    fn to_object(&self, py: Python) -> PyObject {
+        match self {
+            CommutationLibraryEntry::Commutes(b) => b.into_py(py),
+            CommutationLibraryEntry::QubitMapping(qm) => qm
+                .iter()
+                .map(|(k, v)| {
+                    (
+                        PyTuple::new_bound(py, k.iter().map(|q| q.map(|t| t.0))),
+                        PyBool::new_bound(py, *v),
+                    )
+                })
+                .into_py_dict_bound(py)
+                .unbind()
+                .into(),
+        }
+    }
+}
+
+type CacheKey = (
+    SmallVec<[Option<Qubit>; 2]>,
+    (SmallVec<[ParameterKey; 3]>, SmallVec<[ParameterKey; 3]>),
+);
+
+type CommutationCacheEntry = HashMap<CacheKey, bool>;
+
+fn commutation_entry_to_pydict(py: Python, entry: &CommutationCacheEntry) -> PyResult<Py<PyDict>> {
+    let out_dict = PyDict::new_bound(py);
+    for (k, v) in entry.iter() {
+        let qubits = PyTuple::new_bound(py, k.0.iter().map(|q| q.map(|t| t.0)));
+        let params0 = PyTuple::new_bound(py, k.1 .0.iter().map(|pk| pk.0));
+        let params1 = PyTuple::new_bound(py, k.1 .1.iter().map(|pk| pk.0));
+        out_dict.set_item(
+            PyTuple::new_bound(py, [qubits, PyTuple::new_bound(py, [params0, params1])]),
+            PyBool::new_bound(py, *v),
+        )?;
+    }
+    Ok(out_dict.unbind())
+}
+
+fn commutation_cache_entry_from_pydict(dict: &Bound<PyDict>) -> PyResult<CommutationCacheEntry> {
+    let mut ret = hashbrown::HashMap::with_capacity(dict.len());
+    for (k, v) in dict {
+        let raw_key: CacheKeyRaw = k.extract()?;
+        let qubits = raw_key.0.iter().map(|q| q.map(Qubit)).collect();
+        let params0: SmallVec<_> = raw_key.1 .0;
+        let params1: SmallVec<_> = raw_key.1 .1;
+        let v: bool = v.extract()?;
+        ret.insert((qubits, (params0, params1)), v);
+    }
+    Ok(ret)
+}
+
+type CacheKeyRaw = (
+    SmallVec<[Option<u32>; 2]>,
+    (SmallVec<[ParameterKey; 3]>, SmallVec<[ParameterKey; 3]>),
+);
+
+/// This newtype wraps a f64 to make it hashable so we can cache parameterized gates
+/// based on the parameter value (assuming it's a float angle). However, Rust doesn't do
+/// this by default and there are edge cases to track around it's usage. The biggest one
+/// is this does not work with f64::NAN, f64::INFINITY, or f64::NEG_INFINITY
+/// If you try to use these values with this type they will not work as expected.
+/// This should only be used with the cache hashmap's keys and not used beyond that.
+#[derive(Debug, Copy, Clone, PartialEq, FromPyObject)]
+struct ParameterKey(f64);
+
+impl ParameterKey {
+    fn key(&self) -> u64 {
+        // If we get a -0 the to_bits() return is not equivalent to 0
+        // because -0 has the sign bit set we'd be hashing 9223372036854775808
+        // and be storing it separately from 0. So this normalizes all 0s to
+        // be represented by 0
+        if self.0 == 0. {
+            0
+        } else {
+            self.0.to_bits()
+        }
+    }
+}
+
+impl std::hash::Hash for ParameterKey {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: std::hash::Hasher,
+    {
+        self.key().hash(state)
+    }
+}
+
+impl Eq for ParameterKey {}
+
+fn hashable_params(params: &[Param]) -> PyResult<SmallVec<[ParameterKey; 3]>> {
+    params
+        .iter()
+        .map(|x| {
+            if let Param::Float(x) = x {
+                // NaN and Infinity (negative or positive) are not valid
+                // parameter values and our hacks to store parameters in
+                // the cache HashMap don't take these into account. So return
+                // an error to Python if we encounter these values.
+                if x.is_nan() || x.is_infinite() {
+                    Err(PyRuntimeError::new_err(
+                        "Can't hash parameters that are infinite or NaN",
+                    ))
+                } else {
+                    Ok(ParameterKey(*x))
+                }
+            } else {
+                Err(QiskitError::new_err(
+                    "Unable to hash a non-float instruction parameter.",
+                ))
+            }
+        })
+        .collect()
+}
+
+#[pymodule]
+pub fn commutation_checker(m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_class::<CommutationLibrary>()?;
+    m.add_class::<CommutationChecker>()?;
+    Ok(())
+}
diff --git a/crates/accelerate/src/lib.rs b/crates/accelerate/src/lib.rs
index 5414183d22cc..3a8c4bf51071 100644
--- a/crates/accelerate/src/lib.rs
+++ b/crates/accelerate/src/lib.rs
@@ -15,6 +15,7 @@ use std::env;
 use pyo3::import_exception;
 
 pub mod circuit_library;
+pub mod commutation_checker;
 pub mod convert_2q_block_matrix;
 pub mod dense_layout;
 pub mod edge_collections;
@@ -40,6 +41,7 @@ pub mod vf2_layout;
 mod rayon_ext;
 #[cfg(test)]
 mod test;
+mod unitary_compose;
 
 #[inline]
 pub fn getenv_use_multiple_threads() -> bool {
diff --git a/crates/accelerate/src/unitary_compose.rs b/crates/accelerate/src/unitary_compose.rs
new file mode 100644
index 000000000000..b40f6c3eb564
--- /dev/null
+++ b/crates/accelerate/src/unitary_compose.rs
@@ -0,0 +1,240 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// 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.
+
+use ndarray::{Array, Array2, ArrayView, ArrayView2, IxDyn};
+use ndarray_einsum_beta::*;
+use num_complex::{Complex, Complex64, ComplexFloat};
+use num_traits::Zero;
+use qiskit_circuit::Qubit;
+
+static LOWERCASE: [u8; 26] = [
+    b'a', b'b', b'c', b'd', b'e', b'f', b'g', b'h', b'i', b'j', b'k', b'l', b'm', b'n', b'o', b'p',
+    b'q', b'r', b's', b't', b'u', b'v', b'w', b'x', b'y', b'z',
+];
+
+static _UPPERCASE: [u8; 26] = [
+    b'A', b'B', b'C', b'D', b'E', b'F', b'G', b'H', b'I', b'J', b'K', b'L', b'M', b'N', b'O', b'P',
+    b'Q', b'R', b'S', b'T', b'U', b'V', b'W', b'X', b'Y', b'Z',
+];
+
+// Compose the operators given by `gate_unitary` and `overall_unitary`, i.e. apply one to the other
+// as specified by the involved qubits given in `qubits` and the `front` parameter
+pub fn compose(
+    gate_unitary: &ArrayView2<Complex64>,
+    overall_unitary: &ArrayView2<Complex64>,
+    qubits: &[Qubit],
+    front: bool,
+) -> Result<Array2<Complex64>, &'static str> {
+    let gate_qubits = gate_unitary.shape()[0].ilog2() as usize;
+
+    // Full composition of operators
+    if qubits.is_empty() {
+        if front {
+            return Ok(gate_unitary.dot(overall_unitary));
+        } else {
+            return Ok(overall_unitary.dot(gate_unitary));
+        }
+    }
+    // Compose with other on subsystem
+    let num_indices = gate_qubits;
+    let shift = if front { gate_qubits } else { 0usize };
+    let right_mul = front;
+
+    //Reshape current matrix
+    //Note that we must reverse the subsystem dimension order as
+    //qubit 0 corresponds to the right-most position in the tensor
+    //product, which is the last tensor wire index.
+    let tensor = per_qubit_shaped(gate_unitary);
+    let mat = per_qubit_shaped(overall_unitary);
+    let indices = qubits
+        .iter()
+        .map(|q| num_indices - 1 - q.0 as usize)
+        .collect::<Vec<usize>>();
+    let num_rows = usize::pow(2, num_indices as u32);
+
+    let res = _einsum_matmul(&tensor, &mat, &indices, shift, right_mul)?
+        .as_standard_layout()
+        .into_shape((num_rows, num_rows))
+        .unwrap()
+        .into_dimensionality::<ndarray::Ix2>()
+        .unwrap()
+        .to_owned();
+    Ok(res)
+}
+
+// Reshape an input matrix to (2, 2, ..., 2) depending on its dimensionality
+fn per_qubit_shaped<'a>(array: &ArrayView2<'a, Complex<f64>>) -> ArrayView<'a, Complex64, IxDyn> {
+    let overall_shape = (0..array.shape()[0].ilog2() as usize)
+        .flat_map(|_| [2, 2])
+        .collect::<Vec<usize>>();
+    array.into_shape(overall_shape).unwrap()
+}
+
+// Determine einsum strings for perform a matrix multiplication on the input matrices
+fn _einsum_matmul(
+    tensor: &ArrayView<Complex64, IxDyn>,
+    mat: &ArrayView<Complex64, IxDyn>,
+    indices: &[usize],
+    shift: usize,
+    right_mul: bool,
+) -> Result<Array<Complex64, IxDyn>, &'static str> {
+    let rank = tensor.ndim();
+    let rank_mat = mat.ndim();
+    if rank_mat % 2 != 0 {
+        return Err("Contracted matrix must have an even number of indices.");
+    }
+    // Get einsum indices for tensor
+    let mut indices_tensor = (0..rank).collect::<Vec<usize>>();
+    for (j, index) in indices.iter().enumerate() {
+        indices_tensor[index + shift] = rank + j;
+    }
+    // Get einsum indices for mat
+    let mat_contract = (rank..rank + indices.len()).rev().collect::<Vec<usize>>();
+    let mat_free = indices
+        .iter()
+        .rev()
+        .map(|index| index + shift)
+        .collect::<Vec<usize>>();
+    let indices_mat = if right_mul {
+        [mat_contract, mat_free].concat()
+    } else {
+        [mat_free, mat_contract].concat()
+    };
+
+    let tensor_einsum = unsafe {
+        String::from_utf8_unchecked(indices_tensor.iter().map(|c| LOWERCASE[*c]).collect())
+    };
+    let mat_einsum =
+        unsafe { String::from_utf8_unchecked(indices_mat.iter().map(|c| LOWERCASE[*c]).collect()) };
+
+    einsum(
+        format!("{},{}", tensor_einsum, mat_einsum).as_str(),
+        &[tensor, mat],
+    )
+}
+
+fn _einsum_matmul_helper(qubits: &[u32], num_qubits: usize) -> [String; 4] {
+    let tens_in: Vec<u8> = LOWERCASE[..num_qubits].to_vec();
+    let mut tens_out: Vec<u8> = tens_in.clone();
+    let mut mat_l: Vec<u8> = Vec::with_capacity(num_qubits);
+    let mut mat_r: Vec<u8> = Vec::with_capacity(num_qubits);
+    qubits.iter().rev().enumerate().for_each(|(pos, idx)| {
+        mat_r.push(tens_in[num_qubits - 1 - pos]);
+        mat_l.push(LOWERCASE[25 - pos]);
+        tens_out[num_qubits - 1 - *idx as usize] = LOWERCASE[25 - pos];
+    });
+    unsafe {
+        [
+            String::from_utf8_unchecked(mat_l),
+            String::from_utf8_unchecked(mat_r),
+            String::from_utf8_unchecked(tens_in),
+            String::from_utf8_unchecked(tens_out),
+        ]
+    }
+}
+
+fn _einsum_matmul_index(qubits: &[u32], num_qubits: usize) -> String {
+    assert!(num_qubits > 26, "Can't compute unitary of > 26 qubits");
+
+    let tens_r = unsafe { String::from_utf8_unchecked(_UPPERCASE[..num_qubits].to_vec()) };
+    let [mat_l, mat_r, tens_lin, tens_lout] = _einsum_matmul_helper(qubits, num_qubits);
+    format!(
+        "{}{}, {}{}->{}{}",
+        mat_l, mat_r, tens_lin, tens_r, tens_lout, tens_r
+    )
+}
+
+pub fn commute_1q(
+    left: &ArrayView2<Complex64>,
+    right: &ArrayView2<Complex64>,
+    rtol: f64,
+    atol: f64,
+) -> bool {
+    // This could allow for explicit hardcoded formulas, using less FLOPS, if we only
+    // consider an absolute tolerance. But for backward compatibility we now implement the full
+    // formula including relative tolerance handling.
+    for i in 0..2usize {
+        for j in 0..2usize {
+            let mut ab = Complex64::zero();
+            let mut ba = Complex64::zero();
+            for k in 0..2usize {
+                ab += left[[i, k]] * right[[k, j]];
+                ba += right[[i, k]] * left[[k, j]];
+            }
+            let sum = ab - ba;
+            if sum.abs() > atol + ba.abs() * rtol {
+                return false;
+            }
+        }
+    }
+    true
+}
+
+pub fn commute_2q(
+    left: &ArrayView2<Complex64>,
+    right: &ArrayView2<Complex64>,
+    qargs: &[Qubit],
+    rtol: f64,
+    atol: f64,
+) -> bool {
+    let rev = qargs[0].0 == 1;
+    for i in 0..4usize {
+        for j in 0..4usize {
+            // We compute AB and BA separately, to enable checking the relative difference
+            // (AB - BA)_ij > atol + rtol * BA_ij. This is due to backward compatibility and could
+            // maybe be changed in the future to save one complex number allocation.
+            let mut ab = Complex64::zero();
+            let mut ba = Complex64::zero();
+            for k in 0..4usize {
+                ab += left[[_ind(i, rev), _ind(k, rev)]] * right[[k, j]];
+                ba += right[[i, k]] * left[[_ind(k, rev), _ind(j, rev)]];
+            }
+            let sum = ab - ba;
+            if sum.abs() > atol + ba.abs() * rtol {
+                return false;
+            }
+        }
+    }
+    true
+}
+
+#[inline]
+fn _ind(i: usize, reversed: bool) -> usize {
+    if reversed {
+        // reverse the first two bits
+        ((i & 1) << 1) + ((i & 2) >> 1)
+    } else {
+        i
+    }
+}
+
+/// For equally sized matrices, ``left`` and ``right``, check whether all entries are close
+/// by the criterion
+///     
+///     |left_ij - right_ij| <= atol + rtol * right_ij
+///
+/// This is analogous to NumPy's ``allclose`` function.
+pub fn allclose(
+    left: &ArrayView2<Complex64>,
+    right: &ArrayView2<Complex64>,
+    rtol: f64,
+    atol: f64,
+) -> bool {
+    for i in 0..left.nrows() {
+        for j in 0..left.ncols() {
+            if (left[(i, j)] - right[(i, j)]).abs() > atol + rtol * right[(i, j)].abs() {
+                return false;
+            }
+        }
+    }
+    true
+}
diff --git a/crates/pyext/src/lib.rs b/crates/pyext/src/lib.rs
index e8971bc87629..24a4badf6539 100644
--- a/crates/pyext/src/lib.rs
+++ b/crates/pyext/src/lib.rs
@@ -13,14 +13,15 @@
 use pyo3::prelude::*;
 
 use qiskit_accelerate::{
-    circuit_library::circuit_library, convert_2q_block_matrix::convert_2q_block_matrix,
-    dense_layout::dense_layout, error_map::error_map,
-    euler_one_qubit_decomposer::euler_one_qubit_decomposer, isometry::isometry, nlayout::nlayout,
-    optimize_1q_gates::optimize_1q_gates, pauli_exp_val::pauli_expval, results::results,
-    sabre::sabre, sampled_exp_val::sampled_exp_val, sparse_pauli_op::sparse_pauli_op,
-    star_prerouting::star_prerouting, stochastic_swap::stochastic_swap, synthesis::synthesis,
-    target_transpiler::target, two_qubit_decompose::two_qubit_decompose, uc_gate::uc_gate,
-    utils::utils, vf2_layout::vf2_layout,
+    circuit_library::circuit_library, commutation_checker::commutation_checker,
+    convert_2q_block_matrix::convert_2q_block_matrix, dense_layout::dense_layout,
+    error_map::error_map, euler_one_qubit_decomposer::euler_one_qubit_decomposer,
+    isometry::isometry, nlayout::nlayout, optimize_1q_gates::optimize_1q_gates,
+    pauli_exp_val::pauli_expval, results::results, sabre::sabre, sampled_exp_val::sampled_exp_val,
+    sparse_pauli_op::sparse_pauli_op, star_prerouting::star_prerouting,
+    stochastic_swap::stochastic_swap, synthesis::synthesis, target_transpiler::target,
+    two_qubit_decompose::two_qubit_decompose, uc_gate::uc_gate, utils::utils,
+    vf2_layout::vf2_layout,
 };
 
 #[inline(always)]
@@ -60,5 +61,6 @@ fn _accelerate(m: &Bound<PyModule>) -> PyResult<()> {
     add_submodule(m, uc_gate, "uc_gate")?;
     add_submodule(m, utils, "utils")?;
     add_submodule(m, vf2_layout, "vf2_layout")?;
+    add_submodule(m, commutation_checker, "commutation_checker")?;
     Ok(())
 }
diff --git a/qiskit/__init__.py b/qiskit/__init__.py
index 33933fd8fd7e..67384b38971a 100644
--- a/qiskit/__init__.py
+++ b/qiskit/__init__.py
@@ -86,6 +86,7 @@
 sys.modules["qiskit._accelerate.synthesis.permutation"] = _accelerate.synthesis.permutation
 sys.modules["qiskit._accelerate.synthesis.linear"] = _accelerate.synthesis.linear
 sys.modules["qiskit._accelerate.synthesis.clifford"] = _accelerate.synthesis.clifford
+sys.modules["qiskit._accelerate.commutation_checker"] = _accelerate.commutation_checker
 sys.modules["qiskit._accelerate.synthesis.linear_phase"] = _accelerate.synthesis.linear_phase
 
 from qiskit.exceptions import QiskitError, MissingOptionalLibraryError
diff --git a/qiskit/circuit/commutation_checker.py b/qiskit/circuit/commutation_checker.py
index e070fe9b9b6f..2d474c7bac4e 100644
--- a/qiskit/circuit/commutation_checker.py
+++ b/qiskit/circuit/commutation_checker.py
@@ -12,47 +12,10 @@
 
 """Code from commutative_analysis pass that checks commutation relations between DAG nodes."""
 
-from functools import lru_cache
 from typing import List, Union, Set, Optional
-import numpy as np
 
-from qiskit import QiskitError
-from qiskit.circuit import Qubit
 from qiskit.circuit.operation import Operation
-from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES
-from qiskit.quantum_info.operators import Operator
-
-_skipped_op_names = {"measure", "reset", "delay", "initialize"}
-_no_cache_op_names = {"annotated"}
-
-_supported_ops = {
-    "h",
-    "x",
-    "y",
-    "z",
-    "sx",
-    "sxdg",
-    "t",
-    "tdg",
-    "s",
-    "sdg",
-    "cx",
-    "cy",
-    "cz",
-    "swap",
-    "iswap",
-    "ecr",
-    "ccx",
-    "cswap",
-}
-
-
-@lru_cache(maxsize=None)
-def _identity_op(num_qubits):
-    """Cached identity matrix"""
-    return Operator(
-        np.eye(2**num_qubits), input_dims=(2,) * num_qubits, output_dims=(2,) * num_qubits
-    )
+from qiskit._accelerate.commutation_checker import CommutationChecker as RustChecker
 
 
 class CommutationChecker:
@@ -70,20 +33,7 @@ def __init__(
         *,
         gates: Optional[Set[str]] = None,
     ):
-        super().__init__()
-        if standard_gate_commutations is None:
-            self._standard_commutations = {}
-        else:
-            self._standard_commutations = standard_gate_commutations
-        self._cache_max_entries = cache_max_entries
-
-        # self._cached_commutation has the same structure as standard_gate_commutations, i.e. a
-        # dict[pair of gate names][relative placement][tuple of gate parameters] := True/False
-        self._cached_commutations = {}
-        self._current_cache_entries = 0
-        self._cache_miss = 0
-        self._cache_hit = 0
-        self._gate_names = gates
+        self.cc = RustChecker(standard_gate_commutations, cache_max_entries, gates)
 
     def commute_nodes(
         self,
@@ -92,15 +42,7 @@ def commute_nodes(
         max_num_qubits: int = 3,
     ) -> bool:
         """Checks if two DAGOpNodes commute."""
-        qargs1 = op1.qargs
-        cargs1 = op2.cargs
-        if not op1.is_standard_gate():
-            op1 = op1.op
-        qargs2 = op2.qargs
-        cargs2 = op2.cargs
-        if not op2.is_standard_gate():
-            op2 = op2.op
-        return self.commute(op1, qargs1, cargs1, op2, qargs2, cargs2, max_num_qubits)
+        return self.cc.commute_nodes(op1, op2, max_num_qubits)
 
     def commute(
         self,
@@ -131,71 +73,15 @@ def commute(
         Returns:
             bool: whether two operations commute.
         """
-        # Skip gates that are not specified.
-        if self._gate_names is not None:
-            if op1.name not in self._gate_names or op2.name not in self._gate_names:
-                return False
-
-        structural_commutation = _commutation_precheck(
-            op1, qargs1, cargs1, op2, qargs2, cargs2, max_num_qubits
-        )
-
-        if structural_commutation is not None:
-            return structural_commutation
-
-        first_op_tuple, second_op_tuple = _order_operations(
-            op1, qargs1, cargs1, op2, qargs2, cargs2
-        )
-        first_op, first_qargs, _ = first_op_tuple
-        second_op, second_qargs, _ = second_op_tuple
-
-        skip_cache = first_op.name in _no_cache_op_names or second_op.name in _no_cache_op_names
-
-        if skip_cache:
-            return _commute_matmul(first_op, first_qargs, second_op, second_qargs)
-
-        commutation_lookup = self.check_commutation_entries(
-            first_op, first_qargs, second_op, second_qargs
-        )
-
-        if commutation_lookup is not None:
-            return commutation_lookup
-
-        # Compute commutation via matrix multiplication
-        is_commuting = _commute_matmul(first_op, first_qargs, second_op, second_qargs)
-
-        # Store result in this session's commutation_library
-        # TODO implement LRU cache or similar
-        # Rebuild cache if current cache exceeded max size
-        if self._current_cache_entries >= self._cache_max_entries:
-            self.clear_cached_commutations()
-
-        first_params = getattr(first_op, "params", [])
-        second_params = getattr(second_op, "params", [])
-        if len(first_params) > 0 or len(second_params) > 0:
-            self._cached_commutations.setdefault((first_op.name, second_op.name), {}).setdefault(
-                _get_relative_placement(first_qargs, second_qargs), {}
-            )[
-                (_hashable_parameters(first_params), _hashable_parameters(second_params))
-            ] = is_commuting
-        else:
-            self._cached_commutations.setdefault((first_op.name, second_op.name), {})[
-                _get_relative_placement(first_qargs, second_qargs)
-            ] = is_commuting
-        self._current_cache_entries += 1
-
-        return is_commuting
+        return self.cc.commute(op1, qargs1, cargs1, op2, qargs2, cargs2, max_num_qubits)
 
     def num_cached_entries(self):
         """Returns number of cached entries"""
-        return self._current_cache_entries
+        return self.cc.num_cached_entries()
 
     def clear_cached_commutations(self):
         """Clears the dictionary holding cached commutations"""
-        self._current_cache_entries = 0
-        self._cache_miss = 0
-        self._cache_hit = 0
-        self._cached_commutations = {}
+        self.cc.clear_cached_commutations()
 
     def check_commutation_entries(
         self,
@@ -215,272 +101,6 @@ def check_commutation_entries(
         Return:
             bool: True if the gates commute and false if it is not the case.
         """
-
-        # We don't precompute commutations for parameterized gates, yet
-        commutation = _query_commutation(
-            first_op,
-            first_qargs,
-            second_op,
-            second_qargs,
-            self._standard_commutations,
-        )
-
-        if commutation is not None:
-            return commutation
-
-        commutation = _query_commutation(
-            first_op,
-            first_qargs,
-            second_op,
-            second_qargs,
-            self._cached_commutations,
-        )
-        if commutation is None:
-            self._cache_miss += 1
-        else:
-            self._cache_hit += 1
-        return commutation
-
-
-def _hashable_parameters(params):
-    """Convert the parameters of a gate into a hashable format for lookup in a dictionary.
-
-    This aims to be fast in common cases, and is not intended to work outside of the lifetime of a
-    single commutation pass; it does not handle mutable state correctly if the state is actually
-    changed."""
-    try:
-        hash(params)
-        return params
-    except TypeError:
-        pass
-    if isinstance(params, (list, tuple)):
-        return tuple(_hashable_parameters(x) for x in params)
-    if isinstance(params, np.ndarray):
-        # Using the bytes of the matrix as key is runtime efficient but requires more space: 128 bits
-        # times the number of parameters instead of a single 64 bit id. However, by using the bytes as
-        # an id, we can reuse the cached commutations between different passes.
-        return (np.ndarray, params.tobytes())
-    # Catch anything else with a slow conversion.
-    return ("fallback", str(params))
-
-
-def is_commutation_supported(op, qargs, max_num_qubits):
-    """
-    Filter operations whose commutation is not supported due to bugs in transpiler passes invoking
-    commutation analysis.
-    Args:
-        op (Operation): operation to be checked for commutation relation.
-        qargs (list[Qubit]): qubits the operation acts on.
-        max_num_qubits (int): The maximum number of qubits to check commutativity for.
-
-    Return:
-        True if determining the commutation of op is currently supported
-    """
-    # If the number of qubits is beyond what we check, stop here and do not even check in the
-    # pre-defined supported operations
-    if len(qargs) > max_num_qubits:
-        return False
-
-    # Check if the operation is pre-approved, otherwise go through the checks
-    if op.name in _supported_ops:
-        return True
-
-    # Commutation of ControlFlow gates also not supported yet. This may be pending a control flow graph.
-    if op.name in CONTROL_FLOW_OP_NAMES:
-        return False
-
-    if getattr(op, "_directive", False) or op.name in _skipped_op_names:
-        return False
-
-    if getattr(op, "is_parameterized", False) and op.is_parameterized():
-        return False
-
-    return True
-
-
-def _commutation_precheck(
-    op1: Operation,
-    qargs1: List,
-    cargs1: List,
-    op2: Operation,
-    qargs2: List,
-    cargs2: List,
-    max_num_qubits,
-):
-    # Bug in CommutativeCancellation, e.g. see gh-8553
-    if getattr(op1, "condition", False) or getattr(op2, "condition", False):
-        return False
-
-    if set(qargs1).isdisjoint(qargs2) and set(cargs1).isdisjoint(cargs2):
-        return True
-
-    if not is_commutation_supported(op1, qargs1, max_num_qubits) or not is_commutation_supported(
-        op2, qargs2, max_num_qubits
-    ):
-        return False
-
-    return None
-
-
-def _get_relative_placement(first_qargs: List[Qubit], second_qargs: List[Qubit]) -> tuple:
-    """Determines the relative qubit placement of two gates. Note: this is NOT symmetric.
-
-    Args:
-        first_qargs (DAGOpNode): first gate
-        second_qargs (DAGOpNode): second gate
-
-    Return:
-        A tuple that describes the relative qubit placement: E.g.
-        _get_relative_placement(CX(0, 1), CX(1, 2)) would return (None, 0) as there is no overlap on
-        the first qubit of the first gate but there is an overlap on the second qubit of the first gate,
-        i.e. qubit 0 of the second gate. Likewise,
-        _get_relative_placement(CX(1, 2), CX(0, 1)) would return (1, None)
-    """
-    qubits_g2 = {q_g1: i_g1 for i_g1, q_g1 in enumerate(second_qargs)}
-    return tuple(qubits_g2.get(q_g0, None) for q_g0 in first_qargs)
-
-
-@lru_cache(maxsize=10**3)
-def _persistent_id(op_name: str) -> int:
-    """Returns an integer id of a string that is persistent over different python executions (note that
-        hash() can not be used, i.e. its value can change over two python executions)
-    Args:
-        op_name (str): The string whose integer id should be determined.
-    Return:
-        The integer id of the input string.
-    """
-    return int.from_bytes(bytes(op_name, encoding="utf-8"), byteorder="big", signed=True)
-
-
-def _order_operations(
-    op1: Operation, qargs1: List, cargs1: List, op2: Operation, qargs2: List, cargs2: List
-):
-    """Orders two operations in a canonical way that is persistent over
-    @different python versions and executions
-    Args:
-        op1: first operation.
-        qargs1: first operation's qubits.
-        cargs1: first operation's clbits.
-        op2: second operation.
-        qargs2: second operation's qubits.
-        cargs2: second operation's clbits.
-    Return:
-        The input operations in a persistent, canonical order.
-    """
-    op1_tuple = (op1, qargs1, cargs1)
-    op2_tuple = (op2, qargs2, cargs2)
-    least_qubits_op, most_qubits_op = (
-        (op1_tuple, op2_tuple) if op1.num_qubits < op2.num_qubits else (op2_tuple, op1_tuple)
-    )
-    # prefer operation with the least number of qubits as first key as this results in shorter keys
-    if op1.num_qubits != op2.num_qubits:
-        return least_qubits_op, most_qubits_op
-    else:
-        return (
-            (op1_tuple, op2_tuple)
-            if _persistent_id(op1.name) < _persistent_id(op2.name)
-            else (op2_tuple, op1_tuple)
-        )
-
-
-def _query_commutation(
-    first_op: Operation,
-    first_qargs: List,
-    second_op: Operation,
-    second_qargs: List,
-    _commutation_lib: dict,
-) -> Union[bool, None]:
-    """Queries and returns the commutation of a pair of operations from a provided commutation library
-    Args:
-        first_op: first operation.
-        first_qargs: first operation's qubits.
-        first_cargs: first operation's clbits.
-        second_op: second operation.
-        second_qargs: second operation's qubits.
-        second_cargs: second operation's clbits.
-        _commutation_lib (dict): dictionary of commutation relations
-    Return:
-        True if first_op and second_op commute, False if they do not commute and
-        None if the commutation is not in the library
-    """
-
-    commutation = _commutation_lib.get((first_op.name, second_op.name), None)
-
-    # Return here if the commutation is constant over all relative placements of the operations
-    if commutation is None or isinstance(commutation, bool):
-        return commutation
-
-    # If we arrive here, there is an entry in the commutation library but it depends on the
-    # placement of the operations and also possibly on operation parameters
-    if isinstance(commutation, dict):
-        commutation_after_placement = commutation.get(
-            _get_relative_placement(first_qargs, second_qargs), None
-        )
-        # if we have another dict in commutation_after_placement, commutation depends on params
-        if isinstance(commutation_after_placement, dict):
-            # Param commutation entry exists and must be a dict
-            first_params = getattr(first_op, "params", [])
-            second_params = getattr(second_op, "params", [])
-            return commutation_after_placement.get(
-                (
-                    _hashable_parameters(first_params),
-                    _hashable_parameters(second_params),
-                ),
-                None,
-            )
-        else:
-            # queried commutation is True, False or None
-            return commutation_after_placement
-    else:
-        raise ValueError("Expected commutation to be None, bool or a dict")
-
-
-def _commute_matmul(
-    first_ops: Operation, first_qargs: List, second_op: Operation, second_qargs: List
-):
-    qarg = {q: i for i, q in enumerate(first_qargs)}
-    num_qubits = len(qarg)
-    for q in second_qargs:
-        if q not in qarg:
-            qarg[q] = num_qubits
-            num_qubits += 1
-
-    first_qarg = tuple(qarg[q] for q in first_qargs)
-    second_qarg = tuple(qarg[q] for q in second_qargs)
-
-    from qiskit.dagcircuit.dagnode import DAGOpNode
-
-    # If we have a DAGOpNode here we've received a StandardGate definition from
-    # rust and we can manually pull the matrix to use for the Operators
-    if isinstance(first_ops, DAGOpNode):
-        first_ops = first_ops.matrix
-    if isinstance(second_op, DAGOpNode):
-        second_op = second_op.matrix
-
-    # try to generate an Operator out of op, if this succeeds we can determine commutativity, otherwise
-    # return false
-    try:
-        operator_1 = Operator(
-            first_ops, input_dims=(2,) * len(first_qarg), output_dims=(2,) * len(first_qarg)
-        )
-        operator_2 = Operator(
-            second_op, input_dims=(2,) * len(second_qarg), output_dims=(2,) * len(second_qarg)
+        return self.cc.library.check_commutation_entries(
+            first_op, first_qargs, second_op, second_qargs
         )
-    except QiskitError:
-        return False
-
-    if first_qarg == second_qarg:
-        # Use full composition if possible to get the fastest matmul paths.
-        op12 = operator_1.compose(operator_2)
-        op21 = operator_2.compose(operator_1)
-    else:
-        # Expand operator_1 to be large enough to contain operator_2 as well; this relies on qargs1
-        # being the lowest possible indices so the identity can be tensored before it.
-        extra_qarg2 = num_qubits - len(first_qarg)
-        if extra_qarg2:
-            id_op = _identity_op(extra_qarg2)
-            operator_1 = id_op.tensor(operator_1)
-        op12 = operator_1.compose(operator_2, qargs=second_qarg, front=False)
-        op21 = operator_1.compose(operator_2, qargs=second_qarg, front=True)
-    ret = op12 == op21
-    return ret
diff --git a/qiskit/transpiler/passes/optimization/commutative_inverse_cancellation.py b/qiskit/transpiler/passes/optimization/commutative_inverse_cancellation.py
index 5f9744fc860a..97324e2376cd 100644
--- a/qiskit/transpiler/passes/optimization/commutative_inverse_cancellation.py
+++ b/qiskit/transpiler/passes/optimization/commutative_inverse_cancellation.py
@@ -12,6 +12,7 @@
 
 """Cancel pairs of inverse gates exploiting commutation relations."""
 from qiskit.circuit.commutation_library import SessionCommutationChecker as scc
+
 from qiskit.dagcircuit import DAGCircuit, DAGOpNode
 from qiskit.quantum_info import Operator
 from qiskit.quantum_info.operators.predicates import matrix_equal
@@ -34,6 +35,7 @@ def __init__(self, matrix_based: bool = False, max_qubits: int = 4):
         """
         self._matrix_based = matrix_based
         self._max_qubits = max_qubits
+        self.comm_checker = scc
         super().__init__()
 
     def _skip_node(self, node):
@@ -92,7 +94,6 @@ def run(self, dag: DAGCircuit):
 
         removed = [False for _ in range(circ_size)]
 
-        cc = scc
         phase_update = 0
 
         for idx1 in range(0, circ_size):
@@ -118,13 +119,9 @@ def run(self, dag: DAGCircuit):
                         matched_idx2 = idx2
                         break
 
-                if not cc.commute(
-                    topo_sorted_nodes[idx1].op,
-                    topo_sorted_nodes[idx1].qargs,
-                    topo_sorted_nodes[idx1].cargs,
-                    topo_sorted_nodes[idx2].op,
-                    topo_sorted_nodes[idx2].qargs,
-                    topo_sorted_nodes[idx2].cargs,
+                if not self.comm_checker.commute_nodes(
+                    topo_sorted_nodes[idx1],
+                    topo_sorted_nodes[idx2],
                     max_num_qubits=self._max_qubits,
                 ):
                     break
diff --git a/releasenotes/notes/rust-commutation-checker-c738e67efa9d292f.yaml b/releasenotes/notes/rust-commutation-checker-c738e67efa9d292f.yaml
new file mode 100644
index 000000000000..bcfcbe18caf0
--- /dev/null
+++ b/releasenotes/notes/rust-commutation-checker-c738e67efa9d292f.yaml
@@ -0,0 +1,6 @@
+---
+features_transpiler:
+  - |
+    The the :class:`.CommutationChecker` class has been reimplemented in
+    Rust. This retains the same functionality as before but is now
+    significantly in most cases.
diff --git a/test/python/circuit/test_commutation_checker.py b/test/python/circuit/test_commutation_checker.py
index 677b191cb0cb..a0aeae5ca2c3 100644
--- a/test/python/circuit/test_commutation_checker.py
+++ b/test/python/circuit/test_commutation_checker.py
@@ -24,9 +24,10 @@
     AnnotatedOperation,
     InverseModifier,
     ControlModifier,
+    Gate,
 )
 from qiskit.circuit.commutation_library import SessionCommutationChecker as scc
-
+from qiskit.dagcircuit import DAGOpNode
 from qiskit.circuit.library import (
     ZGate,
     XGate,
@@ -44,6 +45,16 @@
 from test import QiskitTestCase  # pylint: disable=wrong-import-order
 
 
+class NewGateCX(Gate):
+    """A dummy class containing an cx gate unknown to the commutation checker's library."""
+
+    def __init__(self):
+        super().__init__("new_cx", 2, [])
+
+    def to_matrix(self):
+        return np.array([[1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0]], dtype=complex)
+
+
 class TestCommutationChecker(QiskitTestCase):
     """Test CommutationChecker class."""
 
@@ -51,206 +62,105 @@ def test_simple_gates(self):
         """Check simple commutation relations between gates, experimenting with
         different orders of gates, different orders of qubits, different sets of
         qubits over which gates are defined, and so on."""
-        # should commute
-        res = scc.commute(ZGate(), [0], [], CXGate(), [0, 1], [])
-        self.assertTrue(res)
 
+        # should commute
+        self.assertTrue(scc.commute(ZGate(), [0], [], CXGate(), [0, 1], []))
         # should not commute
-        res = scc.commute(ZGate(), [1], [], CXGate(), [0, 1], [])
-        self.assertFalse(res)
-
+        self.assertFalse(scc.commute(ZGate(), [1], [], CXGate(), [0, 1], []))
         # should not commute
-        res = scc.commute(XGate(), [0], [], CXGate(), [0, 1], [])
-        self.assertFalse(res)
-
+        self.assertFalse(scc.commute(XGate(), [0], [], CXGate(), [0, 1], []))
         # should commute
-        res = scc.commute(XGate(), [1], [], CXGate(), [0, 1], [])
-        self.assertTrue(res)
-
+        self.assertTrue(scc.commute(XGate(), [1], [], CXGate(), [0, 1], []))
         # should not commute
-        res = scc.commute(XGate(), [1], [], CXGate(), [1, 0], [])
-        self.assertFalse(res)
-
+        self.assertFalse(scc.commute(XGate(), [1], [], CXGate(), [1, 0], []))
         # should commute
-        res = scc.commute(XGate(), [0], [], CXGate(), [1, 0], [])
-        self.assertTrue(res)
-
+        self.assertTrue(scc.commute(XGate(), [0], [], CXGate(), [1, 0], []))
         # should commute
-        res = scc.commute(CXGate(), [1, 0], [], XGate(), [0], [])
-        self.assertTrue(res)
-
+        self.assertTrue(scc.commute(CXGate(), [1, 0], [], XGate(), [0], []))
         # should not commute
-        res = scc.commute(CXGate(), [1, 0], [], XGate(), [1], [])
-        self.assertFalse(res)
-
+        self.assertFalse(scc.commute(CXGate(), [1, 0], [], XGate(), [1], []))
         # should commute
-        res = scc.commute(
-            CXGate(),
-            [1, 0],
-            [],
-            CXGate(),
-            [1, 0],
-            [],
-        )
-        self.assertTrue(res)
-
+        self.assertTrue(scc.commute(CXGate(), [1, 0], [], CXGate(), [1, 0], []))
         # should not commute
-        res = scc.commute(
-            CXGate(),
-            [1, 0],
-            [],
-            CXGate(),
-            [0, 1],
-            [],
-        )
-        self.assertFalse(res)
-
+        self.assertFalse(scc.commute(CXGate(), [1, 0], [], CXGate(), [0, 1], []))
         # should commute
-        res = scc.commute(
-            CXGate(),
-            [1, 0],
-            [],
-            CXGate(),
-            [1, 2],
-            [],
-        )
-        self.assertTrue(res)
-
+        self.assertTrue(scc.commute(CXGate(), [1, 0], [], CXGate(), [1, 2], []))
         # should not commute
-        res = scc.commute(
-            CXGate(),
-            [1, 0],
-            [],
-            CXGate(),
-            [2, 1],
-            [],
-        )
-        self.assertFalse(res)
-
+        self.assertFalse(scc.commute(CXGate(), [1, 0], [], CXGate(), [2, 1], []))
         # should commute
-        res = scc.commute(
-            CXGate(),
-            [1, 0],
-            [],
-            CXGate(),
-            [2, 3],
-            [],
-        )
-        self.assertTrue(res)
-
-        res = scc.commute(XGate(), [2], [], CCXGate(), [0, 1, 2], [])
-        self.assertTrue(res)
-
-        res = scc.commute(CCXGate(), [0, 1, 2], [], CCXGate(), [0, 2, 1], [])
-        self.assertFalse(res)
+        self.assertTrue(scc.commute(CXGate(), [1, 0], [], CXGate(), [2, 3], []))
+        self.assertTrue(scc.commute(XGate(), [2], [], CCXGate(), [0, 1, 2], []))
+        self.assertFalse(scc.commute(CCXGate(), [0, 1, 2], [], CCXGate(), [0, 2, 1], []))
 
     def test_passing_quantum_registers(self):
         """Check that passing QuantumRegisters works correctly."""
         qr = QuantumRegister(4)
-
         # should commute
-        res = scc.commute(CXGate(), [qr[1], qr[0]], [], CXGate(), [qr[1], qr[2]], [])
-        self.assertTrue(res)
-
+        self.assertTrue(scc.commute(CXGate(), [qr[1], qr[0]], [], CXGate(), [qr[1], qr[2]], []))
         # should not commute
-        res = scc.commute(CXGate(), [qr[0], qr[1]], [], CXGate(), [qr[1], qr[2]], [])
-        self.assertFalse(res)
+        self.assertFalse(scc.commute(CXGate(), [qr[0], qr[1]], [], CXGate(), [qr[1], qr[2]], []))
 
     def test_standard_gates_commutations(self):
         """Check that commutativity checker uses standard gates commutations as expected."""
         scc.clear_cached_commutations()
-        scc.clear_cached_commutations()
-        res = scc.commute(ZGate(), [0], [], CXGate(), [0, 1], [])
-        self.assertTrue(res)
+        self.assertTrue(scc.commute(ZGate(), [0], [], CXGate(), [0, 1], []))
         self.assertEqual(scc.num_cached_entries(), 0)
 
     def test_caching_positive_results(self):
         """Check that hashing positive results in commutativity checker works as expected."""
         scc.clear_cached_commutations()
-        NewGateCX = type("MyClass", (CXGate,), {"content": {}})
-        NewGateCX.name = "cx_new"
-
-        res = scc.commute(ZGate(), [0], [], NewGateCX(), [0, 1], [])
-        self.assertTrue(res)
-        self.assertGreater(len(scc._cached_commutations), 0)
+        self.assertTrue(scc.commute(ZGate(), [0], [], NewGateCX(), [0, 1], []))
+        self.assertGreater(scc.num_cached_entries(), 0)
 
     def test_caching_lookup_with_non_overlapping_qubits(self):
         """Check that commutation lookup with non-overlapping qubits works as expected."""
         scc.clear_cached_commutations()
-        res = scc.commute(CXGate(), [0, 2], [], CXGate(), [0, 1], [])
-        self.assertTrue(res)
-        res = scc.commute(CXGate(), [0, 1], [], CXGate(), [1, 2], [])
-        self.assertFalse(res)
-        self.assertEqual(len(scc._cached_commutations), 0)
+        self.assertTrue(scc.commute(CXGate(), [0, 2], [], CXGate(), [0, 1], []))
+        self.assertFalse(scc.commute(CXGate(), [0, 1], [], CXGate(), [1, 2], []))
+        self.assertEqual(scc.num_cached_entries(), 0)
 
     def test_caching_store_and_lookup_with_non_overlapping_qubits(self):
         """Check that commutations storing and lookup with non-overlapping qubits works as expected."""
-        cc_lenm = scc.num_cached_entries()
-        NewGateCX = type("MyClass", (CXGate,), {"content": {}})
-        NewGateCX.name = "cx_new"
-        res = scc.commute(NewGateCX(), [0, 2], [], CXGate(), [0, 1], [])
-        self.assertTrue(res)
-        res = scc.commute(NewGateCX(), [0, 1], [], CXGate(), [1, 2], [])
-        self.assertFalse(res)
-        res = scc.commute(NewGateCX(), [1, 4], [], CXGate(), [1, 6], [])
-        self.assertTrue(res)
-        res = scc.commute(NewGateCX(), [5, 3], [], CXGate(), [3, 1], [])
-        self.assertFalse(res)
-        self.assertEqual(scc.num_cached_entries(), cc_lenm + 2)
+        scc_lenm = scc.num_cached_entries()
+        self.assertTrue(scc.commute(NewGateCX(), [0, 2], [], CXGate(), [0, 1], []))
+        self.assertFalse(scc.commute(NewGateCX(), [0, 1], [], CXGate(), [1, 2], []))
+        self.assertTrue(scc.commute(NewGateCX(), [1, 4], [], CXGate(), [1, 6], []))
+        self.assertFalse(scc.commute(NewGateCX(), [5, 3], [], CXGate(), [3, 1], []))
+        self.assertEqual(scc.num_cached_entries(), scc_lenm + 2)
 
     def test_caching_negative_results(self):
         """Check that hashing negative results in commutativity checker works as expected."""
         scc.clear_cached_commutations()
-        NewGateCX = type("MyClass", (CXGate,), {"content": {}})
-        NewGateCX.name = "cx_new"
-
-        res = scc.commute(XGate(), [0], [], NewGateCX(), [0, 1], [])
-        self.assertFalse(res)
-        self.assertGreater(len(scc._cached_commutations), 0)
+        self.assertFalse(scc.commute(XGate(), [0], [], NewGateCX(), [0, 1], []))
+        self.assertGreater(scc.num_cached_entries(), 0)
 
     def test_caching_different_qubit_sets(self):
         """Check that hashing same commutativity results over different qubit sets works as expected."""
         scc.clear_cached_commutations()
-        NewGateCX = type("MyClass", (CXGate,), {"content": {}})
-        NewGateCX.name = "cx_new"
         # All the following should be cached in the same way
         # though each relation gets cached twice: (A, B) and (B, A)
         scc.commute(XGate(), [0], [], NewGateCX(), [0, 1], [])
         scc.commute(XGate(), [10], [], NewGateCX(), [10, 20], [])
         scc.commute(XGate(), [10], [], NewGateCX(), [10, 5], [])
         scc.commute(XGate(), [5], [], NewGateCX(), [5, 7], [])
-        self.assertEqual(len(scc._cached_commutations), 1)
-        self.assertEqual(scc._cache_miss, 1)
-        self.assertEqual(scc._cache_hit, 3)
+        self.assertEqual(scc.num_cached_entries(), 1)
 
     def test_cache_with_param_gates(self):
         """Check commutativity between (non-parameterized) gates with parameters."""
         scc.clear_cached_commutations()
-        res = scc.commute(RZGate(0), [0], [], XGate(), [0], [])
-        self.assertTrue(res)
-
-        res = scc.commute(RZGate(np.pi / 2), [0], [], XGate(), [0], [])
-        self.assertFalse(res)
 
-        res = scc.commute(RZGate(np.pi / 2), [0], [], RZGate(0), [0], [])
-        self.assertTrue(res)
+        self.assertTrue(scc.commute(RZGate(0), [0], [], XGate(), [0], []))
+        self.assertFalse(scc.commute(RZGate(np.pi / 2), [0], [], XGate(), [0], []))
+        self.assertTrue(scc.commute(RZGate(np.pi / 2), [0], [], RZGate(0), [0], []))
 
-        res = scc.commute(RZGate(np.pi / 2), [1], [], XGate(), [1], [])
-        self.assertFalse(res)
+        self.assertFalse(scc.commute(RZGate(np.pi / 2), [1], [], XGate(), [1], []))
         self.assertEqual(scc.num_cached_entries(), 3)
-        self.assertEqual(scc._cache_miss, 3)
-        self.assertEqual(scc._cache_hit, 1)
 
     def test_gates_with_parameters(self):
         """Check commutativity between (non-parameterized) gates with parameters."""
-        res = scc.commute(RZGate(0), [0], [], XGate(), [0], [])
-        self.assertTrue(res)
-
-        res = scc.commute(RZGate(np.pi / 2), [0], [], XGate(), [0], [])
-        self.assertFalse(res)
-
-        res = scc.commute(RZGate(np.pi / 2), [0], [], RZGate(0), [0], [])
-        self.assertTrue(res)
+        self.assertTrue(scc.commute(RZGate(0), [0], [], XGate(), [0], []))
+        self.assertFalse(scc.commute(RZGate(np.pi / 2), [0], [], XGate(), [0], []))
+        self.assertTrue(scc.commute(RZGate(np.pi / 2), [0], [], RZGate(0), [0], []))
 
     def test_parameterized_gates(self):
         """Check commutativity between parameterized gates, both with free and with
@@ -272,84 +182,68 @@ def test_parameterized_gates(self):
         self.assertFalse(cx_gate.is_parameterized())
 
         # We should detect that these gates commute
-        res = scc.commute(rz_gate, [0], [], cx_gate, [0, 1], [])
-        self.assertTrue(res)
+        self.assertTrue(scc.commute(rz_gate, [0], [], cx_gate, [0, 1], []))
 
         # We should detect that these gates commute
-        res = scc.commute(rz_gate, [0], [], rz_gate, [0], [])
-        self.assertTrue(res)
+        self.assertTrue(scc.commute(rz_gate, [0], [], rz_gate, [0], []))
 
         # We should detect that parameterized gates over disjoint qubit subsets commute
-        res = scc.commute(rz_gate_theta, [0], [], rz_gate_theta, [1], [])
-        self.assertTrue(res)
+        self.assertTrue(scc.commute(rz_gate_theta, [0], [], rz_gate_theta, [1], []))
 
         # We should detect that parameterized gates over disjoint qubit subsets commute
-        res = scc.commute(rz_gate_theta, [0], [], rz_gate_phi, [1], [])
-        self.assertTrue(res)
+        self.assertTrue(scc.commute(rz_gate_theta, [0], [], rz_gate_phi, [1], []))
 
         # We should detect that parameterized gates over disjoint qubit subsets commute
-        res = scc.commute(rz_gate_theta, [2], [], cx_gate, [1, 3], [])
-        self.assertTrue(res)
+        self.assertTrue(scc.commute(rz_gate_theta, [2], [], cx_gate, [1, 3], []))
 
         # However, for now commutativity checker should return False when checking
         # commutativity between a parameterized gate and some other gate, when
         # the two gates are over intersecting qubit subsets.
         # This check should be changed if commutativity checker is extended to
         # handle parameterized gates better.
-        res = scc.commute(rz_gate_theta, [0], [], cx_gate, [0, 1], [])
-        self.assertFalse(res)
+        self.assertFalse(scc.commute(rz_gate_theta, [0], [], cx_gate, [0, 1], []))
 
-        res = scc.commute(rz_gate_theta, [0], [], rz_gate, [0], [])
-        self.assertFalse(res)
+        self.assertFalse(scc.commute(rz_gate_theta, [0], [], rz_gate, [0], []))
 
     def test_measure(self):
         """Check commutativity involving measures."""
         # Measure is over qubit 0, while gate is over a disjoint subset of qubits
         # We should be able to swap these.
-        res = scc.commute(Measure(), [0], [0], CXGate(), [1, 2], [])
-        self.assertTrue(res)
+        self.assertTrue(scc.commute(Measure(), [0], [0], CXGate(), [1, 2], []))
 
         # Measure and gate have intersecting set of qubits
         # We should not be able to swap these.
-        res = scc.commute(Measure(), [0], [0], CXGate(), [0, 2], [])
-        self.assertFalse(res)
+        self.assertFalse(scc.commute(Measure(), [0], [0], CXGate(), [0, 2], []))
 
         # Measures over different qubits and clbits
-        res = scc.commute(Measure(), [0], [0], Measure(), [1], [1])
-        self.assertTrue(res)
+        self.assertTrue(scc.commute(Measure(), [0], [0], Measure(), [1], [1]))
 
         # Measures over different qubits but same classical bit
         # We should not be able to swap these.
-        res = scc.commute(Measure(), [0], [0], Measure(), [1], [0])
-        self.assertFalse(res)
+        self.assertFalse(scc.commute(Measure(), [0], [0], Measure(), [1], [0]))
 
         # Measures over same qubits but different classical bit
         # ToDo: can we swap these?
         # Currently checker takes the safe approach and returns False.
-        res = scc.commute(Measure(), [0], [0], Measure(), [0], [1])
-        self.assertFalse(res)
+        self.assertFalse(scc.commute(Measure(), [0], [0], Measure(), [0], [1]))
 
     def test_barrier(self):
         """Check commutativity involving barriers."""
         # A gate should not commute with a barrier
         # (at least if these are over intersecting qubit sets).
-        res = scc.commute(Barrier(4), [0, 1, 2, 3], [], CXGate(), [1, 2], [])
-        self.assertFalse(res)
+        self.assertFalse(scc.commute(Barrier(4), [0, 1, 2, 3], [], CXGate(), [1, 2], []))
 
         # Does it even make sense to have a barrier over a subset of qubits?
         # Though in this case, it probably makes sense to say that barrier and gate can be swapped.
-        res = scc.commute(Barrier(4), [0, 1, 2, 3], [], CXGate(), [5, 6], [])
-        self.assertTrue(res)
+        self.assertTrue(scc.commute(Barrier(4), [0, 1, 2, 3], [], CXGate(), [5, 6], []))
 
     def test_reset(self):
         """Check commutativity involving resets."""
         # A gate should not commute with reset when the qubits intersect.
-        res = scc.commute(Reset(), [0], [], CXGate(), [0, 2], [])
-        self.assertFalse(res)
+        self.assertFalse(scc.commute(Reset(), [0], [], CXGate(), [0, 2], []))
 
         # A gate should commute with reset when the qubits are disjoint.
-        res = scc.commute(Reset(), [0], [], CXGate(), [1, 2], [])
-        self.assertTrue(res)
+        self.assertTrue(scc.commute(Reset(), [0], [], CXGate(), [1, 2], []))
 
     def test_conditional_gates(self):
         """Check commutativity involving conditional gates."""
@@ -358,22 +252,26 @@ def test_conditional_gates(self):
 
         # Currently, in all cases commutativity checker should returns False.
         # This is definitely suboptimal.
-        res = scc.commute(CXGate().c_if(cr[0], 0), [qr[0], qr[1]], [], XGate(), [qr[2]], [])
-        self.assertFalse(res)
-
-        res = scc.commute(CXGate().c_if(cr[0], 0), [qr[0], qr[1]], [], XGate(), [qr[1]], [])
-        self.assertFalse(res)
-
-        res = scc.commute(
-            CXGate().c_if(cr[0], 0), [qr[0], qr[1]], [], CXGate().c_if(cr[0], 0), [qr[0], qr[1]], []
+        self.assertFalse(
+            scc.commute(CXGate().c_if(cr[0], 0), [qr[0], qr[1]], [], XGate(), [qr[2]], [])
         )
-        self.assertFalse(res)
-
-        res = scc.commute(XGate().c_if(cr[0], 0), [qr[0]], [], XGate().c_if(cr[0], 1), [qr[0]], [])
-        self.assertFalse(res)
-
-        res = scc.commute(XGate().c_if(cr[0], 0), [qr[0]], [], XGate(), [qr[0]], [])
-        self.assertFalse(res)
+        self.assertFalse(
+            scc.commute(CXGate().c_if(cr[0], 0), [qr[0], qr[1]], [], XGate(), [qr[1]], [])
+        )
+        self.assertFalse(
+            scc.commute(
+                CXGate().c_if(cr[0], 0),
+                [qr[0], qr[1]],
+                [],
+                CXGate().c_if(cr[0], 0),
+                [qr[0], qr[1]],
+                [],
+            )
+        )
+        self.assertFalse(
+            scc.commute(XGate().c_if(cr[0], 0), [qr[0]], [], XGate().c_if(cr[0], 1), [qr[0]], [])
+        )
+        self.assertFalse(scc.commute(XGate().c_if(cr[0], 0), [qr[0]], [], XGate(), [qr[0]], []))
 
     def test_complex_gates(self):
         """Check commutativity involving more complex gates."""
@@ -382,16 +280,14 @@ def test_complex_gates(self):
 
         # lf1 is equivalent to swap(0, 1), and lf2 to swap(1, 2).
         # These do not commute.
-        res = scc.commute(lf1, [0, 1, 2], [], lf2, [0, 1, 2], [])
-        self.assertFalse(res)
+        self.assertFalse(scc.commute(lf1, [0, 1, 2], [], lf2, [0, 1, 2], []))
 
         lf3 = LinearFunction([[0, 1, 0], [0, 0, 1], [1, 0, 0]])
         lf4 = LinearFunction([[0, 0, 1], [1, 0, 0], [0, 1, 0]])
         # lf3 is permutation 1->2, 2->3, 3->1.
         # lf3 is the inverse permutation 1->3, 2->1, 3->2.
         # These commute.
-        res = scc.commute(lf3, [0, 1, 2], [], lf4, [0, 1, 2], [])
-        self.assertTrue(res)
+        self.assertTrue(scc.commute(lf3, [0, 1, 2], [], lf4, [0, 1, 2], []))
 
     def test_equal_annotated_operations_commute(self):
         """Check commutativity involving the same annotated operation."""
@@ -435,17 +331,28 @@ def test_c7x_gate(self):
 
     def test_wide_gates_over_nondisjoint_qubits(self):
         """Test that checking wide gates does not lead to memory problems."""
-        res = scc.commute(MCXGate(29), list(range(30)), [], XGate(), [0], [])
-        self.assertFalse(res)
-        res = scc.commute(XGate(), [0], [], MCXGate(29), list(range(30)), [])
-        self.assertFalse(res)
+        self.assertFalse(scc.commute(MCXGate(29), list(range(30)), [], XGate(), [0], []))
 
     def test_wide_gates_over_disjoint_qubits(self):
         """Test that wide gates still commute when they are over disjoint sets of qubits."""
-        res = scc.commute(MCXGate(29), list(range(30)), [], XGate(), [30], [])
-        self.assertTrue(res)
-        res = scc.commute(XGate(), [30], [], MCXGate(29), list(range(30)), [])
-        self.assertTrue(res)
+        self.assertTrue(scc.commute(MCXGate(29), list(range(30)), [], XGate(), [30], []))
+        self.assertTrue(scc.commute(XGate(), [30], [], MCXGate(29), list(range(30)), []))
+
+    def test_serialization(self):
+        """Test that the commutation checker is correctly serialized"""
+        import pickle
+
+        scc.clear_cached_commutations()
+        self.assertTrue(scc.commute(ZGate(), [0], [], NewGateCX(), [0, 1], []))
+        cc2 = pickle.loads(pickle.dumps(scc))
+        self.assertEqual(cc2.num_cached_entries(), 1)
+        dop1 = DAGOpNode(ZGate(), qargs=[0], cargs=[])
+        dop2 = DAGOpNode(NewGateCX(), qargs=[0, 1], cargs=[])
+        cc2.commute_nodes(dop1, dop2)
+        dop1 = DAGOpNode(ZGate(), qargs=[0], cargs=[])
+        dop2 = DAGOpNode(CXGate(), qargs=[0, 1], cargs=[])
+        cc2.commute_nodes(dop1, dop2)
+        self.assertEqual(cc2.num_cached_entries(), 1)
 
 
 if __name__ == "__main__":
diff --git a/tools/build_standard_commutations.py b/tools/build_standard_commutations.py
index 0e1fcdf1797d..31f1fe03822b 100644
--- a/tools/build_standard_commutations.py
+++ b/tools/build_standard_commutations.py
@@ -19,12 +19,70 @@
 import itertools
 from functools import lru_cache
 from typing import List
-from qiskit.circuit.commutation_checker import _get_relative_placement, _order_operations
 from qiskit.circuit import Gate, CommutationChecker
 import qiskit.circuit.library.standard_gates as stdg
 from qiskit.dagcircuit import DAGOpNode
 
 
+@lru_cache(maxsize=10**3)
+def _persistent_id(op_name: str) -> int:
+    """Returns an integer id of a string that is persistent over different python executions (note that
+        hash() can not be used, i.e. its value can change over two python executions)
+    Args:
+        op_name (str): The string whose integer id should be determined.
+    Return:
+        The integer id of the input string.
+    """
+    return int.from_bytes(bytes(op_name, encoding="utf-8"), byteorder="big", signed=True)
+
+
+def _order_operations(op1, qargs1, cargs1, op2, qargs2, cargs2):
+    """Orders two operations in a canonical way that is persistent over
+    @different python versions and executions
+    Args:
+        op1: first operation.
+        qargs1: first operation's qubits.
+        cargs1: first operation's clbits.
+        op2: second operation.
+        qargs2: second operation's qubits.
+        cargs2: second operation's clbits.
+    Return:
+        The input operations in a persistent, canonical order.
+    """
+    op1_tuple = (op1, qargs1, cargs1)
+    op2_tuple = (op2, qargs2, cargs2)
+    least_qubits_op, most_qubits_op = (
+        (op1_tuple, op2_tuple) if op1.num_qubits < op2.num_qubits else (op2_tuple, op1_tuple)
+    )
+    # prefer operation with the least number of qubits as first key as this results in shorter keys
+    if op1.num_qubits != op2.num_qubits:
+        return least_qubits_op, most_qubits_op
+    else:
+        return (
+            (op1_tuple, op2_tuple)
+            if _persistent_id(op1.name) < _persistent_id(op2.name)
+            else (op2_tuple, op1_tuple)
+        )
+
+
+def _get_relative_placement(first_qargs, second_qargs) -> tuple:
+    """Determines the relative qubit placement of two gates. Note: this is NOT symmetric.
+
+    Args:
+        first_qargs (DAGOpNode): first gate
+        second_qargs (DAGOpNode): second gate
+
+    Return:
+        A tuple that describes the relative qubit placement: E.g.
+        _get_relative_placement(CX(0, 1), CX(1, 2)) would return (None, 0) as there is no overlap on
+        the first qubit of the first gate but there is an overlap on the second qubit of the first gate,
+        i.e. qubit 0 of the second gate. Likewise,
+        _get_relative_placement(CX(1, 2), CX(0, 1)) would return (1, None)
+    """
+    qubits_g2 = {q_g1: i_g1 for i_g1, q_g1 in enumerate(second_qargs)}
+    return tuple(qubits_g2.get(q_g0, None) for q_g0 in first_qargs)
+
+
 @lru_cache(None)
 def _get_unparameterizable_gates() -> List[Gate]:
     """Retrieve a list of non-parmaterized gates with up to 3 qubits, using the python inspection module

From 8f3308475ce4d0fbce1a95e7397360a9b352b496 Mon Sep 17 00:00:00 2001
From: Jake Lishman <jake.lishman@ibm.com>
Date: Tue, 3 Sep 2024 14:46:34 +0100
Subject: [PATCH 42/85] Fix extraction of controlled parametric gates (#13067)

The `mutable` check in the controlled-gate `OperationFromPython`
extraction logic to check for a mutated `base_gate` was overzealous,
and would return false positives for parametric controlled gates.  The
only modification to `base_gate` of a standard-library gate that would
not have caused data-model problems from Python space would be setting
the base-gate label, which is used for a public feature of the circuit
visualisers.

The change to `get_standard_gate_name_mapping` is just a minor
convenience to make the gate objects directly appendable to a circuit;
previously, each `Parameter` object was distinct and had a UUID clash
with others of the same name, so could not be used together.  The new
behaviour is purely a convenience for tests; it largely should not be
useful for users to directly append these gates.
---
 crates/circuit/src/circuit_instruction.rs     | 12 +++-
 .../library/standard_gates/__init__.py        | 57 +++++++++++--------
 ...arametric-controlled-1a495f6f7ce89397.yaml |  8 +++
 test/python/circuit/test_rust_equivalence.py  | 17 ++++++
 4 files changed, 66 insertions(+), 28 deletions(-)
 create mode 100644 releasenotes/notes/extract-standard-parametric-controlled-1a495f6f7ce89397.yaml

diff --git a/crates/circuit/src/circuit_instruction.rs b/crates/circuit/src/circuit_instruction.rs
index b0620d78fb75..215d337ab052 100644
--- a/crates/circuit/src/circuit_instruction.rs
+++ b/crates/circuit/src/circuit_instruction.rs
@@ -547,12 +547,18 @@ impl<'py> FromPyObject<'py> for OperationFromPython {
             // mapping to avoid an `isinstance` check on `ControlledGate` - a standard gate has
             // nonzero `num_ctrl_qubits` iff it is a `ControlledGate`.
             //
-            // `ControlledGate` also has a `base_gate` attribute, and we don't track enough in Rust
-            // space to handle the case that that was mutated away from a standard gate.
+            // `ControlledGate` also has a `base_gate` attribute related to its historical
+            // implementation, which technically allows mutations from Python space.  The only
+            // mutation of a standard gate's `base_gate` that wouldn't have already broken the
+            // Python-space data model is setting a label, so we just catch that case and default
+            // back to non-standard-gate handling in that case.
             if standard.num_ctrl_qubits() != 0
                 && ((ob.getattr(intern!(py, "ctrl_state"))?.extract::<usize>()?
                     != (1 << standard.num_ctrl_qubits()) - 1)
-                    || ob.getattr(intern!(py, "mutable"))?.extract()?)
+                    || !ob
+                        .getattr(intern!(py, "base_gate"))?
+                        .getattr(intern!(py, "label"))?
+                        .is_none())
             {
                 break 'standard;
             }
diff --git a/qiskit/circuit/library/standard_gates/__init__.py b/qiskit/circuit/library/standard_gates/__init__.py
index a4741386343f..19a2bf770da2 100644
--- a/qiskit/circuit/library/standard_gates/__init__.py
+++ b/qiskit/circuit/library/standard_gates/__init__.py
@@ -54,6 +54,13 @@ def get_standard_gate_name_mapping():
     from qiskit.circuit.delay import Delay
     from qiskit.circuit.reset import Reset
 
+    lambda_ = Parameter("λ")
+    theta = Parameter("ϴ")
+    phi = Parameter("φ")
+    gamma = Parameter("γ")
+    beta = Parameter("β")
+    time = Parameter("t")
+
     # Standard gates library mapping, multicontrolled gates not included since they're
     # variable width
     gates = [
@@ -61,38 +68,37 @@ def get_standard_gate_name_mapping():
         SXGate(),
         XGate(),
         CXGate(),
-        RZGate(Parameter("λ")),
-        RGate(Parameter("ϴ"), Parameter("φ")),
-        Reset(),
+        RZGate(lambda_),
+        RGate(theta, phi),
         C3SXGate(),
         CCXGate(),
         DCXGate(),
         CHGate(),
-        CPhaseGate(Parameter("ϴ")),
-        CRXGate(Parameter("ϴ")),
-        CRYGate(Parameter("ϴ")),
-        CRZGate(Parameter("ϴ")),
+        CPhaseGate(theta),
+        CRXGate(theta),
+        CRYGate(theta),
+        CRZGate(theta),
         CSwapGate(),
         CSXGate(),
-        CUGate(Parameter("ϴ"), Parameter("φ"), Parameter("λ"), Parameter("γ")),
-        CU1Gate(Parameter("λ")),
-        CU3Gate(Parameter("ϴ"), Parameter("φ"), Parameter("λ")),
+        CUGate(theta, phi, lambda_, gamma),
+        CU1Gate(lambda_),
+        CU3Gate(theta, phi, lambda_),
         CYGate(),
         CZGate(),
         CCZGate(),
-        GlobalPhaseGate(Parameter("ϴ")),
+        GlobalPhaseGate(theta),
         HGate(),
-        PhaseGate(Parameter("ϴ")),
+        PhaseGate(theta),
         RCCXGate(),
         RC3XGate(),
-        RXGate(Parameter("ϴ")),
-        RXXGate(Parameter("ϴ")),
-        RYGate(Parameter("ϴ")),
-        RYYGate(Parameter("ϴ")),
-        RZZGate(Parameter("ϴ")),
-        RZXGate(Parameter("ϴ")),
-        XXMinusYYGate(Parameter("ϴ"), Parameter("β")),
-        XXPlusYYGate(Parameter("ϴ"), Parameter("β")),
+        RXGate(theta),
+        RXXGate(theta),
+        RYGate(theta),
+        RYYGate(theta),
+        RZZGate(theta),
+        RZXGate(theta),
+        XXMinusYYGate(theta, beta),
+        XXPlusYYGate(theta, beta),
         ECRGate(),
         SGate(),
         SdgGate(),
@@ -103,13 +109,14 @@ def get_standard_gate_name_mapping():
         SXdgGate(),
         TGate(),
         TdgGate(),
-        UGate(Parameter("ϴ"), Parameter("φ"), Parameter("λ")),
-        U1Gate(Parameter("λ")),
-        U2Gate(Parameter("φ"), Parameter("λ")),
-        U3Gate(Parameter("ϴ"), Parameter("φ"), Parameter("λ")),
+        UGate(theta, phi, lambda_),
+        U1Gate(lambda_),
+        U2Gate(phi, lambda_),
+        U3Gate(theta, phi, lambda_),
         YGate(),
         ZGate(),
-        Delay(Parameter("t")),
+        Delay(time),
+        Reset(),
         Measure(),
     ]
     name_mapping = {gate.name: gate for gate in gates}
diff --git a/releasenotes/notes/extract-standard-parametric-controlled-1a495f6f7ce89397.yaml b/releasenotes/notes/extract-standard-parametric-controlled-1a495f6f7ce89397.yaml
new file mode 100644
index 000000000000..ea4e69dd245f
--- /dev/null
+++ b/releasenotes/notes/extract-standard-parametric-controlled-1a495f6f7ce89397.yaml
@@ -0,0 +1,8 @@
+---
+fixes:
+  - |
+    Parametric controlled standard-library gates (such as :class:`.CRXGate`) will now get correctly
+    extracted to a Rust-space standard gate when using :meth:`.QuantumCircuit.append` and the gate
+    object.  Previously there was a discrepancy where using the :meth:`.QuantumCircuit.crx` method
+    would cause a correct extraction in Rust space, but the :meth:`~.QuantumCirucit.append` form
+    would not.  The bug should generally not have caused any unsoundness from Python.
diff --git a/test/python/circuit/test_rust_equivalence.py b/test/python/circuit/test_rust_equivalence.py
index b6de438d04dd..b6ec28f82e8d 100644
--- a/test/python/circuit/test_rust_equivalence.py
+++ b/test/python/circuit/test_rust_equivalence.py
@@ -227,3 +227,20 @@ def test_non_default_controls(self):
                 circuit.append(gate, [0, 1, 2])
                 self.assertIsNotNone(getattr(gate, "_standard_gate", None))
                 np.testing.assert_almost_equal(Operator(circuit.data[0].operation).to_matrix(), op)
+
+    def test_extracted_as_standard_gate(self):
+        """Test that every gate in the standard library gets correctly extracted as a Rust-space
+        `StandardGate` in its default configuration when passed through `append`."""
+        standards = set()
+        qc = QuantumCircuit(4)
+        for name, gate in get_standard_gate_name_mapping().items():
+            if gate._standard_gate is None:
+                # Not a standard gate.
+                continue
+            standards.add(name)
+            qc.append(gate, qc.qubits[: gate.num_qubits], [])
+        # Sanity check: the test should have found at least one standard gate in the mapping.
+        self.assertNotEqual(standards, set())
+
+        extracted = {inst.name for inst in qc.data if inst.is_standard_gate()}
+        self.assertEqual(standards, extracted)

From dde09f9d62140d898015601a82a50443cd132600 Mon Sep 17 00:00:00 2001
From: Matthew Treinish <mtreinish@kortar.org>
Date: Tue, 3 Sep 2024 09:46:48 -0400
Subject: [PATCH 43/85] Remove benchmarks for deprecated (or soon to be)
 features (#13064)

This commit removes benchmarks for the deprecated assemble module and
the soon to be (see #13063) deprecated pulse module. While these
features are still supported it's not worth the spending the limited
CPU time we hacve on the benchmarking system to track the performance of
these components anymore.
---
 test/benchmarks/assembler.py                  |  51 --
 test/benchmarks/pulse/__init__.py             |  11 -
 test/benchmarks/pulse/load_pulse_defaults.py  | 552 ------------------
 .../benchmarks/pulse/schedule_construction.py | 174 ------
 test/benchmarks/pulse/schedule_lowering.py    |  85 ---
 5 files changed, 873 deletions(-)
 delete mode 100644 test/benchmarks/assembler.py
 delete mode 100644 test/benchmarks/pulse/__init__.py
 delete mode 100644 test/benchmarks/pulse/load_pulse_defaults.py
 delete mode 100644 test/benchmarks/pulse/schedule_construction.py
 delete mode 100644 test/benchmarks/pulse/schedule_lowering.py

diff --git a/test/benchmarks/assembler.py b/test/benchmarks/assembler.py
deleted file mode 100644
index 03d349088c86..000000000000
--- a/test/benchmarks/assembler.py
+++ /dev/null
@@ -1,51 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2023
-#
-# 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.
-
-# pylint: disable=no-member,invalid-name,missing-docstring,no-name-in-module
-# pylint: disable=attribute-defined-outside-init,unsubscriptable-object
-
-from qiskit.compiler import assemble
-from qiskit.assembler import disassemble
-
-from .utils import random_circuit
-
-
-class AssemblerBenchmarks:
-    params = ([8], [4096], [1, 100])
-    param_names = ["n_qubits", "depth", "number of circuits"]
-    timeout = 600
-    version = 2
-
-    def setup(self, n_qubits, depth, number_of_circuits):
-        seed = 42
-        self.circuit = random_circuit(n_qubits, depth, measure=True, conditional=True, seed=seed)
-        self.circuits = [self.circuit] * number_of_circuits
-
-    def time_assemble_circuit(self, _, __, ___):
-        assemble(self.circuits)
-
-
-class DisassemblerBenchmarks:
-    params = ([8], [4096], [1, 100])
-    param_names = ["n_qubits", "depth", "number of circuits"]
-    timeout = 600
-
-    def setup(self, n_qubits, depth, number_of_circuits):
-        seed = 424242
-        self.circuit = random_circuit(n_qubits, depth, measure=True, conditional=True, seed=seed)
-        self.circuits = [self.circuit] * number_of_circuits
-        self.qobj = assemble(self.circuits)
-
-    def time_disassemble_circuit(self, _, __, ___):
-        # TODO: QObj is getting deprecated. Remove once that happens
-        # https://github.com/Qiskit/qiskit/pull/12649
-        disassemble(self.qobj)
diff --git a/test/benchmarks/pulse/__init__.py b/test/benchmarks/pulse/__init__.py
deleted file mode 100644
index c7325a848299..000000000000
--- a/test/benchmarks/pulse/__init__.py
+++ /dev/null
@@ -1,11 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2023
-#
-# 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.
diff --git a/test/benchmarks/pulse/load_pulse_defaults.py b/test/benchmarks/pulse/load_pulse_defaults.py
deleted file mode 100644
index 770ac1563b2b..000000000000
--- a/test/benchmarks/pulse/load_pulse_defaults.py
+++ /dev/null
@@ -1,552 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2023
-#
-# 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.
-
-# pylint: disable=missing-docstring,invalid-name,no-member
-# pylint: disable=attribute-defined-outside-init
-
-import numpy as np
-
-from qiskit.providers.models.pulsedefaults import PulseDefaults
-from qiskit.compiler import schedule
-from qiskit.circuit import QuantumCircuit, Gate
-
-
-def gen_source(num_random_gate):
-
-    # minimum data to instantiate pulse defaults.
-    # cmd def contains cx, rz, sx, u3, measure
-    # and random gate (custom waveform of 100 dt + 2 fc)
-
-    qobj_dict = {
-        "qubit_freq_est": [5.0, 5.1],
-        "meas_freq_est": [7.0, 7.0],
-        "buffer": 0,
-        "pulse_library": [],
-        "cmd_def": [
-            {
-                "name": "cx",
-                "qubits": [0, 1],
-                "sequence": [
-                    {
-                        "ch": "d0",
-                        "name": "fc",
-                        "phase": -3.141592653589793,
-                        "t0": 0,
-                    },
-                    {
-                        "ch": "d0",
-                        "label": "Y90p_d0",
-                        "name": "parametric_pulse",
-                        "parameters": {
-                            "amp": (0.0022743565483134 + 0.14767107967944j),
-                            "beta": 0.5218372954777448,
-                            "duration": 96,
-                            "sigma": 24,
-                        },
-                        "pulse_shape": "drag",
-                        "t0": 0,
-                    },
-                    {
-                        "ch": "d0",
-                        "label": "CR90p_d0_u1",
-                        "name": "parametric_pulse",
-                        "parameters": {
-                            "amp": (0.03583301328943 - 0.0006486874906466j),
-                            "duration": 1104,
-                            "sigma": 64,
-                            "width": 848,
-                        },
-                        "pulse_shape": "gaussian_square",
-                        "t0": 96,
-                    },
-                    {
-                        "ch": "d0",
-                        "label": "CR90m_d0_u1",
-                        "name": "parametric_pulse",
-                        "parameters": {
-                            "amp": (-0.03583301328943 + 0.000648687490646j),
-                            "duration": 1104,
-                            "sigma": 64,
-                            "width": 848,
-                        },
-                        "pulse_shape": "gaussian_square",
-                        "t0": 1296,
-                    },
-                    {
-                        "ch": "d0",
-                        "name": "fc",
-                        "phase": -1.5707963267948966,
-                        "t0": 2400,
-                    },
-                    {
-                        "ch": "d0",
-                        "label": "X90p_d0",
-                        "name": "parametric_pulse",
-                        "parameters": {
-                            "amp": (0.14766707017470 - 0.002521280908868j),
-                            "beta": 0.5218372954777448,
-                            "duration": 96,
-                            "sigma": 24,
-                        },
-                        "pulse_shape": "drag",
-                        "t0": 2400,
-                    },
-                    {
-                        "ch": "d1",
-                        "name": "fc",
-                        "phase": -1.5707963267948966,
-                        "t0": 0,
-                    },
-                    {
-                        "ch": "d1",
-                        "label": "X90p_d1",
-                        "name": "parametric_pulse",
-                        "parameters": {
-                            "amp": (0.19074973504459 + 0.004525711677119j),
-                            "beta": -1.2815198779814807,
-                            "duration": 96,
-                            "sigma": 24,
-                        },
-                        "pulse_shape": "drag",
-                        "t0": 0,
-                    },
-                    {
-                        "ch": "d1",
-                        "label": "Xp_d1",
-                        "name": "parametric_pulse",
-                        "parameters": {
-                            "amp": (0.3872223088586379 + 0j),
-                            "beta": -1.498502772395478,
-                            "duration": 96,
-                            "sigma": 24,
-                        },
-                        "pulse_shape": "drag",
-                        "t0": 1200,
-                    },
-                    {
-                        "ch": "d1",
-                        "label": "Y90m_d1",
-                        "name": "parametric_pulse",
-                        "parameters": {
-                            "amp": (0.00285052543950 - 0.19078212177897j),
-                            "beta": -1.2815198779814807,
-                            "duration": 96,
-                            "sigma": 24,
-                        },
-                        "pulse_shape": "drag",
-                        "t0": 2400,
-                    },
-                    {
-                        "ch": "u0",
-                        "name": "fc",
-                        "phase": -1.5707963267948966,
-                        "t0": 0,
-                    },
-                    {
-                        "ch": "u1",
-                        "name": "fc",
-                        "phase": -3.141592653589793,
-                        "t0": 0,
-                    },
-                    {
-                        "ch": "u1",
-                        "label": "CR90p_u1",
-                        "name": "parametric_pulse",
-                        "parameters": {
-                            "amp": (-0.1629668182698 - 0.8902610676540j),
-                            "duration": 1104,
-                            "sigma": 64,
-                            "width": 848,
-                        },
-                        "pulse_shape": "gaussian_square",
-                        "t0": 96,
-                    },
-                    {
-                        "ch": "u1",
-                        "label": "CR90m_u1",
-                        "name": "parametric_pulse",
-                        "parameters": {
-                            "amp": (0.16296681826986 + 0.8902610676540j),
-                            "duration": 1104,
-                            "sigma": 64,
-                            "width": 848,
-                        },
-                        "pulse_shape": "gaussian_square",
-                        "t0": 1296,
-                    },
-                    {
-                        "ch": "u1",
-                        "name": "fc",
-                        "phase": -1.5707963267948966,
-                        "t0": 2400,
-                    },
-                ],
-            },
-            {
-                "name": "rz",
-                "qubits": [0],
-                "sequence": [
-                    {
-                        "ch": "d0",
-                        "name": "fc",
-                        "phase": "-(P0)",
-                        "t0": 0,
-                    },
-                    {
-                        "ch": "u1",
-                        "name": "fc",
-                        "phase": "-(P0)",
-                        "t0": 0,
-                    },
-                ],
-            },
-            {
-                "name": "rz",
-                "qubits": [1],
-                "sequence": [
-                    {
-                        "ch": "d1",
-                        "name": "fc",
-                        "phase": "-(P0)",
-                        "t0": 0,
-                    },
-                    {
-                        "ch": "u0",
-                        "name": "fc",
-                        "phase": "-(P0)",
-                        "t0": 0,
-                    },
-                ],
-            },
-            {
-                "name": "sx",
-                "qubits": [0],
-                "sequence": [
-                    {
-                        "ch": "d0",
-                        "label": "X90p_d0",
-                        "name": "parametric_pulse",
-                        "parameters": {
-                            "amp": (0.14766707017470 - 0.002521280908868j),
-                            "beta": 0.5218372954777448,
-                            "duration": 96,
-                            "sigma": 24,
-                        },
-                        "pulse_shape": "drag",
-                        "t0": 0,
-                    }
-                ],
-            },
-            {
-                "name": "sx",
-                "qubits": [1],
-                "sequence": [
-                    {
-                        "ch": "d1",
-                        "label": "X90p_d0",
-                        "name": "parametric_pulse",
-                        "parameters": {
-                            "amp": (0.19074973504459 + 0.004525711677119j),
-                            "beta": -1.2815198779814807,
-                            "duration": 96,
-                            "sigma": 24,
-                        },
-                        "pulse_shape": "drag",
-                        "t0": 0,
-                    }
-                ],
-            },
-            {
-                "name": "u3",
-                "qubits": [0],
-                "sequence": [
-                    {
-                        "ch": "d0",
-                        "name": "fc",
-                        "phase": "-(P2)",
-                        "t0": 0,
-                    },
-                    {
-                        "ch": "d0",
-                        "label": "X90p_d0",
-                        "name": "parametric_pulse",
-                        "parameters": {
-                            "amp": (0.14766707017470 - 0.002521280908868j),
-                            "beta": 0.5218372954777448,
-                            "duration": 96,
-                            "sigma": 24,
-                        },
-                        "pulse_shape": "drag",
-                        "t0": 0,
-                    },
-                    {
-                        "ch": "d0",
-                        "name": "fc",
-                        "phase": "-(P0)",
-                        "t0": 96,
-                    },
-                    {
-                        "ch": "d0",
-                        "label": "X90m_d0",
-                        "name": "parametric_pulse",
-                        "parameters": {
-                            "amp": (-0.14767107967944 + 0.002274356548313j),
-                            "beta": 0.5218372954777448,
-                            "duration": 96,
-                            "sigma": 24,
-                        },
-                        "pulse_shape": "drag",
-                        "t0": 96,
-                    },
-                    {
-                        "ch": "d0",
-                        "name": "fc",
-                        "phase": "-(P1)",
-                        "t0": 192,
-                    },
-                    {
-                        "ch": "u1",
-                        "name": "fc",
-                        "phase": "-(P2)",
-                        "t0": 0,
-                    },
-                    {
-                        "ch": "u1",
-                        "name": "fc",
-                        "phase": "-(P0)",
-                        "t0": 96,
-                    },
-                    {
-                        "ch": "u1",
-                        "name": "fc",
-                        "phase": "-(P1)",
-                        "t0": 192,
-                    },
-                ],
-            },
-            {
-                "name": "u3",
-                "qubits": [1],
-                "sequence": [
-                    {
-                        "ch": "d1",
-                        "name": "fc",
-                        "phase": "-(P2)",
-                        "t0": 0,
-                    },
-                    {
-                        "ch": "d1",
-                        "label": "X90p_d1",
-                        "name": "parametric_pulse",
-                        "parameters": {
-                            "amp": (0.19074973504459 + 0.004525711677119j),
-                            "beta": -1.2815198779814807,
-                            "duration": 96,
-                            "sigma": 24,
-                        },
-                        "pulse_shape": "drag",
-                        "t0": 0,
-                    },
-                    {
-                        "ch": "d1",
-                        "name": "fc",
-                        "phase": "-(P0)",
-                        "t0": 96,
-                    },
-                    {
-                        "ch": "d1",
-                        "label": "X90m_d1",
-                        "name": "parametric_pulse",
-                        "parameters": {
-                            "amp": (-0.19078212177897 - 0.002850525439509j),
-                            "beta": -1.2815198779814807,
-                            "duration": 96,
-                            "sigma": 24,
-                        },
-                        "pulse_shape": "drag",
-                        "t0": 96,
-                    },
-                    {
-                        "ch": "d1",
-                        "name": "fc",
-                        "phase": "-(P1)",
-                        "t0": 192,
-                    },
-                    {
-                        "ch": "u0",
-                        "name": "fc",
-                        "phase": "-(P2)",
-                        "t0": 0,
-                    },
-                    {
-                        "ch": "u0",
-                        "name": "fc",
-                        "phase": "-(P0)",
-                        "t0": 96,
-                    },
-                    {
-                        "ch": "u0",
-                        "name": "fc",
-                        "phase": "-(P1)",
-                        "t0": 192,
-                    },
-                ],
-            },
-            {
-                "name": "measure",
-                "qubits": [0, 1],
-                "sequence": [
-                    {
-                        "ch": "m0",
-                        "label": "M_m0",
-                        "name": "parametric_pulse",
-                        "parameters": {
-                            "amp": (-0.3003200790496 + 0.3069634566518j),
-                            "duration": 1792,
-                            "sigma": 64,
-                            "width": 1536,
-                        },
-                        "pulse_shape": "gaussian_square",
-                        "t0": 0,
-                    },
-                    {
-                        "ch": "m1",
-                        "label": "M_m1",
-                        "name": "parametric_pulse",
-                        "parameters": {
-                            "amp": (0.26292757124962 + 0.14446138680205j),
-                            "duration": 1792,
-                            "sigma": 64,
-                            "width": 1536,
-                        },
-                        "pulse_shape": "gaussian_square",
-                        "t0": 0,
-                    },
-                    {
-                        "ch": "m0",
-                        "duration": 1504,
-                        "name": "delay",
-                        "t0": 1792,
-                    },
-                    {
-                        "ch": "m1",
-                        "duration": 1504,
-                        "name": "delay",
-                        "t0": 1792,
-                    },
-                    {
-                        "duration": 1792,
-                        "memory_slot": [0, 1],
-                        "name": "acquire",
-                        "qubits": [0, 1],
-                        "t0": 0,
-                    },
-                ],
-            },
-        ],
-    }
-
-    # add random waveform gate entries to increase overhead
-    for i in range(num_random_gate):
-        for qind in (0, 1):
-            samples = np.random.random(100)
-
-            gate_name = f"ramdom_gate_{i}"
-            sample_name = f"random_sample_q{qind}_{i}"
-
-            qobj_dict["pulse_library"].append(
-                {
-                    "name": sample_name,
-                    "samples": samples,
-                }
-            )
-            qobj_dict["cmd_def"].append(
-                {
-                    "name": gate_name,
-                    "qubits": [qind],
-                    "sequence": [
-                        {
-                            "ch": f"d{qind}",
-                            "name": "fc",
-                            "phase": "-(P0)",
-                            "t0": 0,
-                        },
-                        {
-                            "ch": f"d{qind}",
-                            "label": gate_name,
-                            "name": sample_name,
-                            "t0": 0,
-                        },
-                        {
-                            "ch": f"d{qind}",
-                            "name": "fc",
-                            "phase": "(P0)",
-                            "t0": 100,
-                        },
-                    ],
-                },
-            )
-
-    return qobj_dict
-
-
-class PulseDefaultsBench:
-
-    params = ([0, 10, 100, 1000],)
-    param_names = [
-        "number of random gates",
-    ]
-
-    def setup(self, num_random_gate):
-        self.source = gen_source(num_random_gate)
-
-    def time_building_defaults(self, _):
-        PulseDefaults.from_dict(self.source)
-
-
-class CircuitSchedulingBench:
-
-    params = ([1, 2, 3, 15],)
-    param_names = [
-        "number of unit cell repetition",
-    ]
-
-    def setup(self, repeat_unit_cell):
-        source = gen_source(1)
-        defaults = PulseDefaults.from_dict(source)
-
-        self.inst_map = defaults.instruction_schedule_map
-        self.meas_map = [[0, 1]]
-        self.dt = 0.222e-9
-
-        rng = np.random.default_rng(123)
-
-        qc = QuantumCircuit(2)
-        for _ in range(repeat_unit_cell):
-            randdom_gate = Gate("ramdom_gate_0", 1, list(rng.random(1)))
-            qc.cx(0, 1)
-            qc.append(randdom_gate, [0])
-            qc.sx(0)
-            qc.rz(1.57, 0)
-            qc.append(randdom_gate, [1])
-            qc.sx(1)
-            qc.rz(1.57, 1)
-        qc.measure_all()
-        self.qc = qc
-
-    def time_scheduling_circuits(self, _):
-        schedule(
-            self.qc,
-            inst_map=self.inst_map,
-            meas_map=self.meas_map,
-            dt=self.dt,
-        )
diff --git a/test/benchmarks/pulse/schedule_construction.py b/test/benchmarks/pulse/schedule_construction.py
deleted file mode 100644
index 13b889a19513..000000000000
--- a/test/benchmarks/pulse/schedule_construction.py
+++ /dev/null
@@ -1,174 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2023
-#
-# 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.
-
-# pylint: disable=missing-docstring,invalid-name,no-member
-# pylint: disable=attribute-defined-outside-init
-
-import numpy as np
-
-from qiskit.circuit import Parameter, QuantumCircuit, Gate
-from qiskit.pulse import builder, library, channels
-
-
-class EchoedCrossResonanceConstructionBench:
-    def setup(self):
-
-        with builder.build() as x_ctrl:
-            builder.play(
-                library.Drag(160, 0.2, 40, 1.5),
-                channels.DriveChannel(0),
-            )
-        self.x_ctrl = x_ctrl
-
-        with builder.build() as cr45p:
-            builder.play(
-                library.GaussianSquare(800, 0.4, 64, 544),
-                channels.ControlChannel(0),
-            )
-            builder.play(
-                library.GaussianSquare(800, 0.1, 64, 544),
-                channels.DriveChannel(1),
-            )
-        self.cr45p = cr45p
-
-    def time_full_scratch(self):
-        # Full scratch in a single builder context
-        with builder.build():
-            with builder.align_sequential():
-                with builder.align_left():
-                    builder.play(
-                        library.GaussianSquare(800, 0.4, 64, 544),
-                        channels.ControlChannel(0),
-                    )
-                    builder.play(
-                        library.GaussianSquare(800, 0.1, 64, 544),
-                        channels.DriveChannel(1),
-                    )
-                builder.play(
-                    library.Drag(160, 0.2, 40, 1.5),
-                    channels.DriveChannel(0),
-                )
-                with builder.phase_offset(
-                    np.pi,
-                    channels.ControlChannel(0),
-                    channels.DriveChannel(1),
-                ):
-                    with builder.align_left():
-                        builder.play(
-                            library.GaussianSquare(800, 0.4, 64, 544),
-                            channels.ControlChannel(0),
-                        )
-                        builder.play(
-                            library.GaussianSquare(800, 0.1, 64, 544),
-                            channels.DriveChannel(1),
-                        )
-                builder.play(
-                    library.Drag(160, 0.2, 40, 1.5),
-                    channels.DriveChannel(0),
-                )
-
-    def time_with_call(self):
-        # Call subroutine, internally creates reference and assign immediately
-        with builder.build():
-            with builder.align_sequential():
-                builder.call(self.cr45p)
-                builder.call(self.x_ctrl)
-                with builder.phase_offset(
-                    np.pi,
-                    channels.ControlChannel(0),
-                    channels.DriveChannel(1),
-                ):
-                    builder.call(self.cr45p)
-                builder.call(self.x_ctrl)
-
-    def time_assign_later(self):
-        # Create placeholder and assign subroutine at a later time
-        with builder.build() as temp_sched:
-            with builder.align_sequential():
-                builder.reference("cr45p", "q0", "q1")
-                builder.reference("x", "q0")
-                with builder.phase_offset(
-                    np.pi,
-                    channels.ControlChannel(0),
-                    channels.DriveChannel(1),
-                ):
-                    builder.reference("cr45p", "q0", "q1")
-                builder.reference("x", "q0")
-
-        temp_sched.assign_references(
-            {
-                ("cr45p", "q0", "q1"): self.cr45p,
-                ("x", "q0"): self.x_ctrl,
-            },
-            inplace=True,
-        )
-
-
-class ParameterizedScheduleBench:
-
-    params = [3, 11, 31, 51]
-
-    def setup(self, nscan):
-        self.p0 = Parameter("P0")
-        self.p1 = Parameter("P1")
-        self.p2 = Parameter("P2")
-
-        with builder.build() as schedule:
-            builder.play(
-                library.Constant(self.p0, self.p1),
-                channels.DriveChannel(self.p2),
-            )
-        self.schedule = schedule
-
-        with builder.build() as outer_schedule:
-            builder.reference("subroutine")
-        outer_schedule.assign_references({("subroutine",): schedule}, inplace=True)
-        self.outer_schedule = outer_schedule
-
-        gate = Gate("my_gate", 1, [self.p0, self.p1, self.p2])
-        qc = QuantumCircuit(1)
-        qc.append(gate, [0])
-        qc.add_calibration(gate, (0,), schedule)
-        self.qc = qc
-
-        # list of parameters
-        self.amps = np.linspace(-1, 1, nscan)
-
-    def time_assign_single_schedule(self, _):
-
-        out = []
-        for amp in self.amps:
-            assigned = self.schedule.assign_parameters(
-                {self.p0: 100, self.p1: amp, self.p2: 0},
-                inplace=False,
-            )
-            out.append(assigned)
-
-    def time_assign_parameterized_subroutine(self, _):
-
-        out = []
-        for amp in self.amps:
-            assigned = self.outer_schedule.assign_parameters(
-                {self.p0: 100, self.p1: amp, self.p2: 0},
-                inplace=False,
-            )
-            out.append(assigned)
-
-    def time_assign_through_pulse_gate(self, _):
-
-        out = []
-        for amp in self.amps:
-            assigned = self.qc.assign_parameters(
-                {self.p0: 100, self.p1: amp, self.p2: 0},
-                inplace=False,
-            )
-            out.append(assigned)
diff --git a/test/benchmarks/pulse/schedule_lowering.py b/test/benchmarks/pulse/schedule_lowering.py
deleted file mode 100644
index 38b09a8411be..000000000000
--- a/test/benchmarks/pulse/schedule_lowering.py
+++ /dev/null
@@ -1,85 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2023
-#
-# 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.
-
-# pylint: disable=missing-docstring,invalid-name,no-member
-# pylint: disable=attribute-defined-outside-init
-
-import numpy as np
-
-from qiskit.pulse import builder, library, channels
-from qiskit.pulse.transforms import target_qobj_transform
-
-
-def build_complicated_schedule():
-
-    with builder.build() as schedule:
-        with builder.align_sequential():
-            with builder.align_right():
-                with builder.phase_offset(np.pi, channels.ControlChannel(2)):
-                    with builder.align_sequential():
-                        for _ in range(5):
-                            builder.play(
-                                library.GaussianSquare(640, 0.1, 64, 384),
-                                channels.ControlChannel(2),
-                            )
-                builder.play(
-                    library.Constant(1920, 0.1),
-                    channels.DriveChannel(1),
-                )
-                builder.barrier(
-                    channels.DriveChannel(0),
-                    channels.DriveChannel(1),
-                    channels.DriveChannel(2),
-                )
-                builder.delay(800, channels.DriveChannel(1))
-                with builder.align_left():
-                    builder.play(
-                        library.Drag(160, 0.3, 40, 1.5),
-                        channels.DriveChannel(0),
-                    )
-                    builder.play(
-                        library.Drag(320, 0.2, 80, 1.5),
-                        channels.DriveChannel(1),
-                    )
-                    builder.play(
-                        library.Drag(480, 0.1, 120, 1.5),
-                        channels.DriveChannel(2),
-                    )
-            builder.reference("sub")
-            with builder.align_left():
-                for i in range(3):
-                    builder.play(
-                        library.GaussianSquare(1600, 0.1, 64, 1344),
-                        channels.MeasureChannel(i),
-                    )
-                    builder.acquire(
-                        1600,
-                        channels.AcquireChannel(i),
-                        channels.MemorySlot(i),
-                    )
-
-    with builder.build() as subroutine:
-        for i in range(3):
-            samples = np.random.random(160)
-            builder.play(samples, channels.DriveChannel(i))
-    schedule.assign_references({("sub",): subroutine}, inplace=True)
-
-    return schedule
-
-
-class ScheduleLoweringBench:
-    def setup(self):
-        self.schedule_block = build_complicated_schedule()
-
-    def time_lowering(self):
-        # Lower schedule block to generate job payload
-        target_qobj_transform(self.schedule_block)

From d3b8b918cd9856d2acff427f79ac3eb4e77d1a9a Mon Sep 17 00:00:00 2001
From: Jake Lishman <jake.lishman@ibm.com>
Date: Tue, 3 Sep 2024 15:56:17 +0100
Subject: [PATCH 44/85] Avoid `ExtraInstructionAttributes` allocation on
 `unit="dt"` (#13078)

The default value for `Instruction.unit` is `"dt"`.  Previously, the
`OperationFromPython` extraction logic would only suppress allocation of
the extra instruction attributes if all the contained fields were
`None`, but `None` is not actually a valid value of `Instruction.unit`
(which must be a string).  This meant that `OperationFromPython` would
always allocate and store extra attributes, even for the default cases.
This did not affect standard gates appended using their corresponding
`QuantumCircuit` methods (since no Python-space extraction is
performed in that case), but did affect standard calls to `append`, or
anything else that entered from Python space.

This drastically reduces the memory usage of circuits built by
`append`-like methods. Ignoring the inefficiency factor of the
heap-allocation implementation, this saves 66 bytes plus
small-allocation overhead for 2-byte heap allocations (another 14 bytes
on macOS, but will vary depending on the allocator) per standard
instruction, which is on the order of 40% memory-usage reduction.
---
 crates/circuit/src/circuit_instruction.rs | 37 ++++++++++++++++++++---
 crates/circuit/src/operations.rs          |  2 +-
 2 files changed, 34 insertions(+), 5 deletions(-)

diff --git a/crates/circuit/src/circuit_instruction.rs b/crates/circuit/src/circuit_instruction.rs
index 215d337ab052..463f3352aa92 100644
--- a/crates/circuit/src/circuit_instruction.rs
+++ b/crates/circuit/src/circuit_instruction.rs
@@ -17,7 +17,7 @@ use numpy::IntoPyArray;
 use pyo3::basic::CompareOp;
 use pyo3::exceptions::{PyDeprecationWarning, PyTypeError};
 use pyo3::prelude::*;
-use pyo3::types::{PyList, PyTuple, PyType};
+use pyo3::types::{PyList, PyString, PyTuple, PyType};
 use pyo3::{intern, IntoPy, PyObject, PyResult};
 
 use smallvec::SmallVec;
@@ -63,6 +63,20 @@ impl ExtraInstructionAttributes {
             None
         }
     }
+
+    /// Get the Python-space version of the stored `unit`.  This evalutes the Python-space default
+    /// (`"dt"`) value if we're storing a `None`.
+    pub fn py_unit(&self, py: Python) -> Py<PyString> {
+        self.unit
+            .as_deref()
+            .map(|unit| <&str as IntoPy<Py<PyString>>>::into_py(unit, py))
+            .unwrap_or_else(|| Self::default_unit(py).clone().unbind())
+    }
+
+    /// Get the Python-space default value for the `unit` field.
+    pub fn default_unit(py: Python) -> &Bound<PyString> {
+        intern!(py, "dt")
+    }
 }
 
 /// A single instruction in a :class:`.QuantumCircuit`, comprised of the :attr:`operation` and
@@ -267,10 +281,17 @@ impl CircuitInstruction {
     }
 
     #[getter]
-    fn unit(&self) -> Option<&str> {
+    fn unit(&self, py: Python) -> Py<PyString> {
+        // Python space uses `"dt"` as the default, whereas we simply don't store the extra
+        // attributes at all if they're none.
         self.extra_attrs
             .as_ref()
-            .and_then(|attrs| attrs.unit.as_deref())
+            .map(|attrs| attrs.py_unit(py))
+            .unwrap_or_else(|| {
+                ExtraInstructionAttributes::default_unit(py)
+                    .clone()
+                    .unbind()
+            })
     }
 
     /// Is the :class:`.Operation` contained in this instruction a Qiskit standard gate?
@@ -524,10 +545,18 @@ impl<'py> FromPyObject<'py> for OperationFromPython {
                 .map(|params| params.unwrap_or_default())
         };
         let extract_extra = || -> PyResult<_> {
+            let unit = {
+                // We accept Python-space `None` or `"dt"` as both meaning the default `"dt"`.
+                let raw_unit = ob.getattr(intern!(py, "unit"))?;
+                (!(raw_unit.is_none()
+                    || raw_unit.eq(ExtraInstructionAttributes::default_unit(py))?))
+                .then(|| raw_unit.extract::<String>())
+                .transpose()?
+            };
             Ok(ExtraInstructionAttributes::new(
                 ob.getattr(intern!(py, "label"))?.extract()?,
                 ob.getattr(intern!(py, "duration"))?.extract()?,
-                ob.getattr(intern!(py, "unit"))?.extract()?,
+                unit,
                 ob.getattr(intern!(py, "condition"))?.extract()?,
             )
             .map(Box::from))
diff --git a/crates/circuit/src/operations.rs b/crates/circuit/src/operations.rs
index f6e087a5680f..8cc2256af518 100644
--- a/crates/circuit/src/operations.rs
+++ b/crates/circuit/src/operations.rs
@@ -435,7 +435,7 @@ impl StandardGate {
         if let Some(extra) = extra_attrs {
             let kwargs = [
                 ("label", extra.label.to_object(py)),
-                ("unit", extra.unit.to_object(py)),
+                ("unit", extra.py_unit(py).into_any()),
                 ("duration", extra.duration.to_object(py)),
             ]
             .into_py_dict_bound(py);

From dff9e8121729d8273963eaf3a7d718c44f4cb31c Mon Sep 17 00:00:00 2001
From: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>
Date: Tue, 3 Sep 2024 18:06:48 -0400
Subject: [PATCH 45/85] Implement a capacity-allocated constructor for
 `DAGCircuit` in Rust. (#12975)

* Initial: implement fixed capacity constructor for DAGCircuit
- Implement `DAGCircuit` with `with_capacity` to create an initially allocated instance, for rust only.
- Implement `with_capacity` for `BitData` and `IndexInterner` that creates an initally allocated instance of each type.
- Other small tweaks and fixes.
- Add num_edges optional argument. If known, use `num_edges` argument to create a `DAGCircuit` with the exact number of edges.
- Leverage usage of new method in `copy_empty_like`.
- Use `..Default::default()` for `op_names` and `calibrations` fields in `DAGCircuit::with_capacity()`

* Fix: Adapt to #13033

* Fix: Re-arrange the function arguments as per @mtreinish's review.
- The order now follows: qubits, clbits, vars, num_ops, edges. As per [Matthew's comment](https://github.com/Qiskit/qiskit/pull/12975#discussion_r1742426093).
---
 crates/circuit/src/bit_data.rs    |  9 ++++
 crates/circuit/src/dag_circuit.rs | 72 ++++++++++++++++++++++++++++++-
 crates/circuit/src/interner.rs    |  7 +++
 3 files changed, 87 insertions(+), 1 deletion(-)

diff --git a/crates/circuit/src/bit_data.rs b/crates/circuit/src/bit_data.rs
index 0c0b20a02522..6a8e4af6b920 100644
--- a/crates/circuit/src/bit_data.rs
+++ b/crates/circuit/src/bit_data.rs
@@ -95,6 +95,15 @@ where
         }
     }
 
+    pub fn with_capacity(py: Python<'_>, description: String, capacity: usize) -> Self {
+        BitData {
+            description,
+            bits: Vec::with_capacity(capacity),
+            indices: HashMap::with_capacity(capacity),
+            cached: PyList::empty_bound(py).unbind(),
+        }
+    }
+
     /// Gets the number of bits.
     pub fn len(&self) -> usize {
         self.bits.len()
diff --git a/crates/circuit/src/dag_circuit.rs b/crates/circuit/src/dag_circuit.rs
index afe6797596d9..90a4c75408fa 100644
--- a/crates/circuit/src/dag_circuit.rs
+++ b/crates/circuit/src/dag_circuit.rs
@@ -1556,7 +1556,14 @@ def _format(operand):
     ///     DAGCircuit: An empty copy of self.
     #[pyo3(signature = (*, vars_mode="alike"))]
     fn copy_empty_like(&self, py: Python, vars_mode: &str) -> PyResult<Self> {
-        let mut target_dag = DAGCircuit::new(py)?;
+        let mut target_dag = DAGCircuit::with_capacity(
+            py,
+            self.num_qubits(),
+            self.num_clbits(),
+            Some(self.num_vars()),
+            None,
+            None,
+        )?;
         target_dag.name = self.name.as_ref().map(|n| n.clone_ref(py));
         target_dag.global_phase = self.global_phase.clone();
         target_dag.duration = self.duration.as_ref().map(|d| d.clone_ref(py));
@@ -6156,6 +6163,69 @@ impl DAGCircuit {
         }
         Ok(())
     }
+
+    /// Alternative constructor, builds a DAGCircuit with a fixed capacity.
+    ///
+    /// # Arguments:
+    /// - `py`: Python GIL token
+    /// - `num_qubits`: Number of qubits in the circuit
+    /// - `num_clbits`: Number of classical bits in the circuit.
+    /// - `num_vars`: (Optional) number of variables in the circuit.
+    /// - `num_ops`: (Optional) number of operations in the circuit.
+    /// - `num_edges`: (Optional) If known, number of edges in the circuit.
+    pub fn with_capacity(
+        py: Python,
+        num_qubits: usize,
+        num_clbits: usize,
+        num_vars: Option<usize>,
+        num_ops: Option<usize>,
+        num_edges: Option<usize>,
+    ) -> PyResult<Self> {
+        let num_ops: usize = num_ops.unwrap_or_default();
+        let num_vars = num_vars.unwrap_or_default();
+        let num_edges = num_edges.unwrap_or(
+            num_qubits +    // 1 edge between the input node and the output node or 1st op node.
+            num_clbits +    // 1 edge between the input node and the output node or 1st op node.
+            num_vars +      // 1 edge between the input node and the output node or 1st op node.
+            num_ops, // In Average there will be 3 edges (2 qubits and 1 clbit, or 3 qubits) per op_node.
+        );
+
+        let num_nodes = num_qubits * 2 + // One input + One output node per qubit
+            num_clbits * 2 +    // One input + One output node per clbit
+            num_vars * 2 +  // One input + output node per variable
+            num_ops;
+
+        Ok(Self {
+            name: None,
+            metadata: Some(PyDict::new_bound(py).unbind().into()),
+            calibrations: HashMap::default(),
+            dag: StableDiGraph::with_capacity(num_nodes, num_edges),
+            qregs: PyDict::new_bound(py).unbind(),
+            cregs: PyDict::new_bound(py).unbind(),
+            qargs_interner: Interner::with_capacity(num_qubits),
+            cargs_interner: Interner::with_capacity(num_clbits),
+            qubits: BitData::with_capacity(py, "qubits".to_string(), num_qubits),
+            clbits: BitData::with_capacity(py, "clbits".to_string(), num_clbits),
+            global_phase: Param::Float(0.),
+            duration: None,
+            unit: "dt".to_string(),
+            qubit_locations: PyDict::new_bound(py).unbind(),
+            clbit_locations: PyDict::new_bound(py).unbind(),
+            qubit_io_map: Vec::with_capacity(num_qubits),
+            clbit_io_map: Vec::with_capacity(num_clbits),
+            var_input_map: _VarIndexMap::new(py),
+            var_output_map: _VarIndexMap::new(py),
+            op_names: IndexMap::default(),
+            control_flow_module: PyControlFlowModule::new(py)?,
+            vars_info: HashMap::with_capacity(num_vars),
+            vars_by_type: [
+                PySet::empty_bound(py)?.unbind(),
+                PySet::empty_bound(py)?.unbind(),
+                PySet::empty_bound(py)?.unbind(),
+            ],
+        })
+    }
+
     /// Get qargs from an intern index
     pub fn get_qargs(&self, index: Interned<[Qubit]>) -> &[Qubit] {
         self.qargs_interner.get(index)
diff --git a/crates/circuit/src/interner.rs b/crates/circuit/src/interner.rs
index 39c5364aa1cc..a8ac269b1a18 100644
--- a/crates/circuit/src/interner.rs
+++ b/crates/circuit/src/interner.rs
@@ -125,6 +125,13 @@ where
             _type: PhantomData,
         }
     }
+
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self(IndexSet::with_capacity_and_hasher(
+            capacity,
+            ::ahash::RandomState::new(),
+        ))
+    }
 }
 
 impl<T> Interner<T>

From 576efcf14a4be392cbcdb3c75d2838a440f73b13 Mon Sep 17 00:00:00 2001
From: Alexander Ivrii <alexi@il.ibm.com>
Date: Wed, 4 Sep 2024 18:32:52 +0300
Subject: [PATCH 46/85] Bug fix in `HoareOptimizer` (#13083)

* bug fix, test, reno

* suggestions from code review; lint
---
 .../passes/optimization/hoare_opt.py          | 20 ++++++-----
 .../notes/fix-hoare-opt-56d1ca6a07f07a2d.yaml |  5 +++
 test/python/transpiler/test_hoare_opt.py      | 35 +++++++++++++++++++
 3 files changed, 52 insertions(+), 8 deletions(-)
 create mode 100644 releasenotes/notes/fix-hoare-opt-56d1ca6a07f07a2d.yaml

diff --git a/qiskit/transpiler/passes/optimization/hoare_opt.py b/qiskit/transpiler/passes/optimization/hoare_opt.py
index a77f1985f696..e47074fc6142 100644
--- a/qiskit/transpiler/passes/optimization/hoare_opt.py
+++ b/qiskit/transpiler/passes/optimization/hoare_opt.py
@@ -203,20 +203,24 @@ def _traverse_dag(self, dag):
         """
         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)
diff --git a/releasenotes/notes/fix-hoare-opt-56d1ca6a07f07a2d.yaml b/releasenotes/notes/fix-hoare-opt-56d1ca6a07f07a2d.yaml
new file mode 100644
index 000000000000..7548dcc99564
--- /dev/null
+++ b/releasenotes/notes/fix-hoare-opt-56d1ca6a07f07a2d.yaml
@@ -0,0 +1,5 @@
+---
+fixes:
+  - |
+    Fixed a bug in :class:`.HoareOptimizer` where a controlled gate was simplified
+    by removing its controls but the new gate was not handled correctly.
diff --git a/test/python/transpiler/test_hoare_opt.py b/test/python/transpiler/test_hoare_opt.py
index b3ae3df97678..ae2f9d9ae1e0 100644
--- a/test/python/transpiler/test_hoare_opt.py
+++ b/test/python/transpiler/test_hoare_opt.py
@@ -661,6 +661,41 @@ def test_multiple_pass(self):
 
         self.assertEqual(result2, circuit_to_dag(expected))
 
+    def test_remove_control_then_identity(self):
+        """This first simplifies a gate by removing its control, then removes the
+        simplified gate by canceling it with another gate.
+        See: https://github.com/Qiskit/qiskit-terra/issues/13079
+        """
+        #      ┌───┐┌───┐┌───┐
+        # q_0: ┤ X ├┤ X ├┤ X ├
+        #      └─┬─┘└───┘└─┬─┘
+        # q_1: ──■─────────┼──
+        #      ┌───┐       │
+        # q_2: ┤ X ├───────■──
+        #      └───┘
+        circuit = QuantumCircuit(3)
+        circuit.cx(1, 0)
+        circuit.x(2)
+        circuit.x(0)
+        circuit.cx(2, 0)
+
+        simplified = HoareOptimizer()(circuit)
+
+        # The CX(1, 0) gate is removed as the control qubit q_1 is initially 0.
+        # The CX(2, 0) gate is first replaced by X(0) gate as the control qubit q_2 is at 1,
+        # then the two X(0) gates are removed.
+        #
+        # q_0: ─────
+        #
+        # q_1: ─────
+        #      ┌───┐
+        # q_2: ┤ X ├
+        #      └───┘
+        expected = QuantumCircuit(3)
+        expected.x(2)
+
+        self.assertEqual(simplified, expected)
+
 
 if __name__ == "__main__":
     unittest.main()

From 05f64295ed8ab55a729cb0f81ff9662201e6f5e5 Mon Sep 17 00:00:00 2001
From: Sebastian Brandhofer <148463728+sbrandhsn@users.noreply.github.com>
Date: Wed, 4 Sep 2024 20:21:25 +0200
Subject: [PATCH 47/85] Oxidize Commutation Analysis (#12995)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* init

* up

* lint

* .

* up

* before cache

* with cache

* correct

* cleaned up

* lint reno

* Update Cargo.lock

* .

* up

* .

* revert op

* .

* .

* .

* .

* Delete Cargo.lock

* .

* corrected string comparison

* removed Operator class from operation.rs

* .

* Apply suggestions from code review

Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>

* comments from code review

* Port DAGCircuit to Rust

This commit migrates the entirety of the `DAGCircuit` class to Rust. It
fully replaces the Python version of the class. The primary advantage
of this migration is moving from a Python space rustworkx directed graph
representation to a Rust space petgraph (the upstream library for
rustworkx) directed graph. Moving the graph data structure to rust
enables us to directly interact with the DAG directly from transpiler
passes in Rust in the future. This will enable a significant speed-up in
those transpiler passes. Additionally, this should also improve the
memory footprint as the DAGCircuit no longer stores `DAGNode`
instances, and instead stores a lighter enum NodeType, which simply
contains a `PackedInstruction` or the wire objects directly.

Internally, the new Rust-based `DAGCircuit` uses a `petgraph::StableGraph`
with node weights of type `NodeType` and edge weights of type `Wire`. The
NodeType enum contains variants for `QubitIn`, `QubitOut`, `ClbitIn`,
`ClbitOut`, and `Operation`, which should save us from all of the
`isinstance` checking previously needed when working with `DAGNode` Python
instances. The `Wire` enum contains variants `Qubit`, `Clbit`, and `Var`.

As the full Qiskit data model is not rust-native at this point while
all the class code in the `DAGCircuit` exists in Rust now, there are
still sections that rely on Python or actively run Python code via Rust
to function. These typically involve anything that uses `condition`,
control flow, classical vars, calibrations, bit/register manipulation,
etc. In the future as we either migrate this functionality to Rust or
deprecate and remove it this can be updated in place to avoid the use
of Python.

API access from Python-space remains in terms of `DAGNode` instances to
maintain API compatibility with the Python implementation. However,
internally, we convert to and deal in terms of NodeType. When the user
requests a particular node via lookup or iteration, we inflate an ephemeral
`DAGNode` based on the internal `NodeType` and give them that. This is very
similar to what was done in #10827 when porting CircuitData to Rust.

As part of this porting there are a few small differences to keep in
mind with the new Rust implementation of DAGCircuit. The first is that
the topological ordering is slightly different with the new DAGCircuit.
Previously, the Python version of `DAGCircuit` using a lexicographical
topological sort key which was basically `"0,1,0,2"` where the first
`0,1` are qargs on qubit indices `0,1` for nodes and `0,2` are cargs
on clbit indices `0,2`. However, the sort key has now changed to be
`(&[Qubit(0), Qubit(1)], &[Clbit(0), Clbit(2)])` in rust in this case
which for the most part should behave identically, but there are some
edge cases that will appear where the sort order is different. It will
always be a valid topological ordering as the lexicographical key is
used as a tie breaker when generating a topological sort. But if you're
relaying on the exact same sort order there will be differences after
this PR. The second is that a lot of undocumented functionality in the
DAGCircuit which previously worked because of Python's implicit support
for interacting with data structures is no longer functional. For
example, previously the `DAGCircuit.qubits` list could be set directly
(as the circuit visualizers previously did), but this was never
documented as supported (and would corrupt the DAGCircuit). Any
functionality like this we'd have to explicit include in the Rust
implementation and as they were not included in the documented public
API this PR opted to remove the vast majority of this type of
functionality.

The last related thing might require future work to mitigate is that
this PR breaks the linkage between `DAGNode` and the underlying
`DAGCirucit` object. In the Python implementation the `DAGNode` objects
were stored directly in the `DAGCircuit` and when an API method returned
a `DAGNode` from the DAG it was a shared reference to the underlying
object in the `DAGCircuit`. This meant if you mutated the `DAGNode` it
would be reflected in the `DAGCircuit`. This was not always a sound
usage of the API as the `DAGCircuit` was implicitly caching many
attributes of the DAG and you should always be using the `DAGCircuit`
API to mutate any nodes to prevent any corruption of the `DAGCircuit`.
However, now as the underlying data store for nodes in the DAG are
no longer the python space objects returned by `DAGCircuit` methods
mutating a `DAGNode` will not make any change in the underlying
`DAGCircuit`. This can come as quite the surprise at first, especially
if you were relying on this side effect, even if it was unsound.

It's also worth noting that 2 large pieces of functionality from
rustworkx are included in this PR. These are the new files
`rustworkx_core_vnext` and `dot_utils` which are rustworkx's VF2
implementation and its dot file generation. As there was not a rust
interface exposed for this functionality from rustworkx-core there was
no way to use these functions in rustworkx. Until these interfaces
added to rustworkx-core in future releases we'll have to keep these
local copies. The vf2 implementation is in progress in
Qiskit/rustworkx#1235, but `dot_utils` might make sense to keep around
longer term as it is slightly modified from the upstream rustworkx
implementation to directly interface with `DAGCircuit` instead of a
generic graph.

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>
Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>
Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>
Co-authored-by: Alexander Ivrii <alexi@il.ibm.com>
Co-authored-by: Eli Arbel <46826214+eliarbel@users.noreply.github.com>
Co-authored-by: John Lapeyre <jlapeyre@users.noreply.github.com>
Co-authored-by: Jake Lishman <jake.lishman@ibm.com>

* Update visual mpl circuit drawer references

Right now there is a bug in the matplotlib circuit visualizer likely
caused by the new `__eq__` implementation for `DAGOpNode` that didn't
exist before were some gates are missing from the visualization. In the
interest of unblocking this PR this commit updates the references for
these cases temporarily until this issue is fixed.

* Ensure DAGNode.sort_key is always a string

Previously the sort_key attribute of the Python space DAGCircuit was
incorrectly being set to `None` for rust generated node objects. This
was done as for the default path the sort key is determined from the
rust domain's representation of qubits and there is no analogous data in
the Python object. However, this was indavertandly a breaking API change
as sort_key is expected to always be a string. This commit adds a
default string to use for all node types so that we always have a
reasonable value that matches the typing of the class. A future step is
likely to add back the `dag` kwarg to the node types and generate the
string on the fly from the rust space data.

* Make Python argument first in Param::eq and Param::is_close

The standard function signature convention for functions that take a
`py: Python` argument is to make the Python argument the first (or
second after `&self`). The `Param::eq` and `Param::is_close` methods
were not following this convention and had `py` as a later argument in
the signature. This commit corrects the oversight.

* Fix merge conflict with #12943

With the recent merge with main we pulled in #12943 which conflicted
with the rust space API changes made in this PR branch. This commit
updates the usage to conform with the new interface introduced in this
PR.

* Add release notes and test for invalid args on apply methods

This commit adds several release notes to document this change. This
includes a feature note to describe the high level change and the user
facing benefit (mainly reduced memory consumption for DAGCircuits),
two upgrade notes to document the differences with shared references
caused by the new data structure, and a fix note documenting the fix
for how qargs and cargs are handled on `.apply_operation_back()` and
`.apply_operation_front()`. Along with the fix note a new unit test is
added to serve as a regression test so that we don't accidentally allow
adding cargs as qargs and vice versa in the future.

* Restore `inplace` argument functionality for substitute_node()

This commit restores the functionality of the `inplace` argument for
`substitute_node()` and restores the tests validating the object
identity when using the flag. This flag was originally excluded from
the implementation because the Rust representation of the dag is not
a shared reference with Python space and the flag doesn't really mean
the same thing as there is always a second copy of the data for Python
space now. The implementation here is cheating slighty as we're passed
in the DAG node by reference it relies on that reference to update the
input node at the same time we update the dag. Unlike the previous
Python implementation where we were updating the node in place and the
`inplace` argument was slightly faster because everything was done by
reference. The rust space data is still a compressed copy of the data
we return to Python so the `inplace` flag will be slightly more
inefficient as we need to copy to update the Python space representation
in addition to the rust version.

* Revert needless dict() cast on metadata in dag_to_circuit()

This commit removes an unecessary `dict()` cast on the `dag.metadata`
when setting it on `QuantumCircuit.metadata` in
`qiskit.converters.dag_to_circuit()`. This slipped in at some point
during the development of this PR and it's not clear why, but it isn't
needed so this removes it.

* Add code comment for DAGOpNode.__eq__ parameter checking

This commit adds a small inline code comment to make it clear why we
skip parameter comparisons in DAGOpNode.__eq__ for python ops. It might
not be clear why the value is hard coded to `true` in this case, as this
check is done via Python so we don't need to duplicate it in rust space.

* Raise a ValueError on DAGNode creation with invalid index

This commit adds error checking to the DAGNode constructor to raise a
PyValueError if the input index is not valid (any index < -1).
Previously this would have panicked instead of raising a user catchable
error.

* Use macro argument to set python getter/setter name

This commit updates the function names for `get__node_id` and
`set__node_id` method to use a name that clippy is happy with and
leverage the pyo3 macros to set the python space name correctly instead
of using the implicit naming rules.

* Remove Ord and PartialOrd derives from interner::Index

The Ord and PartialOrd traits were originally added to the Index struct
so they could be used for the sort key in lexicographical topological
sorting. However, that approach was abandonded during the development of
this PR and instead the expanded Qubit and Clbit indices were used
instead. This left the ordering traits as unnecessary on Index and
potentially misleading. This commit just opts to remove them as they're
not needed anymore.

* Fix missing nodes in matplotlib drawer.

Previously, the change in equality for DAGNodes was causing nodes
to clobber eachother in the matplotlib drawer's tracking data
structures when used as keys to maps.

To fix this, we ensure that all nodes have a unique ID across
layers before constructing the matplotlib drawer. They actually
of course _do_ in the original DAG, but we don't really care
what the original IDs are, so we just make them up.

Writing to _node_id on a DAGNode may seem odd, but it exists
in the old Python API (prior to being ported to Rust) and
doesn't actually mutate the DAG at all since DAGNodes are
ephemeral.

* Revert "Update visual mpl circuit drawer references"

With the previous commit the bug in the matplotlib drawer causing the
images to diverge should be fixed. This commit reverts the change to the
reference images as there should be no difference now.

This reverts commit 1e4e6f386286b0b4e7f3ebd3f706f948dd707575.

* Update visual mpl circuit drawer references for control flow circuits

The earlier commit that "fixed" the drawers corrected the visualization
to match expectations in most cases. However after restoring the
references to what's on main several comparison tests with control flow
in the circuit were still failing. The failure mode looks similar to the
other cases, but across control flow blocks instead of at the circuit
level. This commit temporarily updates the references of these to the
state of what is generated currently to unblock CI. If/when we have a
fix this commit can be reverted.

* Apply suggestions from code review

Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>

* code review

* Fix edge cases in DAGOpNode.__eq__

This commit fixes a couple of edge cases in DAGOpNode.__eq__ method
around the python interaction for the method. The first is that in
the case where we had python object parameter types for the gates we
weren't comparing them at all. This is fixed so we use python object
equality for the params in this case. Then we were dropping the error
handling in the case of using python for equality, this fixes it to
return the error to users if the equality check fails. Finally a comment
is added to explain the expected use case for `DAGOpNode.__eq__` and why
parameter checking is more strict than elsewhere.

* Remove Param::add() for global phase addition

This commit removes the Param::add() method and instead adds a local
private function to the `dag_circuit` module for doing global phase
addition. Previously the `Param::add()` method was used solely for
adding global phase in `DAGCircuit` and it took some shortcuts knowing
that context. This made the method implementation ill suited as a
general implementation.

* More complete fix for matplotlib drawer.

* Revert "Update visual mpl circuit drawer references for control flow circuits"

This reverts commit 9a6f9536a3a7412d19a9fd9bbd761825c9a53d0f.

* Unify rayon versions in workspace

* Remove unused _GLOBAL_NID.

* Use global monotonic ID counter for ids in drawer

The fundamental issue with matplotlib visualizations of control flow is
that locally in the control flow block the nodes look the same but are
stored in an outer circuit dictionary. If the gates are the same and on
the same qubits and happen to have the same node id inside the different
control flow blocks the drawer would think it's already drawn the node
and skip it incorrectly. The previous fix for this didn't go far enough
because it wasn't accounting for the recursive execution of the drawer
for inner blocks (it also didn't account for LayerSpoolers of the same
length).

* Remove unused BitData iterator stuff.

* Fully port Optimize1qGatesDecomposition to Rust

This commit builds off of #12550 and the other data model in Rust
infrastructure and migrates the Optimize1qGatesDecomposition pass to
operate fully in Rust. The full path of the transpiler pass now never
leaves rust until it has finished modifying the DAGCircuit. There is
still some python interaction necessary to handle parts of the data
model that are still in Python, mainly calibrations and parameter
expressions (for global phase). But otherwise the entirety of the pass
operates in rust now.

This is just a first pass at the migration here, it moves the pass to be
a single for loop in rust. The next steps here are to look at operating
the pass in parallel. There is no data dependency between the
optimizations being done by the pass so we should be able to the
throughput of the pass by leveraging multithreading to handle each run
in parallel. This commit does not attempt this though, because of the
Python dependency and also the data structures around gates and the
dag aren't really setup for multithreading yet and there likely will
need to be some work to support that (this pass is a good candidate to
work through the bugs on that).

Part of #12208

* remove with_gil in favor of passing python tokens as params

* Apply suggestions from code review

Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>

* fmt

* python serialization

* deprecation

* Update commutation_checker.py

* heh

* init

* let Pytuple collect

* lint

* First set of comments

- use Qubit/Clbit
- more info on unsafe
- update reno
- use LazySet less
- use OperationRef, avoid CircuitInstruction creation

* Second part

- clippy
- no BigInt
- more comments

* Matrix speed & fix string sort

-- could not use op.name() directly since sorted differently than Python, hence it's back to BigInt

* have the Python implementation use Rust

* lint & tools

* remove unsafe blocks

* One more try to avoid segfaulty windows

-- if that doesn't work maybe revert the change the the Py CommChecker uses Rust

* Original version

Co-authored-by: Sebastian Brandhofer <148463728+sbrandhsn@users.noreply.github.com>

* Sync with updated CommutationChecker

todo: shouldn't make the qubits interner public

* Debug: disable cache

trying to figure out why the windows CI fails (after being unable to locally reproduce we're using CI with a reduced set of tests)

* ... second try

* Update crates/accelerate/src/commutation_checker.rs

Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>

* Restore azure config

* Remove unused import

* Revert "Debug: disable cache"

This reverts commit c564b806c9ff31d5faa6aa3f02c18cfe6a5ff2c5.

* Don't overallocate cache

We were allocating a the cache hashmap with a capacity for max cache
size entries every time we instantiated a new CommutationChecker. The
max cache size is 1 million. This meant we were allocating 162MB
everytime CommutationChecker.__new__ was called, which includes each
time we instantiate it manually (which happens once on import), the
CommutationAnalysis pass gets instantiated (twice per preset pass
manager created with level 2 or 3), or a commutation checker instance is
pickle deserialized. This ends up causing a fairly large memory
regression and is the source of the CI failures on windows.

Co-authored-by: Jake Lishman <jake.lishman@ibm.com>

* Cleanup parameter key type to handle edge conditions better

This commit cleans up the ParameterKey type and usage to make it handle
edge conditions better. The first is that the type just doesn't do the
right thing for NaN, -0, or the infinities. Canonicalization is added
for hash on -0 and the only constructor of the newtype adds a runtime
guard against NaN and inifinity (positive or negative) to avoid that
issue. The approach only makes sense as the cache is really there to
guard us against unnecessary re-computing when we reiterate over the
circuit > 1 time and nothing has changed for gates. Otherwise comparing
floats like done in this PR does would not be a sound or an effective
approach.

* Remove unnecessary cache hit rate tracking

* Undo test assertion changes

* Undo unrelated test changes

* Undo pending deprecation and unify commutation classes

This commit removes the pending deprecation decorator from the python
class definition as the Python class just internally is using the rust
implementation now. This also removes directly using the rust
implementation for the standard commutation library global as using the
python class is exactly the same now.

We can revisit if there is anything we want to deprecate and remove in
2.0 in a follow up PR. Personally, I think the cache management methods
are all we really want to remove as the cache should be an internal
implementation detail and not part of the public interface.

* Undo gha config changes

* Make serialization explicit

This commit makes the pickling of cache entries explicit. Previously it
was relying on conversion traits which hid some of the complexity but
this uses a pair of conversion functions instead.

* Remove stray SAFETY comment

* Remove ddt usage from the tests

Now that the python commutation checker and the rust commutation checker
are the same thing the ddt parameterization of the commutation checker
tests was unecessary duplication. This commit removes the ddt usage to
restore having a single run of all the tests.

* Update release note

* Fix CommutationChecker class import

* Remove invalid test assertion for no longer public attribute

* Ray's review comments

Co-authored-by: Raynel Sanchez <raynelfss@hotmail.com>

* Handle ``atol/rtol``, more error propagation

* update to latest changes in commchecker

* fix merge conflict remnants

* re-use expensive quantities

such as the relative placement and the parameter hash

* add missing header

* gentler error handling

* review comments & more docs

* Use vec over IndexSet + clippy

- vec<vec> is slightly faster than vec<indexset>
- add custom types to satisfies clippy's complex type complaint
- don't handle Clbit/Var

* Simplify python class construction

Since this PR was first written the split between the python side and
rust side of the CommutationChecker class has changed so that there are
no longer separate classes anymore. The implementations are unified and
the python space class just wraps an inner rust object. However, the
construction of the CommutationAnalysis pass was still written assuming
there was the possibility to get either a rust or Python object. This
commit fixes this and the type change on the `comm_checker` attribute by
removing the unnecessary logic.

---------

Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>
Co-authored-by: Kevin Hartman <kevin@hart.mn>
Co-authored-by: Matthew Treinish <mtreinish@kortar.org>
Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>
Co-authored-by: Alexander Ivrii <alexi@il.ibm.com>
Co-authored-by: Eli Arbel <46826214+eliarbel@users.noreply.github.com>
Co-authored-by: John Lapeyre <jlapeyre@users.noreply.github.com>
Co-authored-by: Jake Lishman <jake.lishman@ibm.com>
Co-authored-by: Julien Gacon <jules.gacon@googlemail.com>
Co-authored-by: Raynel Sanchez <raynelfss@hotmail.com>
---
 crates/accelerate/src/commutation_analysis.rs | 192 ++++++++++++++++++
 crates/accelerate/src/commutation_checker.rs  |   4 +-
 crates/accelerate/src/lib.rs                  |   1 +
 crates/circuit/src/dag_circuit.rs             |   2 +-
 crates/pyext/src/lib.rs                       |  19 +-
 qiskit/__init__.py                            |   1 +
 .../optimization/commutation_analysis.py      |  52 +----
 ...commutation-analysis-d2fc81feb6ca80aa.yaml |   4 +
 8 files changed, 214 insertions(+), 61 deletions(-)
 create mode 100644 crates/accelerate/src/commutation_analysis.rs
 create mode 100644 releasenotes/notes/oxidize-commutation-analysis-d2fc81feb6ca80aa.yaml

diff --git a/crates/accelerate/src/commutation_analysis.rs b/crates/accelerate/src/commutation_analysis.rs
new file mode 100644
index 000000000000..08fa1dda5ec9
--- /dev/null
+++ b/crates/accelerate/src/commutation_analysis.rs
@@ -0,0 +1,192 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// 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.
+
+use pyo3::exceptions::PyValueError;
+use pyo3::prelude::PyModule;
+use pyo3::{pyfunction, pymodule, wrap_pyfunction, Bound, PyResult, Python};
+use qiskit_circuit::Qubit;
+
+use crate::commutation_checker::CommutationChecker;
+use hashbrown::HashMap;
+use pyo3::prelude::*;
+
+use pyo3::types::{PyDict, PyList};
+use qiskit_circuit::dag_circuit::{DAGCircuit, NodeType, Wire};
+use rustworkx_core::petgraph::stable_graph::NodeIndex;
+
+// Custom types to store the commutation sets and node indices,
+// see the docstring below for more information.
+type CommutationSet = HashMap<Wire, Vec<Vec<NodeIndex>>>;
+type NodeIndices = HashMap<(NodeIndex, Wire), usize>;
+
+// the maximum number of qubits we check commutativity for
+const MAX_NUM_QUBITS: u32 = 3;
+
+/// Compute the commutation sets for a given DAG.
+///
+/// We return two HashMaps:
+///  * {wire: commutation_sets}: For each wire, we keep a vector of index sets, where each index
+///     set contains mutually commuting nodes. Note that these include the input and output nodes
+///     which do not commute with anything.
+///  * {(node, wire): index}: For each (node, wire) pair we store the index indicating in which
+///     commutation set the node appears on a given wire.
+///
+/// For example, if we have a circuit
+///
+///     |0> -- X -- SX -- Z (out)
+///      0     2    3     4   1   <-- node indices including input (0) and output (1) nodes
+///
+/// Then we would have
+///
+///     commutation_set = {0: [[0], [2, 3], [4], [1]]}
+///     node_indices = {(0, 0): 0, (1, 0): 3, (2, 0): 1, (3, 0): 1, (4, 0): 2}
+///
+fn analyze_commutations_inner(
+    py: Python,
+    dag: &mut DAGCircuit,
+    commutation_checker: &mut CommutationChecker,
+) -> PyResult<(CommutationSet, NodeIndices)> {
+    let mut commutation_set: CommutationSet = HashMap::new();
+    let mut node_indices: NodeIndices = HashMap::new();
+
+    for qubit in 0..dag.num_qubits() {
+        let wire = Wire::Qubit(Qubit(qubit as u32));
+
+        for current_gate_idx in dag.nodes_on_wire(py, &wire, false) {
+            // get the commutation set associated with the current wire, or create a new
+            // index set containing the current gate
+            let commutation_entry = commutation_set
+                .entry(wire.clone())
+                .or_insert_with(|| vec![vec![current_gate_idx]]);
+
+            // we can unwrap as we know the commutation entry has at least one element
+            let last = commutation_entry.last_mut().unwrap();
+
+            // if the current gate index is not in the set, check whether it commutes with
+            // the previous nodes -- if yes, add it to the commutation set
+            if !last.contains(&current_gate_idx) {
+                let mut all_commute = true;
+
+                for prev_gate_idx in last.iter() {
+                    // if the node is an input/output node, they do not commute, so we only
+                    // continue if the nodes are operation nodes
+                    if let (NodeType::Operation(packed_inst0), NodeType::Operation(packed_inst1)) =
+                        (&dag.dag[current_gate_idx], &dag.dag[*prev_gate_idx])
+                    {
+                        let op1 = packed_inst0.op.view();
+                        let op2 = packed_inst1.op.view();
+                        let params1 = packed_inst0.params_view();
+                        let params2 = packed_inst1.params_view();
+                        let qargs1 = dag.get_qargs(packed_inst0.qubits);
+                        let qargs2 = dag.get_qargs(packed_inst1.qubits);
+                        let cargs1 = dag.get_cargs(packed_inst0.clbits);
+                        let cargs2 = dag.get_cargs(packed_inst1.clbits);
+
+                        all_commute = commutation_checker.commute_inner(
+                            py,
+                            &op1,
+                            params1,
+                            packed_inst0.extra_attrs.as_deref(),
+                            qargs1,
+                            cargs1,
+                            &op2,
+                            params2,
+                            packed_inst1.extra_attrs.as_deref(),
+                            qargs2,
+                            cargs2,
+                            MAX_NUM_QUBITS,
+                        )?;
+                        if !all_commute {
+                            break;
+                        }
+                    } else {
+                        all_commute = false;
+                        break;
+                    }
+                }
+
+                if all_commute {
+                    // all commute, add to current list
+                    last.push(current_gate_idx);
+                } else {
+                    // does not commute, create new list
+                    commutation_entry.push(vec![current_gate_idx]);
+                }
+            }
+
+            node_indices.insert(
+                (current_gate_idx, wire.clone()),
+                commutation_entry.len() - 1,
+            );
+        }
+    }
+
+    Ok((commutation_set, node_indices))
+}
+
+#[pyfunction]
+#[pyo3(signature = (dag, commutation_checker))]
+pub(crate) fn analyze_commutations(
+    py: Python,
+    dag: &mut DAGCircuit,
+    commutation_checker: &mut CommutationChecker,
+) -> PyResult<Py<PyDict>> {
+    // This returns two HashMaps:
+    //   * The commuting nodes per wire: {wire: [commuting_nodes_1, commuting_nodes_2, ...]}
+    //   * The index in which commutation set a given node is located on a wire: {(node, wire): index}
+    // The Python dict will store both of these dictionaries in one.
+    let (commutation_set, node_indices) = analyze_commutations_inner(py, dag, commutation_checker)?;
+
+    let out_dict = PyDict::new_bound(py);
+
+    // First set the {wire: [commuting_nodes_1, ...]} bit
+    for (wire, commutations) in commutation_set {
+        // we know all wires are of type Wire::Qubit, since in analyze_commutations_inner
+        // we only iterater over the qubits
+        let py_wire = match wire {
+            Wire::Qubit(q) => dag.qubits.get(q).unwrap().to_object(py),
+            _ => return Err(PyValueError::new_err("Unexpected wire type.")),
+        };
+
+        out_dict.set_item(
+            py_wire,
+            PyList::new_bound(
+                py,
+                commutations.iter().map(|inner| {
+                    PyList::new_bound(
+                        py,
+                        inner
+                            .iter()
+                            .map(|node_index| dag.get_node(py, *node_index).unwrap()),
+                    )
+                }),
+            ),
+        )?;
+    }
+
+    // Then we add the {(node, wire): index} dictionary
+    for ((node_index, wire), index) in node_indices {
+        let py_wire = match wire {
+            Wire::Qubit(q) => dag.qubits.get(q).unwrap().to_object(py),
+            _ => return Err(PyValueError::new_err("Unexpected wire type.")),
+        };
+        out_dict.set_item((dag.get_node(py, node_index)?, py_wire), index)?;
+    }
+
+    Ok(out_dict.unbind())
+}
+
+#[pymodule]
+pub fn commutation_analysis(m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_wrapped(wrap_pyfunction!(analyze_commutations))?;
+    Ok(())
+}
diff --git a/crates/accelerate/src/commutation_checker.rs b/crates/accelerate/src/commutation_checker.rs
index 6fd9d58a7c23..b00d7c624c92 100644
--- a/crates/accelerate/src/commutation_checker.rs
+++ b/crates/accelerate/src/commutation_checker.rs
@@ -69,7 +69,7 @@ where
 /// lookups. It's not meant to be a public facing Python object though and only used
 /// internally by the Python class.
 #[pyclass(module = "qiskit._accelerate.commutation_checker")]
-struct CommutationChecker {
+pub struct CommutationChecker {
     library: CommutationLibrary,
     cache_max_entries: usize,
     cache: HashMap<(String, String), CommutationCacheEntry>,
@@ -227,7 +227,7 @@ impl CommutationChecker {
 
 impl CommutationChecker {
     #[allow(clippy::too_many_arguments)]
-    fn commute_inner(
+    pub fn commute_inner(
         &mut self,
         py: Python,
         op1: &OperationRef,
diff --git a/crates/accelerate/src/lib.rs b/crates/accelerate/src/lib.rs
index 3a8c4bf51071..6561dd258614 100644
--- a/crates/accelerate/src/lib.rs
+++ b/crates/accelerate/src/lib.rs
@@ -15,6 +15,7 @@ use std::env;
 use pyo3::import_exception;
 
 pub mod circuit_library;
+pub mod commutation_analysis;
 pub mod commutation_checker;
 pub mod convert_2q_block_matrix;
 pub mod dense_layout;
diff --git a/crates/circuit/src/dag_circuit.rs b/crates/circuit/src/dag_circuit.rs
index 90a4c75408fa..fdaa81e3b4ca 100644
--- a/crates/circuit/src/dag_circuit.rs
+++ b/crates/circuit/src/dag_circuit.rs
@@ -5530,7 +5530,7 @@ impl DAGCircuit {
     /// Get the nodes on the given wire.
     ///
     /// Note: result is empty if the wire is not in the DAG.
-    fn nodes_on_wire(&self, py: Python, wire: &Wire, only_ops: bool) -> Vec<NodeIndex> {
+    pub fn nodes_on_wire(&self, py: Python, wire: &Wire, only_ops: bool) -> Vec<NodeIndex> {
         let mut nodes = Vec::new();
         let mut current_node = match wire {
             Wire::Qubit(qubit) => self.qubit_io_map.get(qubit.0 as usize).map(|x| x[0]),
diff --git a/crates/pyext/src/lib.rs b/crates/pyext/src/lib.rs
index 24a4badf6539..fdb2bff9a21d 100644
--- a/crates/pyext/src/lib.rs
+++ b/crates/pyext/src/lib.rs
@@ -13,15 +13,15 @@
 use pyo3::prelude::*;
 
 use qiskit_accelerate::{
-    circuit_library::circuit_library, commutation_checker::commutation_checker,
-    convert_2q_block_matrix::convert_2q_block_matrix, dense_layout::dense_layout,
-    error_map::error_map, euler_one_qubit_decomposer::euler_one_qubit_decomposer,
-    isometry::isometry, nlayout::nlayout, optimize_1q_gates::optimize_1q_gates,
-    pauli_exp_val::pauli_expval, results::results, sabre::sabre, sampled_exp_val::sampled_exp_val,
-    sparse_pauli_op::sparse_pauli_op, star_prerouting::star_prerouting,
-    stochastic_swap::stochastic_swap, synthesis::synthesis, target_transpiler::target,
-    two_qubit_decompose::two_qubit_decompose, uc_gate::uc_gate, utils::utils,
-    vf2_layout::vf2_layout,
+    circuit_library::circuit_library, commutation_analysis::commutation_analysis,
+    commutation_checker::commutation_checker, convert_2q_block_matrix::convert_2q_block_matrix,
+    dense_layout::dense_layout, error_map::error_map,
+    euler_one_qubit_decomposer::euler_one_qubit_decomposer, isometry::isometry, nlayout::nlayout,
+    optimize_1q_gates::optimize_1q_gates, pauli_exp_val::pauli_expval, results::results,
+    sabre::sabre, sampled_exp_val::sampled_exp_val, sparse_pauli_op::sparse_pauli_op,
+    star_prerouting::star_prerouting, stochastic_swap::stochastic_swap, synthesis::synthesis,
+    target_transpiler::target, two_qubit_decompose::two_qubit_decompose, uc_gate::uc_gate,
+    utils::utils, vf2_layout::vf2_layout,
 };
 
 #[inline(always)]
@@ -62,5 +62,6 @@ fn _accelerate(m: &Bound<PyModule>) -> PyResult<()> {
     add_submodule(m, utils, "utils")?;
     add_submodule(m, vf2_layout, "vf2_layout")?;
     add_submodule(m, commutation_checker, "commutation_checker")?;
+    add_submodule(m, commutation_analysis, "commutation_analysis")?;
     Ok(())
 }
diff --git a/qiskit/__init__.py b/qiskit/__init__.py
index 67384b38971a..38a9f5952425 100644
--- a/qiskit/__init__.py
+++ b/qiskit/__init__.py
@@ -87,6 +87,7 @@
 sys.modules["qiskit._accelerate.synthesis.linear"] = _accelerate.synthesis.linear
 sys.modules["qiskit._accelerate.synthesis.clifford"] = _accelerate.synthesis.clifford
 sys.modules["qiskit._accelerate.commutation_checker"] = _accelerate.commutation_checker
+sys.modules["qiskit._accelerate.commutation_analysis"] = _accelerate.commutation_analysis
 sys.modules["qiskit._accelerate.synthesis.linear_phase"] = _accelerate.synthesis.linear_phase
 
 from qiskit.exceptions import QiskitError, MissingOptionalLibraryError
diff --git a/qiskit/transpiler/passes/optimization/commutation_analysis.py b/qiskit/transpiler/passes/optimization/commutation_analysis.py
index 12ed7145eec7..d801e4775937 100644
--- a/qiskit/transpiler/passes/optimization/commutation_analysis.py
+++ b/qiskit/transpiler/passes/optimization/commutation_analysis.py
@@ -12,11 +12,9 @@
 
 """Analysis pass to find commutation relations between DAG nodes."""
 
-from collections import defaultdict
-
 from qiskit.circuit.commutation_library import SessionCommutationChecker as scc
-from qiskit.dagcircuit import DAGOpNode
 from qiskit.transpiler.basepasses import AnalysisPass
+from qiskit._accelerate.commutation_analysis import analyze_commutations
 
 
 class CommutationAnalysis(AnalysisPass):
@@ -33,6 +31,7 @@ def __init__(self, *, _commutation_checker=None):
         # do not care about commutations of all gates, but just a subset
         if _commutation_checker is None:
             _commutation_checker = scc
+
         self.comm_checker = _commutation_checker
 
     def run(self, dag):
@@ -42,49 +41,4 @@ def run(self, dag):
         into the ``property_set``.
         """
         # Initiate the commutation set
-        self.property_set["commutation_set"] = defaultdict(list)
-
-        # Build a dictionary to keep track of the gates on each qubit
-        # The key with format (wire) will store the lists of commutation sets
-        # The key with format (node, wire) will store the index of the commutation set
-        # on the specified wire, thus, for example:
-        # self.property_set['commutation_set'][wire][(node, wire)] will give the
-        # commutation set that contains node.
-
-        for wire in dag.qubits:
-            self.property_set["commutation_set"][wire] = []
-
-        # Add edges to the dictionary for each qubit
-        for node in dag.topological_op_nodes():
-            for _, _, edge_wire in dag.edges(node):
-                self.property_set["commutation_set"][(node, edge_wire)] = -1
-
-        # Construct the commutation set
-        for wire in dag.qubits:
-
-            for current_gate in dag.nodes_on_wire(wire):
-
-                current_comm_set = self.property_set["commutation_set"][wire]
-                if not current_comm_set:
-                    current_comm_set.append([current_gate])
-
-                if current_gate not in current_comm_set[-1]:
-                    does_commute = True
-
-                    # Check if the current gate commutes with all the gates in the current block
-                    for prev_gate in current_comm_set[-1]:
-                        does_commute = (
-                            isinstance(current_gate, DAGOpNode)
-                            and isinstance(prev_gate, DAGOpNode)
-                            and self.comm_checker.commute_nodes(current_gate, prev_gate)
-                        )
-                        if not does_commute:
-                            break
-
-                    if does_commute:
-                        current_comm_set[-1].append(current_gate)
-                    else:
-                        current_comm_set.append([current_gate])
-
-                temp_len = len(current_comm_set)
-                self.property_set["commutation_set"][(current_gate, wire)] = temp_len - 1
+        self.property_set["commutation_set"] = analyze_commutations(dag, self.comm_checker.cc)
diff --git a/releasenotes/notes/oxidize-commutation-analysis-d2fc81feb6ca80aa.yaml b/releasenotes/notes/oxidize-commutation-analysis-d2fc81feb6ca80aa.yaml
new file mode 100644
index 000000000000..967a65bcebab
--- /dev/null
+++ b/releasenotes/notes/oxidize-commutation-analysis-d2fc81feb6ca80aa.yaml
@@ -0,0 +1,4 @@
+---
+features_transpiler:
+  - |
+    Added a Rust implementation of :class:`.CommutationAnalysis` in :func:`.analyze_commutations`.

From 52733ae09f7ac9d2d5e2a674970ff95301d34bd6 Mon Sep 17 00:00:00 2001
From: Matthew Treinish <mtreinish@kortar.org>
Date: Thu, 5 Sep 2024 04:20:32 -0400
Subject: [PATCH 48/85] Adjust graphviz options for better layout with
 plot_gate_map() (#12770)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Adjust graphviz options for better layout with plot_gate_map()

This commit fixes an issue with the visualizations of some
backends/coupling maps. The default neato settings worked well in most
cases but for some graphs it was not generating a good layout. This
tweaks the settings a bit so that layouts work with more classes of
graphs.

* Don't set graph attributes if qubit_coordinates is set

* adjust sizes

* planar branching

* support for backendv1

* remove the formula

* new ref images

---------

Co-authored-by: Luciano Bello <bel@zurich.ibm.com>
Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>
---
 qiskit/visualization/gate_map.py              |  34 ++++++++++++++----
 ...djust-neato-settings-3adcc0ae9e245ce9.yaml |   6 ++++
 .../graph/references/16_qubit_gate_map.png    | Bin 37221 -> 26909 bytes
 .../graph/references/27_qubit_gate_map.png    | Bin 54334 -> 39631 bytes
 .../mpl/graph/references/5_qubit_gate_map.png | Bin 8766 -> 8722 bytes
 .../graph/references/65_qubit_gate_map.png    | Bin 135197 -> 98456 bytes
 .../mpl/graph/references/7_qubit_gate_map.png | Bin 12001 -> 9122 bytes
 .../graph/references/bloch_multivector.png    | Bin 72475 -> 72475 bytes
 ...bloch_multivector_figsize_improvements.png | Bin 70591 -> 70588 bytes
 test/visual/mpl/graph/references/figsize.png  | Bin 8766 -> 8722 bytes
 .../mpl/graph/references/font_color.png       | Bin 136101 -> 100497 bytes
 test/visual/mpl/graph/references/hinton.png   | Bin 6395 -> 6395 bytes
 .../visual/mpl/graph/references/histogram.png | Bin 9520 -> 10300 bytes
 .../references/histogram_2_sets_with_rest.png | Bin 10759 -> 12343 bytes
 .../mpl/graph/references/histogram_color.png  | Bin 9576 -> 10353 bytes
 .../references/histogram_desc_value_sort.png  | Bin 14378 -> 18290 bytes
 .../graph/references/histogram_hamming.png    | Bin 11864 -> 12642 bytes
 .../mpl/graph/references/histogram_legend.png | Bin 12162 -> 14197 bytes
 .../references/histogram_multiple_colors.png  | Bin 10558 -> 13587 bytes
 .../mpl/graph/references/histogram_title.png  | Bin 10495 -> 12343 bytes
 .../graph/references/histogram_value_sort.png | Bin 14301 -> 18148 bytes
 .../graph/references/histogram_with_rest.png  | Bin 9881 -> 10806 bytes
 .../mpl/graph/references/line_color.png       | Bin 144577 -> 105685 bytes
 test/visual/mpl/graph/references/paulivec.png | Bin 17133 -> 17133 bytes
 test/visual/mpl/graph/references/qsphere.png  | Bin 40227 -> 40227 bytes
 .../mpl/graph/references/qubit_color.png      | Bin 12473 -> 9581 bytes
 .../mpl/graph/references/qubit_labels.png     | Bin 11018 -> 8830 bytes
 .../mpl/graph/references/qubit_size.png       | Bin 9109 -> 10307 bytes
 .../mpl/graph/references/state_city.png       | Bin 106823 -> 108666 bytes
 .../mpl/graph/test_graph_matplotlib_drawer.py |  12 +++----
 30 files changed, 40 insertions(+), 12 deletions(-)
 create mode 100644 releasenotes/notes/adjust-neato-settings-3adcc0ae9e245ce9.yaml

diff --git a/qiskit/visualization/gate_map.py b/qiskit/visualization/gate_map.py
index b950c84c902a..eb20623f0c8c 100644
--- a/qiskit/visualization/gate_map.py
+++ b/qiskit/visualization/gate_map.py
@@ -945,6 +945,7 @@ def plot_gate_map(
         font_color,
         ax,
         filename,
+        planar=rx.is_planar(coupling_map.graph.to_undirected(multigraph=False)),
     )
 
 
@@ -966,6 +967,8 @@ def plot_coupling_map(
     font_color="white",
     ax=None,
     filename=None,
+    *,
+    planar=True,
 ):
     """Plots an arbitrary coupling map of qubits (embedded in a plane).
 
@@ -987,6 +990,7 @@ def plot_coupling_map(
         font_color (str): The font color for the qubit labels.
         ax (Axes): A Matplotlib axes instance.
         filename (str): file path to save image to.
+        planar (bool): If the coupling map is planar or not. Default: ``True`` (i.e. it is planar)
 
     Returns:
         Figure: A Matplotlib figure instance.
@@ -1057,7 +1061,14 @@ def plot_coupling_map(
 
     if font_size is None:
         max_characters = max(1, max(len(str(x)) for x in qubit_labels))
-        font_size = max(int(20 / max_characters), 1)
+        if max_characters == 1:
+            font_size = 20
+        elif max_characters == 2:
+            font_size = 14
+        elif max_characters == 3:
+            font_size = 12
+        else:
+            font_size = 1
 
     def color_node(node):
         if qubit_coordinates:
@@ -1065,8 +1076,6 @@ def color_node(node):
                 "label": str(qubit_labels[node]),
                 "color": f'"{qubit_color[node]}"',
                 "fillcolor": f'"{qubit_color[node]}"',
-                "style": "filled",
-                "shape": "circle",
                 "pos": f'"{qubit_coordinates[node][0]},{qubit_coordinates[node][1]}"',
                 "pin": "True",
             }
@@ -1075,11 +1084,11 @@ def color_node(node):
                 "label": str(qubit_labels[node]),
                 "color": f'"{qubit_color[node]}"',
                 "fillcolor": f'"{qubit_color[node]}"',
-                "style": "filled",
-                "shape": "circle",
             }
+        out_dict["style"] = "filled"
+        out_dict["shape"] = "circle"
         out_dict["fontcolor"] = f'"{font_color}"'
-        out_dict["fontsize"] = str(font_size)
+        out_dict["fontsize"] = f'"{str(font_size)}!"'
         out_dict["height"] = str(qubit_size * px)
         out_dict["fixedsize"] = "True"
         out_dict["fontname"] = '"DejaVu Sans"'
@@ -1093,9 +1102,22 @@ def color_edge(edge):
         }
         return out_dict
 
+    graph_attributes = None
+    if not qubit_coordinates:
+        if planar:
+            graph_attributes = {
+                "overlap_scaling": "-7",
+                "overlap": "prism",
+                "model": "subset",
+            }
+        else:
+            graph_attributes = {
+                "overlap": "true",
+            }
     plot = graphviz_draw(
         graph,
         method="neato",
+        graph_attr=graph_attributes,
         node_attr_fn=color_node,
         edge_attr_fn=color_edge,
         filename=filename,
diff --git a/releasenotes/notes/adjust-neato-settings-3adcc0ae9e245ce9.yaml b/releasenotes/notes/adjust-neato-settings-3adcc0ae9e245ce9.yaml
new file mode 100644
index 000000000000..9dec5debb2ef
--- /dev/null
+++ b/releasenotes/notes/adjust-neato-settings-3adcc0ae9e245ce9.yaml
@@ -0,0 +1,6 @@
+---
+fixes:
+  - |
+    Fixes an issue with the visualizations of some backends/coupling maps that showed as folded on their own. The
+    `default ``neato`` setting <https://graphviz.org/docs/layouts/neato/>`_ works well in most cases. However,
+    ``prism`` overlap returns a more regular layout for other scenarios.
diff --git a/test/visual/mpl/graph/references/16_qubit_gate_map.png b/test/visual/mpl/graph/references/16_qubit_gate_map.png
index c76baabf152238ad114b5951d85f6c869cbd4d59..722b1db9152393ec37d2d13a02e72a2c4a4f0cf5 100644
GIT binary patch
literal 26909
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
U3x)52|2smG7FQ4}6EO<-e{_hiApigX

literal 37221
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
KVqb5I&-e$#QzRw;

diff --git a/test/visual/mpl/graph/references/27_qubit_gate_map.png b/test/visual/mpl/graph/references/27_qubit_gate_map.png
index 73ef08c1c3a8cee2440f2f2dca21e2407a805a04..59ed9d8d5cfc44274bfd534c5fb2e2592e36f9e5 100644
GIT binary patch
literal 39631
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
J=(bJR{{h{tYa##u

literal 54334
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
A^Z)<=

diff --git a/test/visual/mpl/graph/references/5_qubit_gate_map.png b/test/visual/mpl/graph/references/5_qubit_gate_map.png
index 3d89cdaf9950489fe22813251188b51d4b82d494..557901f7e9be18c9c66f4ab964435a143a59d643 100644
GIT binary patch
literal 8722
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

literal 8766
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

diff --git a/test/visual/mpl/graph/references/65_qubit_gate_map.png b/test/visual/mpl/graph/references/65_qubit_gate_map.png
index 1e99ced00400a97c3c53b80951257eb6dc7669ff..182d7c333bbbfd5c47e786b0b43ca3673fe3edbe 100644
GIT binary patch
literal 98456
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
MN$XjKf@R460cRZB5&!@I

literal 135197
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

diff --git a/test/visual/mpl/graph/references/7_qubit_gate_map.png b/test/visual/mpl/graph/references/7_qubit_gate_map.png
index 1413da0a7c4733ef0c4c38d3d1dc9b1b36bca548..4a0ed4fe2d51bfebe8f1e493bddf9b5fe9585908 100644
GIT binary patch
literal 9122
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

literal 12001
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
N+H);P^;4_x{{#1BwSxcv

diff --git a/test/visual/mpl/graph/references/bloch_multivector.png b/test/visual/mpl/graph/references/bloch_multivector.png
index 5b72a9d0489622dc8337922a0bd6e696fac2cdac..896e513ef36849c1bf2e483f725f160286449bc9 100644
GIT binary patch
delta 46
zcmbQejb-*WmI)qmraB54B_##LR{Hw6i6sR&`6W4-NqYH3>G~h%&5LYI+nUC>RSE!`
Cz7iq;

delta 46
zcmbQejb-*WmI)qmhB^uvB_##LR{Hw6i6sR&`6W4-NqYH3>H4?1INBT2wx%&|l>z{e
Cnh^{D

diff --git a/test/visual/mpl/graph/references/bloch_multivector_figsize_improvements.png b/test/visual/mpl/graph/references/bloch_multivector_figsize_improvements.png
index 80e73131a39b8b9a211f4d04187c426c7bd74963..5f5ba75d9428d1940aa8f3157c4aa819e3ef9841 100644
GIT binary patch
delta 43901
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

delta 43905
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
AVgLXD

diff --git a/test/visual/mpl/graph/references/figsize.png b/test/visual/mpl/graph/references/figsize.png
index 3d89cdaf9950489fe22813251188b51d4b82d494..557901f7e9be18c9c66f4ab964435a143a59d643 100644
GIT binary patch
literal 8722
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

literal 8766
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

diff --git a/test/visual/mpl/graph/references/font_color.png b/test/visual/mpl/graph/references/font_color.png
index a53f93fa4fe28d9f3dd7364938fa8421d71ac797..3e132fff5be45016d5dba9cb0e18968888445650 100644
GIT binary patch
literal 100497
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
WrP^;7ot|I-A0>J9ca^ec!T$@|8}cat

literal 136101
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

diff --git a/test/visual/mpl/graph/references/hinton.png b/test/visual/mpl/graph/references/hinton.png
index 3be80df31480e23a10c39dce9ad262b740f0d4cb..70521af917c515239fb4d5df8975c61adbc04bfa 100644
GIT binary patch
delta 41
xcmexu_}g%Thn%U7LPkkRL9vy-er{q(K~8>2PG*u`eo?yq$9eN2H>ORM0036J5W)Ze

delta 41
wcmexu_}g%Thn%5~LPkkRL9vy-er{q(K~8>2PG*u`eo?yqZ7z=XjcHRQ08ZKutN;K2

diff --git a/test/visual/mpl/graph/references/histogram.png b/test/visual/mpl/graph/references/histogram.png
index 3fa51ec644ed42d104da395a1129123f0a5035e5..8167908c1ba30af8f5638acda9b50aa8c29ae1b0 100644
GIT binary patch
literal 10300
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
Ov!fQ@<^A>C<^Kale6<z;

literal 9520
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
M&Oa3Y?bI*-30PIS?EnA(

diff --git a/test/visual/mpl/graph/references/histogram_2_sets_with_rest.png b/test/visual/mpl/graph/references/histogram_2_sets_with_rest.png
index fe11f5811931bfca5c8bfe280404ed33a8a78f40..fc6d8497b8678c4c1babda81a3c5192e0dd72b26 100644
GIT binary patch
literal 12343
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
Nyrp_G_lEhO{|h7^yTkwh

literal 10759
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

diff --git a/test/visual/mpl/graph/references/histogram_color.png b/test/visual/mpl/graph/references/histogram_color.png
index 34f7d449616ad7c824ef8c54f44797453935c8a2..57a1cbabc1c0cd365d16a0695589b718ae9533ca 100644
GIT binary patch
literal 10353
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

literal 9576
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

diff --git a/test/visual/mpl/graph/references/histogram_desc_value_sort.png b/test/visual/mpl/graph/references/histogram_desc_value_sort.png
index b119ae2deed4c439943ca252494b4c26c48b69a3..71f87047479ae081cc09198447821b7bc741c18a 100644
GIT binary patch
literal 18290
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
M$()Qoe(~o21wPebv;Y7A

literal 14378
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

diff --git a/test/visual/mpl/graph/references/histogram_hamming.png b/test/visual/mpl/graph/references/histogram_hamming.png
index 95bfe0ab1049e8b49ff40cb81e04be4c218b6e85..0fdca0e5342ff65e4d236187069f770846c44c6a 100644
GIT binary patch
literal 12642
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
P5+f(0bR*-M$>aY3AP@s+

literal 11864
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

diff --git a/test/visual/mpl/graph/references/histogram_legend.png b/test/visual/mpl/graph/references/histogram_legend.png
index 77fbe9c5dc0f947fe9c8bdfea9211fddaa6c4a8d..0cb218e12528289c8071de0edb60be94c30877b9 100644
GIT binary patch
literal 14197
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

literal 12162
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

diff --git a/test/visual/mpl/graph/references/histogram_multiple_colors.png b/test/visual/mpl/graph/references/histogram_multiple_colors.png
index 7edbfc07bab5f69ed68e8d9ccfbfe0d57b3d7f7e..0ee70ac4360ce928ae937e584fc33361c92372c1 100644
GIT binary patch
literal 13587
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
VjAVD4dq8P01$mXrnSYqv`zJaGaQ6TJ

literal 10558
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
B8an_0

diff --git a/test/visual/mpl/graph/references/histogram_title.png b/test/visual/mpl/graph/references/histogram_title.png
index c4c6859c8f2eed7af9ea8bd0cdf9a717572a2017..84e486d45e483c5135f74c9e6c934f068a6e42c6 100644
GIT binary patch
literal 12343
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

literal 10495
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

diff --git a/test/visual/mpl/graph/references/histogram_value_sort.png b/test/visual/mpl/graph/references/histogram_value_sort.png
index e44d08e0d9f922f5b8180e92d924d3795a951487..5f9c93e205ff3ba5ebd6349eb0735bdb7c1d7c93 100644
GIT binary patch
literal 18148
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
BYuf+-

literal 14301
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
R3%8acE+Ta?;rz9G{|#|86IlQN

diff --git a/test/visual/mpl/graph/references/histogram_with_rest.png b/test/visual/mpl/graph/references/histogram_with_rest.png
index 69633c1e4fdbbb4c90a2e76b69b880ba403bc58b..e1fe47fe2ba26ab24165310b5a5b4fb8a907ac3d 100644
GIT binary patch
literal 10806
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

literal 9881
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

diff --git a/test/visual/mpl/graph/references/line_color.png b/test/visual/mpl/graph/references/line_color.png
index 392c42fbd3ae56d5463352c5d2aa61c038fe07ed..a7813e0ea07ee1ac6110a2586cba30f11a93c1ca 100644
GIT binary patch
literal 105685
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
Hu0mjf=K2uv

literal 144577
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

diff --git a/test/visual/mpl/graph/references/paulivec.png b/test/visual/mpl/graph/references/paulivec.png
index 813a387265b183b700cb17ebb961b41224a2f1a5..0a0912c5cb3da5aae7ed6ca1ef4a57e75994dc28 100644
GIT binary patch
delta 43
zcmaFc%J{aGae{}Osg6QMNl8JmmA-y%Vo5<xeo0Pdl3spMy8g#`^CCB<wL1X-aH$b&

delta 43
ycmaFc%J{aGae{}Ok&Z$}Nl8JmmA-y%Vo5<xeo0Pdl3spMy1r)Y)B25R?M?t{q!7&j

diff --git a/test/visual/mpl/graph/references/qsphere.png b/test/visual/mpl/graph/references/qsphere.png
index f344accd2856b8d32c79b9b014ad8a38793a248b..d687e7c8871d30e57785ba6ec5822e73cdd5a2e8 100644
GIT binary patch
delta 43
zcmZ3yi)ryLrU@Q$raB54B_##LR{Hw6i6sR&`6W4-NqYH3>G~h%&5PWaws#HyYK0Nh

delta 43
zcmZ3yi)ryLrU@Q$hB^uvB_##LR{Hw6i6sR&`6W4-NqYH3>H4?1INCR+?VSSvVxthg

diff --git a/test/visual/mpl/graph/references/qubit_color.png b/test/visual/mpl/graph/references/qubit_color.png
index c4669adfa79956bbea2676447bfc70dc3bc3fa2b..789e1c71278e046da566c1218faf74211ec203a7 100644
GIT binary patch
literal 9581
zcmXYX1yoes_x8{o!q5mv4obI_)X*`cNC*f@NJ%#{q%t(pJv1oY9TL(Y2+~S-cm41C
z{k}D8%{_6?+2@|S?>_r^_WlCXR3gHs#Rq{vL@LS(I>5CT1VRJhVgn@%yJ~shg8fcS
zNdffu-!G@FC;<dw0;wp->Um}CXL|dQyWjM``e`+%<MX8sD})jvs-uS~TT4Hfiz?26
zKftj}O<T>HBXYQ0AfLTj;5-EAg9RvDB%BG><irK5GT{z)sjY?OD8*mjACvxKPq2y~
zRu>;R4QM-2O&RvvEE(lk-hHVa&#Gchy}>)2D+0GDrRBm8`-FgY@$neSIe;*78mX`D
zJy#Z9<`m-=zadvv2BnE$k&(+gn9g>ga4F{N(M~rp9&Z_)w@6oP+gLd9wx$WZt}J{S
zjvfWR^B?adjQTxF@qHjX+O2>?(AU@7E2<1ZWfaPq*ox7Z562`-0y@6NJz&bvxAYR&
zgml>7jB!#%;3JfV5<#H+LiCysXf!l-Mgu0H9CJRE_B63s#P+i?J^3<NXybKFO)@j(
zo%2p*)-0z~T=?Hpg$cHP;WWCbT*GWH9m!%?C;WOS(upeP5fga`j_mxgNV`f%t<?nc
z%5nd8uKvwRG(FyeS6;R2zQ;<(Bi36#erGxwQ7_G03f~LR{`@b@H`{^#48FrnTed7-
z1u_)t;)wZC+bqo9y0eoXWk1G(Qgi-h$q}fkAp-6*<eAuT(TVDqnc<&S;krd%m$l;I
zMcGM=cKiW7sPQ09U7Na}cKQJ$uO9JgKjK)upE!Sb*MQLzejE676&oq%z+(bp*En$s
zEqNojG9tR&6>y^Rp4{d2Hv{u?JM&e=$BOsQyHK$7R6#^M+4^Ssh?|BUn9qT>^1a&1
zWxXNXbD8MQ2OETx^Zzh>RFUlU;Js2mZ$r#)r{{cGZ}ih4KZmK&qnn;GG%Z6CZ*RH6
z&m}VnyY-yXKj7dctq&G*k@)UR_h>(ap9^33=WzbtSTc3?9eq?Df=vzHi=3{KC54~w
zPTRgvx6m&B`Eb9sRuuBL2f<?sM^YiIv-QWqPF&0n-=5DA$Qy#~;**Q)*CE1*2F0M2
z^BDv=$5h?wmbUvmfgsSSqnAINX}M>}Btkjc{`BgyW4a-)(ePfR2bU5GQC7~m^w_s4
z7_2%qJ)W-T&P+(!kgPYC-LfZU0mhOsYLPF($jQm=2ndP#MM_odo;&1R&lP#Cpe;M>
z&&sxil7-8>rWHOp^eZG=&@EOON<uW*6n}xBJIsar#t!a5!4e`P$8qiqztb1evI5WA
z^x(4+MrUKmqi4t^6T^_(5-1FZ=89-ZK57104?(|NA~12)usJZ(SQ(J0YjQ>_ejVdc
zD&JM8A=4k7+vF*X@WrqDf@E=e-R4W6jp=h?C0h)-1RKE&6kU;dO83Zig0KPQlQvbg
zUz-8b)CZikOw8z48+0cr(;p|L9B2vT*bKo&aaqKE=ZP1W{OO#%BjdSq%P-W;wQW>7
z0>0+TmofBMp;8VmmvlS!`NB5A;+2j|0e9Cuyp50jfzNKb|E$n~F<nSA#GZJaPp`~d
z0$MVj@{i2?jOy%d%^mZBu?VfHs8(=O>+oYA@Jiijg;9Veb4>5QHw32%S_>ZywGZ~w
zX3WQQ1U@juN4VG)3{pjZy?5V%!6p;5p2r+n-i5VU3A0`jR$6r29@m^3J@eU~>6~%p
zyzT1>&PsSXRj$!%#NZvWAX*yq(MMRREvx%O-Z!tNrqRWPMlqKnO%0-!$5b-73IT#8
zurW|{OOq+jJrpCE=jD(u1*MK;NM7qq-OSE=0oTM8p9n$gVuk5=wzan~qvwHd^}y>Q
zJHK$K#Yh_unsXdKVv6i1Qz@vDIo}fT;C%dz>Da77)k3|D`CFI%C3++yiQhHb{rnT1
z?Q>0bYbSm$zN0=mnVztK<vCmvP7K8{><AuxX-D*<v2aA;O!yBj#b*!ux`y9b!!|~2
zEeGxNv+Ul+XKapTsyVct8#wFxmqOGU8VS%r;<e_o)M)Ecz1zP!gGqGswdxqGWI^I?
zISS?~Dm%3_?;aqaz5u*glXp=lX85r@JR~i*3aK4ko%L^)f91C^r{ioolVdy0)tN4n
zM7l{aG6KRsbG8j8+GsBOSQ9tk*p_&pO=Q@(WJ(Gezcru?(LP$#&5+h0*)P$}T8+U%
zyE>A8PXCYF!K%fBmFu-a9O`$yqp({{)h;QYL+b5uKBoB|QzzM50_U(^UoDHe$=ILi
zOzP}L2%n2LWIwt?Wj04^^Qmc6veLCAWeZ%SdU=zRbzT0o`x8m@LmJSL0_z=gv!PfP
ztgV;e)xL?L`QV#jK_M&j0pruW81x23(yf55!h906SN7ORj_$7lbZL*y{BP!aFr%%t
z>7@y4ZT?EVS5qgv@9ytK8%oyobFNfS7$<fL#_nn;AjhJz#j77?%Tlfdtzu(*`2_3?
z9^qI|5gxgpnUpgV9y*9!%b=fGMaSdt`Hvv?gCG$6t-~8qMTPbvG1oBm_I5eWj>jyI
zlCf+KPs}<$0&dE*{*ZT@x07ru$!0d;(h}(l2IVHXhh*dkb`ALN?}&0!1f8Rd2g6aj
zy6qREswp*v>gBAzv7V<Xugv~T19rW|61wdah!IAV7ta1Xf?>~n*Cy+Dx8mVVy>o7}
zJDp#Z1KpqN{f4!2G8z?mrI}tt6kR4=TuF)8^)MlBoM#hvk92%j5a06?DQJV^8K3X%
zdV^ucX;hQz_UpFSyw|{SV*Ueny})_o!wuWpHlsh+U9k!BNUT@)Yi<)4I7lq(o%$a^
zn^Y`nIn>)5=ZNH6JM$NLB=Ii{%2=U_gKXgycdF`cZ*_I#4viaBb!N)r_42}4d;8UN
zIs)R|_EJt;AMX7dcD<m`IBuhp<NkQoh%+6#<f3FIWnUlSWJQ02=b2(<-~U9`HzJui
zl>W%ae$~5f{>DWXyz9-$8SnNWnVFFOLWL4}g0nyH#NlD*#6^WxNI71;aPYFs)YzLY
z@HV}rjS^`UQ_iXK!obE-G>_n*Ov~GQu$g+s?xj=PdPZz>{pI!M*-N(Gmn7Ojl;w;f
zbVo-$ovq$G+=OD4Mi$ST<kWttC6~^N<k20VU`F*9C+~e;9vQ^d{PW!2#@7fIDdEWW
zjb<=3lh_Q#o^Wg{nxQfqFtct*n7ujAJ28#?i_6oi;Zc8jdVQKTR%W;-srje7%}QWZ
z&z5k{?jdC?TT7*<)`P8Tew%?rN+HfIGS`_Zv^$&<#BC{ll(gM!z`bc5O7fHOCpX`Q
zm8j$^3NPy?4zUiS*qZA&VmmKAqX*A+6062Ouvibqv79$C=FuM9f;l+{D;^Fce8xd8
z=x2Jxm9EyCn~N<J!v5bLxIyqqmz8l&pO>G(h?^O-5)~Ocfwq~F^;K_1iKH-JA9h|&
zUL5J$$O~hmy2-<Kbyy=3Wg$P;cmj4ZjT8O||Hd`<&G+6tV%j6qz9=82N(uK%^ElA6
zGIYckBX@b3s{jR^lbMFNaEHSG4b!CUg`>`rdgYL$ryJXWPV7wR%dM`lakA<5DCM4#
zCoB*iIWXd2k+Z<k?s-(rVLP2+-Joas2SN6>xX_-N+OtRAQW<qHUjFt3QKPlO>t)9m
zbssSTO-4j2J$Z?4?Pl0>H#a7Oy3V%0F3vM5#D(dYsP~c%Xw}}HX=lZ=3nq{~F=<yH
z`u=fdaudZo*qWJ!|Me?KJ`6&R32HI#I{ujU{GLuy#{_+E42wA9%SoWiVj&T%Lt1M5
z)2Asq>07Sz$OQIlQPHY-+v1<p=-%3d^jl^x2q?$pPmlY*b_`URq-Sb8@#Z!X6AXm#
zt5#d8J~BsoVN#FNY|Ww<8}IJGARt<+3f(Ldiymy3+s1WDrkAN<@lkXbW3Nc=t~tI~
z{J<p((@|%qwG#;Ibd~HK&;42@fB2~pqEm5_{n+U5UH}$LC0WZV-1BWJLg-=%I5Zxu
zWuVzK_*xv*vvDNY(25qCJ)XI(%a=?|*^!68T|DNBU{Qh)MJ=H|N9N;s+m)hz@g`3S
z?C0vrjH-|!Kl-FLunQ|qZU^to&g9`#y0H0YiD`R(&0!i}2yyK+@Rqd3wV%SJmP$(!
zIFCrD#55nK?gcE_mU7M~Q=fB`z6qETqhIsaZj469-)5A_xxGnSn#Y`_C8FLT(agGL
zLh=Q_wv;io#!-8olnd+olkwFV4RFclT>NuNvUhO0UvL~pjIiu%f`l|*at{dyO!S8e
zc6~RbMJd-3)S_y<RAsSw4qqNzGJNo_cZcI$bc9ZWRL!63kB1|5(C952cLxihu7*Qh
z9Ww43J2t{_rr+h$>~})^+KYdeGd(BA@jxE?IsutXusO!U!Mx#Tm4NQXew@)<G;>j!
z8~$#5pQdyL{Z+V=xUZq=Qg~W5fB)jlu!7;dRXtIuDcRmdz+o!tshX`#(6+EboIz?|
z%uIQ>^LYLD%Wt6+f9j(y^npD{YzV=ut^+1+nQco~z=qlExBD;6yP8)ybMmk}f!R#P
zvBV46Q$r`-a2-6cci~O=>HV-8^O{(9I_=Euy-1eCW(#+jemuK6?DyMHn7-|X`u?M)
zB1KS{mD|O)8k?cMs3l~*+m6Bk3kLR9cJoHtC4A=XsZ^w@M!{Q@5=qV*!BT!IDkZg&
zmoKMuM^j|8?-BmlgrOqqZ4nV$hH`S#kVE$k!fSp`&gNnfl(M$h9@|Ii?jrFW0$$iu
z=90wO2f_8$e_r@Kq|&H?F^=p46!SfLltP?9xmITB*gdsAE~7SRZDh9s$2kWVeMIGA
zALHNZc@sw-eis`LA1wy<_+;ttQ@WbeBnv9u53<y;M?0J#BhsyTD#LnpIwhr=)PEf9
zj|^Lj#`hOABX|{A=s9oyr8~j<8FXLOgj?#mT)R+)An;ykgM?~RrRc8K$bDk<kGA8v
zm<Q9AWgcKsKE>v&<j=dEuGUmFiQf~MGzsK<Tm4;}HoN4(6tE|O_uZ)-o5YiNY&mrY
z6WQH$u|IkPW@F3R)&0!Oq|*4V<cmhz+wO?SWSC6^nvAW-l6MArHuY*Z%6a|deW_LL
zCl<E1Vjhw4D#l!T-%D(DbKE~#iR>er{<tsl9D3r6|B8W27VZG3khF}*%c0O$(o2qz
z?-L{$S42P(L`;eVxy7mEyfq}We>4sBr9L;;#+02AIdR`NH~=-?3iEJ9Fcs5aEwCs2
zIkl2@mg&W0j%=@l1m!CkcXHL>H0r!zur0*zM&ZW)5L+qiJLs=Dg|`a+=Y)_T<*?{g
zW=-C#D^-&e?sTGH2<)FS3A>9iPLEF^<2m+>dE8w1iLvvQHS>t+L3~kueO$^=)qGKu
z3tIVIbxgdBU>^dSOU4fJT-*z2%_kffo?N77$29~$pRB?nHT!jcl_s@D*-ec>85&`T
zIk)anP)R*osN+qj=nLHQi_LWD+;Upe<DL&65K}^f<#w`iQ}vi~u)&Aci5iC=Ft~_U
zyqh7B|E~fpenaST^-uqw^B&wvh!BdSC4iceGE`AW89U9#`F@}yr$Z{z#Slz8*%Q3m
zpC)xP-wg?e=04lIu}}wEyUQ8-LZG?)45qI<YIc?ML;qLisrp|TBda=~a#v|Ogg|0f
z#*KBngyN`XsPxxQKl4XzJW=pr-anpjVr`M`Y5^wkG&?6zC*oQslBusW!Tf2!>b@L^
zV(ea^U*Ma{6U|eArTNjXuE|dbK3Tm=W_?a>UZV|tEempNA)*!sZ!KqI_Sj$-jZDRj
zC1FSe;QUiNiK}|hU8wVZjzWTO{KX==e)OW{DQa7&QK;hb9aKWj{++z1XXMA?sAo{T
zZ9_7BO~hPEVgg0cq7hJ`i!SD8MG=B1L#5X?(4~CQ!%1HAIP>Dlw0LxydIB7Po>Qyl
zQvf@Oc@odogsWosT^IN+5+Xx=qG<%-UBTz~zNIe#3gG8Yw1Y+r2*f$C5{D49F?PAw
zhrsCczeH1t9teEw!s$fvVmrOSfG1nkt&hDzI4-UML_$?|Ahu#8sM!N+auQA}3}3U_
zc}dBYb81wNY48n%LaiO1PO5b-G|k;VwZI0zokb0rX*0;U;l@<p8<}n)h_^#M8;95p
zzn4Ng-%j1Z$^)OKV<k)Oh4c;XZ0k!gSy1P2>gd>aV_#{lcpEW;Pov$Km`FJS&1~!?
zFZoRIMGB}sY~@<AEOCQZw+K6Mj1PF<Sd4x-OS~7Ih%?6q48U`|H%TW-;X~lR5kLb#
zZ2F{*`CRQvn8u6=#)1n0pTGFgM!K8*g4oK8nZH?jw$@OidS@kM>ch3m$~#a=Uy*vQ
zH-dG7&-T`1rKG6Xb8C@~TEgIs1UosOZ~fz?^+OPVdCLq+b^|8z@nW+y>HJkI|G<aU
zcdAn0D{OD-Y$wpK_8V5_K1Z=VyIW=Ke7t9TdV8$2g1{LFHo!Bk2Q@6wW<0gPzXaR8
zYw%rizX(TCl{DVx$ktZjfIOEq(%n?~(h<S*U0?`+xjDJ?9@NUea_YicC2u6HK39KK
zcp~PlV=B=Ne3xlps<P$6MdH0#*=)KYy^N_}NqoT9$!^puYFOSEbS>x|{dv4Ei4Q>O
z?8nEotflNIT(>Qm?8H%WRy<{8*i1AZ@G$HX6EfVXd)8fi0g|y_6|xf>Q!#`pj;)J(
z^@5VErVD*N%|~c&>MnYtpLX7yuTf?tD@p72_IB3I=u`(4Wn%-!mFwj}0h>XAd~vH}
zPQZQVV>DkFut^CV34%FfqA}fav@X~0dhw02q&ziKi8wjI`~8@hB-v9Nx#3?WFzRjP
z%juT`)HoeaPPgZ}<#uSKA2Wht4%&^Im=q?q6$UUd0Yw_GV!7ri`73_F%TA8>tw24B
zU-8L;t_{Md3jDwvu_ieXgo_VQ1~T!GKJi(YUSO4>&1^5~|Fv~mp|0U3!ph%CF<0tl
z3`w7NN`)p3r(qG&72f+R#0A9*2xhh{t9LqU<+90#>qMw=`x0vBv)ZX8S2O7W8zfB5
z4q{QV`&AFoA=UZ7?r_Cl3K#&|gfAidz9MXbx;?hzR;bt6(q9#eG&5J`t^U&xs$d-5
ze~5XfqCgz6skk4wU?Fv!jbXI*hqUTg!P0K>eORTB@X^J5XR~{)9jnUHr7$xy3|1pj
z@9vGCN;B5UK#u&Pm6BWiipP}#;CfyL&>L2V(BpdUqimWY{wXVWeu=*PJ5)~YY^Yx1
zw*7)+h^oRmC>*Li4S9~TX-T1$0e?CcI2t7E{7~UHxBngfY*F6woqPBuSU>8@OEt{H
zU5<f{s8-eem4h`gtk2d`7y-2ai4WTAm~mowFitKfIm3YlM|;d4178bgGro6l{{<nt
zL57$)4!W1CI4AJaj9PhjLojx(CBda-Jf=O70L`;iVq`Z{{xq81(3--mpG=@}sRS23
z#zbz@ZIv#TOnJA?LZkpN1Z7EZU8|Gc*Z`xT3`G=E5D1lR2Kdc8!G$p=DyD(9uGn;E
zs$|e@^tPjFT`1IoZ%zb_`F-n{=y6skKuZ!T=Ho7KB|H(_g~0rvfxe|IfE4D<3yV6m
z`GA?_q#ayjH(aPfDZ%lz*O=T>K;jQ8bnyZ8#+XcO&5d0rE%#uk1x&my#C~m&GRql<
z2-%&($_65`YhhfDCz^d}&jkU-Y>1@ddH!WvX;{6P*U2>3rcSvS8Th_H;c<&g3@rOg
zH0GR;%d7TXQs>^7v^aHuBEnW0-OpRV-&=!C!!5L_Gkz1nuhI_sU+M`v1D*Z$*mFNa
zN;fh<qm<jg8sJcEqF5q*tjbV%eT*QWqO5|x!`95WT$}x)>k0>nN@JQa&S(MAOBZx-
zD~6Z(>5+@qg4!3AX+&RC+j?@+ZrY<o)1&d2<or9s!~5Fa;q6-L)CK6Pw#H{9wow7-
zO@Br|ZPqnK)Mg;a{x+yOodDgNe9nH<Xt~Y~?Q%)2clWSWcUjzDAFNqv5;fa?0H$<6
z%FT0|p?;0NEY5Dw{S%5();CEPLhFmcxw)MAJ^q{+i4r%jK_h4Hls<l%!YZNu9?j7@
zedMdfezXL<$rbSxygZ`^u$qcRIiSYJ0P`WrbNo3ZGb|7LXhc-z@@VLC3`3daw4V`R
z1UoPGPlAeHlK?)Q*XC36eWR6s&>cKhJZip9*Ov8lw*#q55R%f?I*<b3vlR=9KeP8K
z#Z1cYsp^6CRq??psGnDPF*+lWSyC8IL*|u`$j_|W7C+^~*RcMIZLX=9&x>rncuA8Y
zI`-%*b;n0hWk1ej^D7Ea;?Kir(B8E+4IDK!+bg}erMCNy<V9itw8cna+s`s(H`Jtc
zx#H((8{)R!RkvSq@fP_kn)w$T`pW~JppD-RC(LB8EqOd*B5&IGZ)rCmIb<5&?<&_-
z)JTgJZ(sx~iFf94NxTQeNA~I-b1j^&DuD^)x)E~lAl~&~+XJqG0#Gq{QTYy9$0!Hz
z{&9val#mw$--!UL+U_rtE^@P|8xL>uMY!(*V7NK(6aV)Js1imLZCwB1egj6P1jeUN
zvWwAB3osz>Cte-J8squA)6Hj84k$&O;_A+I?lTy=S@;fmafoA3j=AJdRcSb|zka=m
zh>V0g4)t*4!C*4JB)NU>@EnUw@Cph#jh!Z>hZ;YP-X<mw@d_xDnX;(3jmEQ0Sz1}a
zD*kbB;pf3jp!grs)z_#BC~$~jyh0xco!28apZYq9h19$!a9)k-T>BZoZBYY>3}Q;a
z=hL%!KQx%w$=v_~ypycqnQ{%{$X`Vm#trD+-cy2LiV2g|U=nzt0H?;_P)TMS%TIl%
zt=0?vzMSHLzss~&Wu8vfz8Kh;Q(@etVYP?By*jo{gMrJ{@8hkil;i*G1uT<u_?ej*
zu&eO4t^M&pLgSk~i%$Ij!>;`qN#LUoC2~nHT9udlyjh4&zJa#v2&z5>r7vFAG5o0t
zHd)yBxMVtwu=;==^NKjXAdc$DeI`yT$&&10$+xr8;$+6?d#%sq4|3^|ztbEn6V1Yv
zwz@VZlI8J>XFQ;@y^XBgnTV%)$O`SJIq&hunX!~LbY{)9pB$|O3k@H$e%46eLM%7e
zog7c<oZOgpF#HGM1iS^HM1v#HZw5C!EWtn4(I`XXww5x{Bjg%i$7Kdo>>W?K?C@8g
zZY>`RBiP+ln6`-!A=D&9K-eWidVkS<Jx-~W&i#aydoh{@!^D?+JQw3=i1%bumF%dS
z04$?l6urkO=_f#TxqO(-M9EbwS^c(o>U#0+I<e#S!8dy(v6poP)^-u$XzGSH8;3D$
ziqR^7K`o4wJ{&+R7kdcVvtOwhLpQc?VQY~)S=g<(3~+oy15m;Y9UEEQ$_sAf<E0c*
zpryVg+T(s<TT-qMh8RaDV#b&mBj^G(#f6Hi%`%D`V>TSPJ9pd^f#?3*G|9;cBs1ww
z=;ymF{v%SM6V$@0*G&MhYY&Q_!65N+8hR&dXT&8P&=)DnfOWH^DbLb`;%~2<E1uKo
zLagqbk-=R*zi-g}n#-%sZhm2ZUBUXL#+w>HJxZj3m|<!rbioSs#j(XBkvKUCL+JrT
zY?7(9mZ_c9abb4Y0KH#r32OKr7)bjZ{i}_v?NVu>#&$;@0T(_?^?QQxl7s+x2olR{
zhZEoVM0SFWX%mdcx(jh$>QVHIJZD~FOvKgojzwZ?q`}5wV`W~vahQWGgac8Yl_}0S
z`fs2y&Pe5O;?58}p*K@T)F@?=rIy3z;!^GG&T8a7XhO-(-&FU<T$7%D{N(0;6jZEF
zaP=35EQEDJpiD;=<Tf&z`BkL$<Wpbl?0&qES0yW++>ylMk_RFofsIr2HATYE_jtFX
zMpplZE}ngdQyJ&_-XF@7N!+7-W_}ZoBFxOJ+xM4?dsf=isV6R+fwKfB<xjfW6}02a
zJKn|<Gw3ZJn421)P^`8iwAQ|seVD&Bt@2sh9-7m=TW_q)Pk4>_3irdW_A>n;(Hc5q
z+FGRWi+$TX*yse0VYvz3oso9FTh?OpM8~o}6}5y&Wj!liqu-x>KH!j4&KaqU7cdVm
z!0J<%M3^py>ypB9no<?w{34bD(oHxd_pY!tqG%DO9Jp)0|E6F7w(@AF3^8vZfF`_H
zW>XCzRQ*6%+0mVGBG>fUR_aw(kXAKBk{m`k=1>(IYc~bT3P`IaZoet5FW=$kf9Ow3
zR|nvLOh>@kA&nrUnTLAMgK46ThqgkRCiae?Q<TBPH_gonPtyN$e6s)L(@HyveRxZA
zc#68rV)K9D&P7iQ|C@maJG-Di>YQSMkEYkcx<xvrFnGpImd|sq{(%#hKYyPc>QWQp
zbt*0EAF$CcOoF|37@Cl*E@`e`FC$_&WEG&c4&~Ni#08PTsvfl*TG(&BL#26*6jZXO
z2O#eR;spP>&*)1JqxdLyYv8;yjf^oRXpwZ7KNNSJbY+IqmDqay_G=8e9$JDT>G9Ol
z)^1yqxH-2G1d>I3q)TBMG46t~OrVwaTe<WeRd8kxKb4oJ1?ls0ktP?*G*_HId_Veh
zrWP_@F8QLD>9?qFGAMLOh00#BsRb}R(Z!&4D|)yn?*3R2`U8srrEF0`Z)IhIkL08@
zitcaLX)>3eY~+V_y>X+jOi{1B+k4*=1J&-00}a0=GD-S5>S9UzU5qBJ%CZE%>}_`}
ztNENz14U6pC8Si0?gH&Lx`{F7i@;H32{S)`Z8men992CP=G?N^nRZ1{6{M6ev^VQ@
zI)m^@<<G=3Hy1Q2%>9sOxN8h2hk>_}iLbNISb1YSl21<{(X;l2CYnUFAkhU7tNtj#
zs_pDl;gj+5RB86zK2uNa`>3Th+hFbQeERT>C%_qeci9oK@EQp9)!34AOYpow2UyIf
zu2*zuwSv2|nHp*=%UNB)RkC*5pJs)wcucuwvYpbffph^Z%Kvf!Ml(5yJ}kHEMG4O)
za%$&alDuN=;0Zm7t~dB*1eGXj@tAm|FX-??;TnEVIq74d|CV@gaZcU_H%>3J|ES+%
zS70&P@c=Df6iE*Z(2Raux?I5UyW_u~y+Q*5&nKsdj>k;)m>|;1m}n_x{4#;JKjMA+
zdhAfdZ5k{qe{QFR>LYYb)R!u={S}4zF%fUeN25Lnp0~e$U%PNKz_KRmdpd%)m;`_>
z3D3zCu~%kw{Kr3i9FBTpE1b(630hzNi1f;&e^W*eFb`~bQohArBTcTXK_Qr>mJ_8E
z&hrju_>&WH&|J#h-xE8EZ&Ej>1T)3a#w6w67sn@*kPelbo_)Mp^khh{heB7!`u0EF
z&-^Nmq{!n0pyX^FlHqJpXDp$I-*RjHXN>id<Vo+b&_cDLO%DKemu;V==B)Tfm~%py
zV#cZk#)7CtB6Wn))H`>kW#;RJE*yRjrxqMcC~-P=k{i4rqG9k+UR+o0dwQ-b971z{
ztGhv<MZ@yWl5KnMjksq&@wIEmO+<Tx5nGA3>mdyUQ#QUYiePb>4%=Dl3E{^XbOI`$
z$8`p=aT=Vvo86PmXj*7nBonA7+_$4>1RID?(o0ZQ{)zN71b6ZI)H*5EOZ#uNRmOVQ
zuMdp4vtwN(Zq0W6_%b*Ogj}IdAV3lVo#>6G%bv1wt3&$b)47rKZ7H_iG8_)jj>Cr$
z^wI3sj=Xu)l+c{v)K!U$Y9Qu;5pY#`=^8`-DZrq5&#pmNhffi}Gl-KOlJ+uu{b5eG
zjmS&a7XiEp$N?f1^d#<6e}+|2t_Ycdv5LE)gD)xgp-ZZ&t=Y!>iB^$C=$|Mm=Sz$r
zdE)=wF?#XpNiwBxerPBwOi>@0)cIdXH6eK~#q*@A!EB@B+jk_1nrmVKCf7}o%s@BH
z<Qvz_PLu2Cn2I#M+UvXaf9~y#&a(f%mkD<;OdboX^H0s$pJc5L7ES>f$4S)*L2|{E
zP84oPquBZ<viXKzzPA@kt1%KD`IoJdMX_H=87uBg6rTXgDZVN@K(eWANj*c`nvj3U
zn9?I70^F=yvlMmk@<=g$OEgaR`p}>+a@NqOT|+&eDL?w@;(hkU2n!=;dK4Ko<f-&@
zg_aaS-tz@rOgT59rob0}|3QJU-OWNhcctIUP!&a}wnGSSI}^a(C^2$Ug+P1`yi-<i
z>(a|Dyf>egGL+VCt)%elO-zxS`LCN5=q9MdC-F@0j}dWrU4bD*nsKLDufE`kyQ63M
zC!x;b;|Frbo<ui$RRvyF=p%JD#3md0N&&7k?3q0L`t&>|q{gtgvDMPBuNWW6OdZX@
z7Gq!*jj($slCZg-D?jL$Pu=nNiwB>Oy>iuz5eIhp=S9soHE&4Mx}>0$v-^5me!tlF
z!?h_1DCkl}H0EzZ05VJ%0?D}#&r_-+4}+k4E}-3AS=xN;4Mmgm(+M`JgU}eQ_RW36
z#zP-3Aixr-ViE#aCrTjfpW!~1wKKv`zfZ_We0LalLlH>g`oGkRj*VYM33SSQZDCBY
z<4HVN($^uEEN&s2KmtRymirUwhZGa3uV9s!&pGRhb9E&yTM1e>#G3E)fQf|*3WUzy
zv}fpiV0d+qwbS=5*9(~?#ffFz;CRDxDv)Tdy`}Mn#`%O5rl&v>AcqcX;K3o#e`W|K
tTt&Z}0RE6c7ABP-SnM>?qC5N%XRzyn-MMk+DUd$}Qh{nJl*^e1{U2r7HT?hp

literal 12473
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
Cg{Y4J

diff --git a/test/visual/mpl/graph/references/qubit_labels.png b/test/visual/mpl/graph/references/qubit_labels.png
index 9ddc259a367c17b9f7a4eef91aa701e084891d80..d2f0200481684889f08679892523efc4d1385f6a 100644
GIT binary patch
literal 8830
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
Pp#)7Cs-aLLXA%B?%xgI8

literal 11018
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
R7Cdgn(@@ogR;t)U{vXgkf@J^z

diff --git a/test/visual/mpl/graph/references/qubit_size.png b/test/visual/mpl/graph/references/qubit_size.png
index fa317e6b9d14cd0c74feec6ac712813ecb21002f..f8f7a660f53f48a2f517c0cc17b371b44de71d2b 100644
GIT binary patch
literal 10307
zcmXYX1yo$U^ENJvyF(XP+}$be4#kVR7k77xyBCKRZLt>ZqAgO~7N<aq7g?O|zQ6B(
z_MCh7B$>%%ZZerXPZG5?m2g0mAOr*i92I4GUEsZgfPlz=fd>5Jo?CwhywI%Gl;ja!
z{`-~p)@C6fyh2csm(dR>J}L1JF<U5r_rp`aate2knV$-|M_^5kTv-nwV#gp9#b{Ux
z=ft>XuDfPVKZI@A&cQX5*V66u>IaGSaPsY=5!cA0gU<|d?Tj-Q>`$LBlrto}Yo<%O
z3m-zH%UY{~9Zn@P4}=dy51ev$MR1cU_A(Xxnv}{}Ky~;e!^r=85bp&ctY;Kvd49qz
zH2qLdqMBUZg^zX}`LE3^P4iD`9X`?4Yn)FjXh;6gCb?gfDbKJSS#n`wCY*SR-SP^<
zn~{1S3yyU`K_bv#u<2IyLJOP)1qmM{OCQdG)#8RB%HxM&CP-A1nz@@~ZJ7a@8Caz`
z|K*~s$GxL+z-_y>6=Ufb-nFYs&M#sE)&GZ1Vr@uSxRu5YMPFNU_@cevv<@B%oZHUr
z)~-uNswN__Mh{LM2-T8%V#To6j@Vun(!Yu24p(1F`?0ALFEvopd%iomWn1};9;Ltz
zk1qa98tEaeJD9urVJjHyE{)M205XYc>(0c90y|2eN<ULk*H2DKl6dU8fNASv%cQ}d
z^*eB`%8@lV&p#`)2^l=T_vpknS=$nxPSWBjDfrc~y;c^njl6eI$-HG6u6*470l(NW
z0zG#iPpak=M|yXS;$p>r`&aALQp}};ZxRnl6xgVfXv3szLnQn3J$G!tp$LaD=f0H~
zc7244{m<i|3UIHB<V{UsUD!yTtXU8JlglzGED)6##n!J;LoNaL*DQ#;zwEgy`!w+^
zCg2L?(`sg)O3*NN9VN=cM>{`_JWGtX#>llMv;DcVPv<50dChq^xjuErSXfgzC5zJB
zlf`GPf*2n=?e|So;ol8qebO~Dd}3^j&;PJ9%AZ{0S&a^+;NVdQ1k0f{*ZNR}K!)T5
z|9CW*1=XOqF9{7~dDz*T(Zo<MhrRwsO%lG%4tC!_j}$2OMGk`Ekd49d`uC@Tro1fI
zA}1^iFNFFCcb=VfZwgHZYPsSokjAG1!cCc!787YALKjZWOfR^e39Tt{9|PyCzVl$J
z1s}Fgq<&;iWsuoU>OarHKhia$dvg^Pd&2Z5%L96GKk=TmSR3On<@&e29Sy*;8e(A?
z(qb%#Ldy|PPlwQF8@`$4<7Y`?kL|VcGg}t++-8I5t><8CY5&(Aw@-$94>_h=&j;%?
zMVWNB&WaqY6W17om2$U9;pYn}%iqwcHNgb%rRkyYsZNjR4CE}eXg;g8UurIu_qZ05
z336<&wk|f8+ZbasFUV-aP3?27p1dWaZeyZ!gLE#)fRV;nosz|?lC9-d4E@i1_6M1=
z(r#J>9}cx0qvUVnHJO>Be0|15*opma7VYv0^MbP8!Rq#28Lsl!f7$J=7s`*DRw#>p
zZ@6b`JZ{MSv4FO1J@U`?r_Mf&CE%N`RjEI%QCZGO-K})keZ>(gA(`b+iy?c*7**AR
zz=WG8ym_T_YS8cQPNMXP#ol|u!3|R0r5p~gx?c2f&M597GnBE(!f33dH(^29&Pv^V
zZJMX4+UPcG<+QHJ!XEk2VNhX?&!G@iE;GFAwq$Ou41{GH^45eK&9&>%HE~PlQRxQ+
zZs?w&Up`WEmCWO7x%TTbiu*T_-hx3d%WI(k>+aj@6nI;kp|%JuskRA{beCSqofPD5
zgA7<adDSiN_$}@Fc$)20n4XL)t3~vjGCd~V2UpRX^ypW7j|hpdZJSYVFj8LZZ^8>z
zdnfxz6jRz9MbP)O$QP079v&C$5fk?NqO3nmSmL_Fm3X+ahq$R2kzMHf2NR4DM~S~e
z9h|*H{hlSH<Tt#DSQpBikB7YVy#<Z!Ic~|0eO~<7$2MV8Q*!4+rnAaSw8OEU7e1^Y
zGZPN`qnBW9A@6rqHE6D0wIOgnL6uNVYuQh35ibEoW&|r6TNulP4EK$uzg^JLowo`|
zbgwx!xV7=|KcCqgD2#ZWieN|w_Jn$~CR=}TBiQV8&q=`<UK%2^HpLG+ugfk-V3u8r
zYEb<{CmlwvpPd{4LYnpWoYrCGy_g!=L!oJ@{`AxzM(upGeV5Y`Vji-M;+iihgF^n1
zY<oZS{AcZN|H%<_je)q*YR@xS^4aO92i8*NK76`hqTD7G*N%Ka#M3^p=S$rAf#%ZG
zzDlR>9gx4aql35BtsDefQQnnBU$&1W*{pqn7x9dEx{&%pB(JVLv(qvStg*b7taw$3
z+Lxzj*<D($zuBF<@z$MK&7>b^=?W-JAhDgi3x8(o8<KBLkj_<M*s2lbv9{b<Iw^0Z
zc)kMl^tXq?g`#Vm2Xf6<)uyvANKp9v-Ky7!OcOT4$!}=Ki_7r0_PcePXt$opR@Yx)
z61M!tacy`Iwda8aMCK3uX>-pbPH2#lS>>W!%e_8Gi1ZwV@HFr}U9bj@R@7w(Qr$4_
zgOqbS7yUtAMyQ|EciLs-1SWnxd!C5$@JD~J(refXF3Y8*P<sO{W%!5qE4RD|+9u|3
z)+)F4x8R+ILZYHRxUZ#cz4*s@P<`XiYf9aO2W%s4UF_d>ZJ7Kv#p2Jx-$F}7gQLE9
z1&33)!f?cKWz?{}#qiTJsWmuxtPw(<n8?s-_h=Nsi;K|x-o$2{tnK0(!HV61xb^XV
zslzdo({G*3`-jsgIibUFk?`C{GgG_;U;2)kH!Pe{f@|CF@gO4QA42zG;p+A}=6Gxu
zJRmRMIAQi5Np|peQ^Z}K4b;K=>+|d;rlcV)$Xo@b1s4#tveJye_o#>j)`li)w!&|g
zVpSzlWX<}SpH^CqY9^ePHgKB55a>?T&+e&i_B0ci8qj>*Cw%NiWk@Or>1<3+JDv*g
z_D{<hSeG?ztjIuvi=hQndQ2=_0!u?HrQ;oLsvCs745h9U>Uov@oLT4zbY4c``NB9;
zB`h>KBRDyHv5BYhadXSq*BY5Zzez^0b7>Zv>hN>q6Y>eN68%)NYe=00Zw8WE9J{HD
zbRmf?e>??ZDXZQ2>^=8d3$spderW%T#sGgcSG68@4)jJUmS*jB32Zzb&SzOz@_D1b
zLjWE!l4?`m5-Ev9N*sw)gu0aYKETB!<*K4nI^b{qWnzHsp$7{(-Hn2iF)(^OA#8Ft
z9xY$R|4HiRC6l4LlCSrbl)1}ka+8|yH4?$8Rk*s$FX#wleZ)<E-(Nx`aJG6Gk@_@-
ze(+9^Fo8QzA!K?w6$DnWYj!QJfo}HAKAeu@tmD|itjx8gc{Z*%og7`ZR)*WaGaaLQ
znZL-~*a4rN;bW2e{hJ-g_8Dv-@)$?sfA*_hJa>nMk-fj$FJOd6euKzrx^S?GG6aE}
z)Rc`Q-5E(7uO!S&*fraTyi=ShExTmWmY@6iEc)N-I0GcA#vhM`J=6HYsH8`9bB&{#
zb#@SUOtR-k{$PeI%<q-3jm}qeMR2L4W`hm$&sMR3ONPKM6&?(SR4+K~A0B(2p0@of
z8{hZ;;1@ez-;7I+7|neknVp|Y?kJ08M8<0zyH>6sYHTe0%A4&de=_WIw^BL}&V>v|
z_Ntea?tj;2lZR01#0G3I8t)p@>Q=gq7xgf7FaON<Q|>$x(@B)o2Ln;wm-e*kPi?~P
zKqHyTM%fat!t!zB&0C|=9USYvYKN5Qaf1~%Cd&7(gVPc|OZ2GBk<5wl5=X6b5%1}K
zmG*+%q#3H#C;Jcv&JDXar-UBlbW_Q-rI0(i_cR>I56hc@bMwBFktLA7YkhmnqH%lY
z(wl=qofg44h_ekOo<x`wC6(yO_^#~Vjy~gVqsz5~gx;JMv8GT7vC4C>-f4YrD-;8r
zb|Zq0j}v$;%igNEuZTHG&6V)DEzg(zduxXXfipttRiN9O(qPOMclWL3Tr=q&`c*xT
z!EZ&dZyq%|qkWkyDnFf+V~OFtj)kAr`B=wNjXgI65)E)h5ueX9zZ{(6Ua|4Vf2qgM
z@zl-K@%nIk+2<`@%qxpxoF4ZI8L@k0kB#8YjSMQeRJ1uXi2r!AGM`N3KsEQNu7F%s
z1hexrb@<uY7}~gu@?Ik|jqD?Gvt8mH1-6WFqWr}~2?uYLxu`a>bkMvRV}q8~ZD*Q8
z^Kn>1&sS2~u#+pB4pixv;)ezNY<D^9#&1NBJ!RvB$p_0#or3niTE2@aoScN=TP@E#
zt_bSnOwS!gQa?B!wqK;Jrp&2L5I1{JRV88JVQ_-m4Y`cbGjkRfcLngAtWR=I(Kehr
zzw?P1myCb$<NLR=;M;#5403Bt(sWG)B}Kffr8XJpQA<1gE>S&R8m_BYczuQI7mU$v
z&@q{eQ9%T=KdPPh^aGD8v!t-0f7i3-KR(L)9tUrb>a;0z63~xnx_y~=ba*qcM%5-(
z9K(y*+G<Q$&Ia<~2d|RCeA`8>hY_D2lfHyrQre&uWqn#GtMmEQ7=xj^{*a6{@%ug+
zeA|3brC*tMXbeKe-ZcoXn3d@yqE}WN%Oib_Cnuz+hXsS{J5*9N<GYpAvHa4A#n4{C
z>+>uTJ!tMg47<qg{Hjn86L6m2Ia0Tm>dr2oZeRNnP%WzUZ-Dn!gYvyLzs46|w}2<T
z;W8f=Fwz7yI@Uq{wA%)=%+A|$LhK_CTqnIt{YVLXdgZ`jwJCwJU=Mzdw;Agf`7IoE
zx}$xBu{}W5aQEkt!fD9|uAV-jZ@au!e_47iwXe1UhNbu3<8xx2eq{?9t&X>dZx?S9
ztHMyX5nrG$5=!bHrvgVEmn&ZK#!=s%kwL^64O3`cH;iU|D>4mbQM^jSf5%PP*O@yx
zM?RG1+Vgame<EkY$wAjoP~E^Juzc;|bxTGOlEO?mv|YyjQX+OkLKMg<pN>21KP}8m
zLsu7R!9DdpZDvnP;++{`9mz{(rz}do6s3Eii&Uqb^y75qaV>p;pC*lEyx2{s##=0c
zs$Q6#L&0<-3`wi6Wc>pBl-Xt2b6(<FIFMUD!jvoKbLB0$g%K-iX<KaUio}9CcK9w9
z*n~9Xrr{7ZoGz4R(RF$wKwTCV$kJBcwnG;JmdB^tB_qvWM+Yk<>Djrw;X5f7>hvo!
zX;j_6c#kjhRb|~fT7L_-wjC#|ojld{1NU&9>ZN;A6VX$0a}368=dK!Emh<oJVhKoK
z3bVN%B%5?_D`{+(P5xy^92{jU1C!i@E&Nq(%)at)^Y+KK@r5e>iQ<mM;Bg~{g|*(n
z7CCOoHK>G?w3PSKcBDht<s-0aRk<n?4NR?O-oa04IMw879-fDmWKoPn$fimhr8;c|
zIi3be9&nG@6<WUQT+Wx>zD*!Kum4#cAD5`K83FI?_TJRV$r$y8j{H~k3ddC{ywN8Q
zH0m^M<0JQq>C$J(>WsKYw=EvjS~6?x<#KgO5ZDAA4G@7s{sE>mx^1whf9gsDwPKO*
zhNN86NR5n4tb6EJuf$dy$-jJ%#kSddeS6?Cfg~Cv%l8Nkrm0c&`jBmmt+bT*EEnr&
zsY(L#O1y(LK|NnC3qJPLP&@#K^GZH{&_tP?6ntAV05~MUMj3~I6MByn|B~TXbhaUK
zvv9;>;qj2u_judC;dA}*PEa(Tl0#wr1m44QUQJ3Xsh3W>mLQiPIQg%&9=(tI_5Ir5
z5wIonph?i9K?GN#1*N0fSSb7pFi+AzyojpFTct-IECTns7lrCE@-(U3vjV>!Bs@^O
zO7hnRGbxvqp8q}?zM#_#C3@UZsZ*O7b!6L~A&rszy9~!+8)76k0e|pBjU4k{@IC)Y
z9Gb#_Uf5h;Qt=oK;#Fb7jbGcnBhTVMGB84bqRZ1R`BsE$gKGwg$AQ#t-<$3<23_x*
zw{S5Lm<8ps>KUj9gLe-3)4g{YdwfjM<E`NpV1FF%?Bfbqbpov0Jv*Mjs=LPuyYs1<
zp=L5p8w&@8a6l|Nf)jD4=DGy=@sHhdmvF1gHG6!YBtzOq{HI6|uZC*UP@~m9-VW4i
zde}1x7J8Ar0*>z`;7aUYwecd48k2UKf>3TU<~JpiU#vdES-#ZSNT2C|?GwNx=XXaF
z&jU8TiNARZ?T0LtVf3nDm9i7Bh~frI4965TMF2n|T#{^URK&XcmKdrt8un~+>tQ%+
zb%P>ehLvn6UuxQk^?cuO+)>DaF_3^*LM6}vahdK_+P;Ht=_gCncHy)Au+p|DNYwb;
zGTW;S{yN}$@Y)=?=h<qn+wQ39W#n-s<A7R84AhDG;hs^TIP+Kc?sbOSZWK5$?A5Ck
zD*lll@vpl-45sdca*U4qT{?&3zXJdZ0BFfL;MkgC7tcyHU6U{8{uH$u<duw)g`I`9
zOg~YutFTuyo1WxgTqWz1QA2t=zS|~+&1{*xR@rL&!(E`55M2FGM$iI294O|mN(!9L
z6yUD2MJB0On-?0uqZ5p8!1;@%l#2XjpK1fe)mUxAx1AWOD=|sGF6dhzC26~V^w;JK
z=eWx!DKLLI6<zFL`otJq5_P(-=<bNUKp{3CHSQ{_V;dE*pdN(uYqs!FjK^5^q~>&o
zq|NkWO`1R8{KN~n?GaIJOF7fAPy)YU89rH3&Yv5SIeXf0g<MC+sJu6FE-Ya?o@cZ?
zVfiQ+DdexD;cU^1<(~wFPe_)O`FcgDl}@G0@g|B2H_j?-Y1coEBjM^Q+U%ANiAg@~
zeb!}QCLK%{(ADVZaDIjG682HlMt+<k*++2#>C7!E&5!BjE9ZmNFxqmDR`ESVA@e0*
z7nRV<`)4eneqTuF&XNzcliG91n%$i81sa=t9uU@*HW1h`$%Z?ktrbtPU3SgGK^yCg
z-ycs;X1xNo&5T-kF9aP}P|#Dy3ok01#-F&7f)DNA|LnQQ5IM;*MtD5!RwnSP?x1~Z
z!M+LSNPOENO__>3-BXF9(;EYtQHTNucp3aNSSQ@J)Hr}&EM{$s42<8b82r~enQ^C@
z>=LZpr9WjqcfP6B)!crhqACrL+E}r54=BX6Pt9viC0a{)AGfPaky@BlK$DkA30Uok
z?;lH*`e3{({`t<(gM^<S!f~O()~ytKNEq)tlvw73b`vSim2;*g2;Kdu*Pm;bm@Gdo
z2?!p3Ey!dI${xrgRYvGWe!Td71;US)-6!URJk;Tv@0?#u<hHPIWvhDSJnbEfZUCXS
zI()s7dA2_;Qwk7wbe)2=gRr)eu`Kn2<>rRZ2H0KryifMu_|LXv?*XeoUN3HAi)LYn
z88@#i?-Qv*NR4OlyvaB#Fn10K5!Hm`W(PYMp<$~mcXtcz=UrI!>L#dMaG>joDwf_Q
z0D)?bpxE6zushnyAYSbqu4K?L9_Ree?m2$RxvLvBv5!5C%NXIte>LMm1M9KK3^Ek~
z#W|sR{`;E(Wc%$7il0`I!b8S;adN;<>)lP6)P-oj38CnWdH3^?ZqOWlvG7vSKK^1(
zO06DL?oaArDUk^JII7RSs{1n(GZ4TtTVVhi<Qg?NwQdCIJWM&HcSs`{4dY{SW<l|P
zg7xzHR(Ii#;EYf8W-tF&d!XSwt#DNim9T`068VnKvjbzXwWQ;Ha>eUgkppw)Y(w-D
zxV%q9Pi+rt<py&39!<t4#eqilk39Kes(viJQM&^gWcxwHs)qUr##=YZ5VJ|F1uQqJ
zrhKp)0`Xb7>;w`??-m``<Tc9>BPZu<3Kn;T>;&O~Mif?UH62DN8=|Q_G>$32jq`E4
z`uJv3+ZqUT^quC|b4m{V-~C3POxDEG0H^hb-dx$Jo@#^b3Dz=U-;H-aGmpG}O_;19
z-s$2$FkP0tDy-@bEZ~9&oU(4pCP_mf4;ZoSK<3tEa8rC_=;ZWD8(r9KzCNDeyLi9o
zAK)Umid_C`+{8Vlo2ifum$(|`A~8yNpNg37iHKvE#>?CD1u6)J%(z&xeu8LCJI>o6
zi#F!f)mQl=FNy=XIQfatYCZifXkWL%V(gKBk;Udm?7nx=V)xz=pc(dJ=SVv`6{hD8
zyYvm|M4OY^`04h1e!)(umKdkz7+Dpz247IOBgw25-dx_bSv&Ddg*gWGr)3he$#b{8
z<m+Q@w&C5-=Cs{@XnCn_vnHP>yP=6*Y}wKBt{q_JP7ZrYN5<=AD``+CMyYx;wPG{(
zAekMb1NI}+6jZb8`i{iHdOT5hJIUW-|L|v;lRd6%oksfe&alC(?{bWrio!*=-YnfW
z!aRkqE~^?WoN;}U)pXW|k&}G3XTn0vi*q{-1?P#$lQL*v^yhy`2?kztB-X+X_v9+)
zI1ayahu(&d``k|Cv@zj~%GggRy<JKd=>$6WP6Amv8|+;Ot`VjciaJ!>Qffq@8Qn+5
z4RyZ<@#5tRg8wbo=N`I)h_Vz1mPlo%S$>lUGESN6Cj<`6vyC@kFzZ}?iPp(Ezb>-l
zbe5Idfyu?@qZ5-3e3{7@T{>0nYaUJyJD)Ti612Ad8FrfyH)KamVqI#vD(U7P>-#OU
z|BV9o?NS=_aB%<fAuW+SZJsIIZ8!zQtCcUI>s%j~^(k;wW}2`IuGrm__*aZzccZf2
z+(MKF(4mbV!9OZb`{G&a3agU!`fz1eEIJj^*F+F@FXFmzv*`p(Ne1<OCl{)aE{1Ct
zQk1QxJI`(X%exW#+i7OLx!&dJI{eE773hZ^j(-6S`%dT`5J7*^Dc&*<tnX)~SrNVv
zL136MZct;iOP{CHi7$kJ)8N|ReF~<_FPs>3u4xjbAk6q7yM4btnb>>>b#k=OAbDD?
zC5aPNS+JLy03#O#pdik!;1WalI5Ml2&z}w_@h1n{ki-yiFeS)tO5)_T+zwwn;Ajed
z`3jrw#@(Wq@Y(dP319)raZK$0sR`BP<(l(}8G7F!P_~rbbqiQbJa<~Zt6W+^b;Xe(
zSQ$4|9S3-e!T=LFNQriO@6<_zk}yvU=)*ov27m2F%|N8{S9;exU^cJfC9x4rb&XRE
zP_U;16fmHDx0I996`q`H0;m@$FW~b)qCmXUyal!2a0gqz9>ZQT`2`ud2!LTsiJ~3!
z$=%p10K)QsHqo3XOGkyh3s(@q*O(!S28@Wfp?dt#2-ZEfX#$ZDiEq2)2ACH83UWK@
zb@-tJuF?45ASD*znRF3;HhDUp^3LP(xLw6#CwfO^Ge$P~GRuFgr_yNXsdnKUzbFX(
zM=&k}`(yvp`284@5Sw<Yfx~0f2Z)1xSG+ihKz8AAXozcorgz>;4I&U=YywKscnWIc
z(+)Ns=h8(;Dw^{J2dUk2-O8*59;pdyWv>WAg9ett8KZ{oH<}3r7IHiK2~tqo(l<*g
zkM)Miz{ko~0($|5@Ot+U)8me^0}~=KX6T72P4>T*0IEEK_g<pUIXQdwoG=WOs0Y5s
z&k79cq3xiXcsAPE&ik)ZyaLg;kN(?xY<rxvKmaWgE`naYlK!89s!!xhxM>o7K}B7d
zJ<5R;A-ns_U@z%s(|f5IOJ$Va2MkvjmN@SBXJ`1N#ZRxE4nFO+!8NKaJZ=TrmsQ!%
z%Du9t__P7MLHo+at@@c%4o2ujj?NkOO;m7z%<??8y=s3qt!vz=Ny(*QrD5<-*B0Q=
zYJr&6yiV7BB;vsa^Kx<@$z}ng(}s|2JdTC*y+ZIecjIb<4fZ)3wW)rJu+)yiAgsr?
zG$zC(2C0l~kvOP{66)d064v2AO*E7KoU$<t%Kff&#wR}C8-pxynJS^aoEuU;QS$Eo
z!p8S}jH<=&TbI`?>$H_IUoh?=a#=pQo>Fy4Jz&2#ySw$OWTP~Msc@+^0`-82mhb?9
zyB}}!nJDCoUYKU5qUI>^n^2_FV9Ky3Yyp94Kh6?@P<3zikZb>p{XeK#+jDsb_UiR5
z)(nq-ejk4S8dQ^Capd>yh#hCyS|`K{5!g@vR*Ny*7wpL9n~(&CObV?K|KTbY#*_-D
zAtsS8Wycu!(Kt&td&0_0o=KZ69j3lo%^VGyImid82?{a4DE<(fQylDv`2;B!+l^!U
zKHA=>3dYI4YqpRoDNbyby%L>MEQtQtOB!5=u?_Yj`R&=p`*5u*mnso<{RM@JF{+7x
zB<uyLhm6!fPZ#ASP?(r<Lb6%U96dY?Rp?AZ;`Ij)ErNHWmCo7+=<`q9RiwVQYrp!*
zLf|)t1&k*gf8)aKA#)RybgV-_g6(MNYEf)hUmvXzOgL@K!4W|hE_Atz5j$kw<|qpD
z^Ey6gz$dBESCLn>F(P03!MU!L0ANmmtVTj2n1xjUOSUVHH#i0T*KSyVf@*6m(cGL<
za+slGZ6_03_ewn3AvL3=vnixY&Wze?f=%mUN>Rk5$ZW#Z6u<9zvzD$X_p7%Q(psFt
z&#jGE-qNh@HP&^CEbsnmjiF_8PwIeE$+Mgpj5x-K5O~Jnv<{dp!gi>rZTs8Y>7V^j
z&#M?XVKE{Sq7f-Xh!nsp#1W~c_&%XauP%i0Z5g`$b5C*Q!8mhGqGj2hv10EYur2LC
z-Hvv*EEP+jIQdPRJlWX7pqjx&Qt{892|I87yJt^f_ht@Mkg(;{4&-{_R;UeT3m@&+
za+RY?!U-;y8vYdJ+S*C!?Tv>=fIV2sLV}{7@WUy8V$KpnYPs~Ol@YqV%eNaqfi9x$
zCUtP}fqlguhJR?oVsYquc_m*7hmkUAD)N>Y076E&-5RSky|YY{9|byn0G@cVaUVb&
zAV^t(l<#`hDJQ)o`sGn<7lkHaKxvdtbak$y$XmZtGO}^|tR+@9o^VS55Xaz{_`I|D
zw9!~+{<hE$(*Eh!=lKw`*gA4v%o#6B-|V1@ZhLJD5AjPGDHb$1f0-VbO;Hg$CNh*h
zEqFnK#$<b)?KcgIE4kD_h~`{*cHIOe_e!<i>lOqA^yB~T0$`i3cxh*vYq*S=@qLoc
zCRN$q)9(uITLB?-JvayYoDcf3mgI8`zEUT*m#XEjAS9^_RK0o!?;dK~O3B#3xknox
zNLU2Dc94g#$vr^RK_d8X5S$iByWT0fj}RwcGFA7*^}YlKb}0<xI-}QQrj-La;tS%8
z0aD1L<23;7n^*R91yW)w<i4CGfpij8zWC0u;kmDV+T`R<TY`~ypfaEjpSD%Y>Raos
zEcMJCRIkqw;hamWRn>X8_0DfyWO_^Q4QO~<ODioUsG8ZQrnw?~ZKlMXe|^Tst5;-F
z1v2vj6O*WVZHD#21c_*>jOHsniZ>pst2zIwwQ0UWaCo1%>8%@EH)OXM5b(EgihO*Q
zJ`w+JyR!ACBMK70&!|&i&W#RnG3RqAId5~TRpzyGvl08taFslEK<wCd7X(lnuNoQ0
z@Mt4f(L~;Id+>~^z#`uQhezcK3odCYE)ltjQGG|Z=mSI5Z|z3!-+{2I$QKhwV77Kf
z$`r%Roa%MKtwL-D)}Q++pYPdR#Ssv(qMZ6n0Ww$CqZ{8|OMS{`{i}ujV6<RsnQ$2S
zBeZ&l?e-a}YyPUp`U}En)VHRnl{hA8H2s960&NV^eumF!c6K-KUBULJF(1xX?taxO
z9Ulk_L3c>b|E?}q6aGxH+NRDIZ`a$3PlZmC+BH+WUwEFb<;wcIfmtD|PcIs%D%<5p
z?bF}t;6)Jfyn6V-!o`0qg_`@wW?!W1gs{L3TJIL|P?|Y_B0TK4X8rDE?y-tJ_9K4I
zTs^?0hMM)++o84EP6oms=N??=7ol>^YIE~OS7)gHW}qykk+8SG#$$n|wj>*IrE%Qk
zGZ6(vACR^{Mh;>Q#U!biRWWCH9A%)7ay=6QAi-_10+rmx=zdP3JY@k_Dy~vAVY75I
zk5n3TyOQpH6Uv1umv`u{E974<kn)8&?Ov)uIt0MIiHEeYLbm+qj`du~4&}1=v%UJl
zD*(fp(M#Hy(Mh=lIMB;-nD8E>dmOs!UHM-Fw7e2jGOfI@Os8^L{g{4^*xyH)(|@SM
z<u?*+;>V~yf55z<j<h@4Ey~$m&OP=KQebV-*GE_?!7`i}GuxY(A=3TezV2TCef?UF
z<(HI=-=hi#qms93j?Z)<4~NaR51Txy)G8)ivgGloN!*ZjW+VB`J@eOR+aa2k-vqQY
z{Out3{-Je=v2=#+TqS2nb8D;0#Kw*+kd)*+RXAu>CHi6Ch&Q^mu@|V@Xhn!-Sq*mo
zdm52EzkSEc`j7*CH1>R^@SKu2_LsV`-&w+m)3hkNIR$eiUNS+#-s`t=t~jb#eTKLJ
zna4rnH6dqKin+cn;|{`~J9u)f*s%Al$m2GoU}35NBd-+IqbXX>YcbRubD2<4*q0c_
zHx1+B+Wd8lMF-rq@n%=~Dt~i~S+X!z8uGITdcU_u@4gn5Tm$icvQ)0H+Sj;@$B>CV
zbP+m^B)T5YYmoN-65{5X>yj_>hPn4prVTF>V);}3FBxEp{jj1j6_c7lb;x=kONYw0
zr}B^!L-*8xL<Js{kHSAG7x92pFDcpwS#$BjdS#WKzLM5Zn7eP@Wsc6@z>$jXM!ku<
zR3Iy%uG4IU_%Eq0Fz*Uf*B{N^v6#dj84;scUiR%-EYawI@3TV}>P3gY#bvdRBo6#>
zev`{c5Vt79LvBp*%HqFj=qTh1I}HpM)hmJHcYZU_t?D|f?%(5;_I`^VmaOkw2bHmn
z!<AC1Hq#+;v4?tvrn+jVf7w$0wJlGdEZCXnH<b72WBkwnb|_r|0pE_YR5H+F|Ia&H
zdY8upz(Qg&6`Vr-<%QEaIs*#v2g?b|I}>ldptIY6E@ImgQNS0~h7_!1G*6cCA)M@~
zr4$x3YB8V|`(S5y<UEXaoq(i5i(;Pn`uGYi<ll7HB)tiX{4;{Jnye{$eji`IJ}P@p
zdyn{EBcWH<Bc&Rg0B;&1{q7aayH`MnlOuh#+W+m0v7+an!uh56$cU6VyxSop!|xQj
z;2Jv{(2O9$&n3CdcPiMW0!V${rhDE1dW2e}Tg|EXf8*t-+JpXWtS3tf+NV(g_1TK0
z(6I5=y`Ma(=35+mP|5v)QQKAS4Q1X0oSA>gq|%$~v+Vbpwt&eJI)Pb>j=IPHRq=|~
zAth!*@|(l|*J<O51@J;9niWOM9Rltb$;Kcy`AvQYzN?d!C(7V`Dj;>%!;cW>Qd!T*
za6&@N_eM*(nQ_Gc7Sf7jiSXoc{xnkugeJkGo2PSk3>7GjNV8z+8#YU9t!zCYYl@!T
zfu(@+0LJe%48@`s@&0NelAJRz<kTeb*98Nc{O_~uyg_02+=vs`#2IJq)|YOV%v08U
zLtx9D16JLO-^VW8S<Y&Lv<Mu@q-_h*@5VN}($Zx!Oae(6>B!T4Skt}i#>553dCN04
zVY58969%)J-wzyxSs+5d?Tx|e7Q1i<ivgb&PTolAFz`fSdI9e~BCyZ%cF?4clpgu}
z(yEQY9aSI^mKbagsvgiwro<QBJ8__esHTwWo8dS~-N()ktoPnnNSVzdfmH%G>g~{G
zJRn{9GqViaSpG~wSqSm1uTmBYy}$lv|GFD}MzLBoD4Rr0D;Od<ANqlX_H}IC|2?+C
a5sCbX<Vp98`G8x22r3Gi@=daqQU4E9y3wHk

literal 9109
zcmV;GBWm1<P)<h;3K|Lk000e1NJLTq005)_008U=0ssI2b=;a400006VoOIv0RI60
z0RN!9r;`8xAOJ~3K~#90?VWja6xY4yKULkW*1jSkfdq&}Y+^CH*}*mjyu?dv$7^iI
zStgT7-ee{-&O3hZ+3)3@%w#*syeu!99osl|9AgrL7r<aJU{<k8LI$x&NJ40DskOA!
zT{VBG5mc#Ly;XHr2|mZi$G)n%_e$TYTlfC%@BV&*EX&;F#z2g92W}EQZi;;aaZ~IY
z2x|=6cJ<NFhO?XQUPJ+V9O+49r(w0kuv5dCXp7zJ=J+|vt0}Ld&B@@&p&*cx#`JL%
zk7fE;#G6Bpb_h|MjW@LMQ3(f6)8|1H@JK^lY!&fHBqgwX2DjfrN<wt{ILwKL*d5($
z+{0((h++VZ2P2ADMApt_-F$4Z{N@Y?bQk;Z8D85?pC@FQuSXO~PvYzA8K0+J&u%<)
z6kC$`^DcIuM8L<lIaCAz0Uln#ZL=fq+6{_cV)wcE&HI#HMAEc+0oKgr!DR?q)_S9$
z%VbxQbWs|RVcSvO-K%l6Hwe0jy<sP1RoW}vk1VtG2)j<`Qu**k`w8xW3ig%`^^q0@
z#^o}#fTDb|Qb<d}YQfn}bt6YBIdD4gR8EFBcT<?h*c?r}KHSmxo88vQ3$M`YVTfAi
zPv&du{Qk7Ag<t-iMn`~#ECN|+y!7Nvb6W^#{ARzs8;>-U(tyW9#U;wBxKK|^2W_3i
z$B~=Cs+r86%&1KM;eKA+K%aZaN@N-xe0+?x^R)d9Vu=iOP1H1Tr42_Xu08;}jkH8Y
zW-xjLqq7hqn3`%Sc1;sU&IDd%9j)YOrJ|(IO-C1JYiV_|W-dAD%$~sE&jZvW%e;S(
z6*EbQi=@}FN0KS8V*hDQU8LKEC?JYRviF@41VjNzLXt^{WBNF5ol0?7hGZ?p{_rps
z3vN&NHS8;6&0K)|EDi^8eXoaICs;Q>{1#)2+r!>c-am}Pi6A0L0FsP!-QQ4_8JNR#
z_j0U~k~5?xv3>!|riW%#)J*Ko9!kzeWF`aLS8wlh1$Dh7vHK)z=bLibU3!rXJ85-#
zmo0K|f4cs^u%nB&cCqyckFRECVX!S~w)6^S01wE*$pErUc~!8tG<R^}a>NZsmp(VI
z?cf)GqqPG`3d_DIBg?cp`H#Qz>h=Khn*lU?vrk<N|K3D9Iq57dX88<&%?GJz3ie)$
zh0-cB+05I!_}RPEw*ZlvBKkk-pOtgIp6@<DT2g@PwOM+}@a<pI(;M1d4=wY4p$90d
zV&`#AUI?KQ0mhHw`G-SmI##rF@T0%d=8W`vr@|tVn#litn5@*HF4JZhZ|w+KX`hVD
zAb$j6C|_V1YJ(mIVvDnfpKhd8Yo!5?M0*!M*+@tCP?u@*W}m*q&o+jCdwd-EBUmw$
zMN<GuFY>F+q0Q=l_I0B>I7l)-{wo*iLr_{2dErqCvH=<${NpPDuD6Jc8_EBA$nUC5
zn>V|oi%2HKJ-t-c@yCzYxEG*!9CyqKu>(Us(MDj)LC%MwG_ZcYSLq<}NSv?dy#szP
z&_?W@UMyOyezum-(gCn|YG^l}ufx%)!E!(+>Y91~pm!M^B%`vpYXN<39GxNDCChwp
z*zfe#Se`zz%*88YrjU~!+KsP%3}Cg86z_FW9g#+Q5^2d~r;(OKT2d_6;v04nk_(3@
z@XQ*l7B=l;&ZNN8Y}LIRcJTZoK7OQ)*zs|pJ+?z&5dr$bGQ+t&I6853Qq`dTk<Cha
z($yy*$@>JPCo?jgc%7}Sm35r04egdSa~U_1+9tM^FlSO|_j)AGU8dp^Qwr2S(njo*
zL~Vvpi^%v~fGe$9RCgVHZW<lFH`5aBiZNhdV8}|*#*z8MBUnQ5w9L)m-bKhVuk8qP
z-Y$xKcvv^Fb2BulhWi$ik_d1p&@RaJg!HEzOqYu;7j-S19`vI``?WFP+NU9j5vjrM
zK6P|adLabki6HRw8f;cRIl=jGErXK8=}WXZNl#XkYa@1gGVyW2F125Hj59TqUZkai
z_AYw*NRFp4mz6Uq9tUu#ksZf_Zd)Kej?SL2`W=Wamya(3{wD|7X(ZYeSC&+U_O-rk
zHWTt_>txfuh<Yvv9Ia%v(m7Kbu?3h?z{v|ieYtbe7@OmFaaDSeKW+_Sk!=-OIg^D`
zXm!%kK}!d%{r`5-+)i(BM&nQ!VsemRCnK4x6f#rDNTKXv2uf$CasLv4H$R~}LL-$-
zd9^-b1I6QlHFLi72GhqfeJmq0NJ}Cyj-Ec6+qqEBq0jleCbV|l9%hXvFO$4XA3yDL
z)7D9ogGL8!oj5vabl`B(q}y}Q?V{U7U9<Opt(IWNZ~?x22XR)8pHuJmhk+z>X3$?!
zGqL9v@#ZH%UD@2ur>FSzls4^Vr7|wp?@w)3@8~*s-QMM*(LtNj`vf#yeHxnEwRDvX
zeu!Ezi^=))^z!H6{)_?X?xmw!VOZ2m>_j_rCs9&~Cj#e%P_YQCoEhc<I?>M993L)=
zZV%3$>z;tCPecEspc7fCJh%j4(`U3gHLJFvO&_s=^$P;~5^0Og#>$x**J-too<w?*
zkLO_EqcHGA=zkQhv_-lPbnhbK<G6T*Pc(Ir?pFGMXesvSEap$vz+WXu1cAF3>TVLb
zo`H|TU^=>Jb$Vxo{nNvi4z9EYYqam5!;c%u@4n;vg6uSY{|^9%&+xksf~r$M{RnDo
zE`4}8C(a{Dx|^vjA|ukc{T7{@37V8dQW6=X91O~;`1z(7bqHkC9%>qkotDH?xATV&
zwXM|`0$*F_wXGVK;76TbZT9=47an75PEcE%0Xv}mUu(f+md^;y0U=Zbczl)mH8LQX
zDKYMV%5g=PSL3nO6c_6C+6e;d7qF~Ym&&yzJsDf<4y;%$>ZeT?K}3OXtf#mzqT>rb
z5n$aszOY#1YIQ<@F(YHvdO@~&eAVltXS4FnyIDO8&_?q9cpHzc=KdvS@)DmuHZ~Ir
zi^%k`>O$SaY#goRPuu8qM;c}$Bbjg9#kknLDB)4t%!{wbrs@8f-Sz11sWN9GMftqD
zm%U|ygCq^cA|k-;bNIroraZ7YI*U<RTy6<)*imByMyB~N3PodxNsi~K+xhpWSz3(U
z214MGtzTEWjpPK}5_X#@mF_20=gG(s{4^T9IB5O!xjAux@+!)zXzlPF^loH2iFT?R
zuk9jarSijPw4d%p2e*gkU#7h)N-wtnDT(~wulRU9qU~^KvodcI^CkiGxoL3F-bqg{
zqKMt*bqKMDY%Sq@{k6NA+bOH^x;B^&tA$5a@cZCwoRK5L!^?dSgt0V1*{qDtV(J)f
znaHg1Oer8Y!#lz+nWpaUp3<1~Q5)tLF{L0H({hW2$@wgp;`^rtwKpawFnfZc<oJ0V
zcNn9<bL&X3>ugvQh_~_8b$*wo1{E7vuC$R!5}%dFs4H5Kn#g~>2SL<p<{^M6^38jO
zaxyor*i*)+j|%K5jqU<QYbK838|x8>=%|!W1i`yAR5W_1%Zw|w086GRN*Wy@d#D+W
z*%Nqp1vXL3(AxdB#c$oqoQZ+1)T~V%STbEbsrl5*(=@=<$Ij!(5Fe+_e9dAZJ&ETZ
z2`bozp~X&1QvVLeDot=;a|qtrMME2I4_!T^B!UqBfk;tAfJKve@rhuA{~20rP;X_r
zJscQ(aKj`VKgZs(YyaEkB+<_JQ9x++L5l@oLLSdQ!qaO=um`%~D#kj+Ihf*cWTn#F
zey!xwQ`|nsOdDVQbaeCj4t3!jw{Z7DF4VK9ltZ86>hq>h@G%V)un2f0>^9~VvAj5(
zFfv9LTM$?>O>w}yzLm;aCJj05G$0#x(B7pe88^}!!L2Zt!dxC(#rexr)KJq%T{G?7
z^!5S7SxHG`R2Bszm|VbwyzsXPj4n2?w3sai6^{FRN=+vAo>KK854(-$)+**`RtrV>
z6y@vK4WoavfsACeRs6_Vx`K;}X9SwsdHYj!;X}(AsnOBb;4y*N44S6(xj9e~qppOA
zEc41%wg2|?vEGPpQN|o%&nzTeX$92ksF>b-c$hQFunWlvJhLV?6HIf6Es89jt|+N(
z;zGTjs|`bS1Dg-33m;z{T8tD8F^AZ|vSRfXg27*Iw}+RvsZVh(p61=lj|rv`dqgTz
zl|e!dpNaUyx}LndPaS$OBbi55#HcrbiNpq$DJM0qzR*IiM3b|%e0)q%A_zQtr#c8n
zlrfXov&VbG>kP2RkRy4wi$8p%-i=)|$4B_0C}SqEtrm6U!>R_VeFeCQEpL3{jng>5
zs7$_aYm9nx9cB`n{%M-B#Av>0$0|9fv;kNxJh#peSz}Em_Q(t-DGiDTD!f^8j6ho_
zuYIg8{KBoF#hcX+lZnkB-?W}yj+}{6SCq)`+IF1Eh-?!_sRQW85c7#WcM{3U(BcLe
z$#<Pl=gzR(cxH{h9;G2+KC!J97ApOs&t2wHV~l!pl}3j*So-xmx-#VO%DQ4cv4ItX
zb`kcK`MNGzND{yQP(5{+J%J_D{oD{EOeuC=CKHr?8v9S{6|pcFwj5F$>QfSU^0pZD
z#y_SM8`N8bT`mnmK!!(E10Nhx7k>E;QWJe$9aGFI_WUBX=`kkOv|cxV_)vZ5eEAG!
zjgLWR0%BINZB`acR+OBn<#J23yYbgO)GOoQk4WXAWzp_NkeF3$V8x(7mQkLjl~=P{
z8GTX^c;?Qi23-sZ6N{ZcLLFjdUwK41enX<m#jD%ZKELbd2RLmNTTCoAgM8DR-5fs`
zrKUIRQ15n($>HvWQEELr%q{l9De5sZI)}jyRB%{nqqSOic8$>kznEKWyN&rpijs<I
z8rt-2w9V-wjQ)d589hSZb|c5!Vl!wYmtmitXZB^8KW<fftxqlBw%LAeFcPL0yD(S1
zfw-?s$AIS_AEV-uq9no2(`(ET$;tF$151@Jx1%$(4BWwUxrI%isS6)p75nJJK{6b~
zzI6(5N<R=itZ5#Jm$%ZVw7}1qsNRAzGQ&aa1Uqw;&e)|@ic`Lt@ZNqdUQv{!C-LO%
z8n>b=!$E8Y?Tg5=#?!QOm-*<3qNG0!S8}|Tt?11#5qsh&MrA2V_Lgdvp3Bw8%Ujj8
zt(s-Nh>OESY+$L<Q=rvJ=|yd7{>yIl+C3+o2bOA6c{CY5V&6JV?XIhdZ`z6T>Uu<x
z=hkAkX;68T89rhs$8(D^0_MpJv_%#H)9EV^%H0bo^q&yY$P6E`8Dve9BtDC5({sa4
zb->iIIjo-_QJpblScyHkK+6c2d&?*}t0;-H@|@w5i4B2iJMIf%(97M_&gn~jt{#%6
zcHZ8tE_`S?xls><q9MadY+&&;^_zFSHBFM~a?#cqApVXl^U5~$;qPf<eE7zg3j-WC
z)0EUiW=~KIzZEsSvzPOix!i*Dx=@&cKzb6RM=)tLQwtcEd+o^JM@Q6|#uNK@J9O{9
zzC=4mNEGN#ciOLIM-Of{7K{I^-d7_BrYEy(I;&>U(ajIuRNKJ6zMgqSerhle!%*yo
zHh%dYms_!jp=EBjhzJ7XMp9X)C|@*%udLO!kFjA`4dar`hlkmG5M+=;QyRRx;OFZ}
zup>gJ3m_wzM^|az)tE4R#CCM@+xIzFj})2bf+Tqp%4em~(jNOjC>k<M#BOx(lXq}*
zMymAnw01Bi+k6QjhhR7?y_(wj;afO5HTFi5Bx;)Y*}JhkGN>)47u(s*Pu`)+rHkL0
zN22-)zu98$L^K1Kdp0h^FE&w8Gt^uxEs3IhCg(FIo3tcS6Y2BN+)l+McAex(tKS<3
z5CraBWb^|7!C-E&cOK`h-2q;^A3sNWvhN>xBsT74`_aG+3Gn?dnRT;k025Ep+Pm1a
zFW3S0OfCD%`Mic!C-HGiAIk$v$V}nk<#f9gsXKfkh`jnS|NOXt0;Gh2iN)T0fW9EU
z)0LOmR-%ZE;OypL1)taO&ySOmz=O-!e>%V?Uy`V6=3oW4P95qpgJaeSnxm6FWkH!u
ze*3=fVAX9-cAWr7jt?%mip-XS=ANmURqVZG_{xzJ8Uu&-{e9H0M}~$rbEgb6vDlH@
zPX>a#yMha4Z4u3#{MD3VUumVu5&4Vl-N=&VV3QJfBu<>ypxszuO0g?yG?*37FY?CM
zDmfcM%EvC3I%K?wFs0a+8X`S4nUl^Fw*hp!cxO;#!XXd^BL=+=5>tv@(;Sg;G%23{
zb}xx`Wcbte&`yPkqB=a1i7=(utsQ}{@rT{UckUxM6X5OLA&1J7q=;INEv6JZ>;U67
zE8n`;YxR8ZfI5vwFi5gGBb$jZrP$#ux-25!xXYWUV`~YU4+Ofw4}H;!zNI;)6gw{T
zb5^3jSJ!z{ukSp;JA1-xTEN7PE2b1XDa2FJ0zAFOdtiT0DQ^vmbrd|JCFItPgDJ(%
z%M5Ml_4sP<2FCu=yuKqMtB8QH;>CxADa9V0g(YaQzqrhMlH<r3{<JO9oeZ}}ed^yt
zm~xAA(rDbl&Cx`WJFn(rnOEf3(f{3je0Vsh3I!p!Eiyx5$~SvLUTgwK_8%cgFlx}@
zfSB^lwpp1ok&?54?P!w3SAVWqy8`Nzf#$-LZ#J;BSjRAi{t!fSpZGGX*i#EA$VQA}
z_bnnTW~ft&nG3Uu4cxz2%kv)r5k=O`i(YejU}CXn6f&bQN<lCBUB`p*UNSN!78`i-
zHtbg2-Fqz}1=-v&N8eVWfVsuaNane9=sK2*0&!NpdAEt<<_uu^-(W@|kFL}!0EQqS
zh<y7#vQqVFAi9`dY+&^)?pvb0-hzNd<XiVJag^3o$B5w|Hn4UcMfr%LX5Vj%NP?aJ
z`9<?Zqa6ZMTF?fw{V1Q;Ad19U>2*gOk655Em#^PNdQ#wPO~h~zyS|0L?+1`1dL+`4
z=;%Ta!ZEQ~L~IrwTF$a!bEN$U3DXbblEll~6p^ePoy;p@Suqw1q8OBB{WI-28=0x}
z^f7wGFjSgh@MeE>M17tkJ(<T>lW6CGC6rWBa+WhS^tutia@}5;EPG%5<OEU@Xm!%l
zOJf_r?vv{L+`|KNAI7h1;Rk<Kyw(DI`#$xoN|LB+p}v*oc6xeodx*0VAIHcHax=(D
z=NErdM54D^_|aELF<t`f2r==SElIpGC>_tT89wIEqDcM-^8IJjTRBr9w%fzLa@LyM
z5<VCcf3vq7Qm5m|O67}T<*uGls5YB?ddl2Kv3+7zu`e~M9f<^Z^0qMDNJK#$ySmXq
zSylMmGbW}K+wI}yt?E?SD`zo%Z1{C9pP_bj+I2Gg+Kh=Q#ols|8s)j!5ve>FSvsDS
z1Rp6zG|vPVTg)eRb;F>1Y68!!(I6eqN@eVLS&mXR?x<lhvHJ&bm1*p@*%ak#P<c^4
zqm@44drql87N*8zV*h<Vwato>>@@CMtXcibl`nTkH^)Le(`#hRB=-5sY%5WeXf=Qj
zuz0F^K0lnMX{Hgo&&{jb)!SKj&SlbQEnA6?W5Hxa$(dRc2T@UB8nNHqM_r4eBsY_L
z7ir(n%311?-8y9BjtS-v``l%A9#@ozBG0Z-C*RbB{1NJ1ko~9CX`f7r3B>Mo`^ad#
zZk~=Yf>kefPcMfm^lB@bm_Y1z_NX%&kILk(1v<7kZ<2b;Yv&0an~NGo7rWw;H=OJM
zqR2CM>N0>2V70JhnxdqxS)KpMj2K#MS0Ar^tPYfL*MevyX<0c_?YlS()?kJf`|VF@
zbSO#+vZIvII4f1Xtx|H9j;?4ltslk}`}8G6&Q!o^;n_Q*cMM-OO>=t!Cmb+11{J&8
z#h<pR2k?6q4&`m4IWxvFLg~@4>tw`E$}z>DV*lk+T9i>E$K-Hlbp3<`fn_rkB`qBa
z?<Lb=M6pj^V4rfp>>t3Rf3$8{vHGjA+sxB6!-?JHV#5w~;eCtMn~%{UCBYjiZ-7%5
zX)>)xgW<$}^AlQ~ijwhpu{;~?!=u5prgCG6ed0U^l!i&0l`r2B%WPT`N2zCpdrH;*
z%VxnqVmo_yeb4~@z!FAf#-caZu|oNBJG(=UQf?3oB=#FSadaw5Cgibtc8q#+9k&h_
zj|QWNee4`Z&L~RatUP<CA<`k*Z7iIkD5<P7Wu_2Ai0$n5F@S$@nStW}u9~fm>|jR6
zQ$vWoVW-;cJf*;g$4CqrmB|EUu#E#I^k|5^*as^pIjbnK+j#1By<*~ojcN_%>f_+)
z7<DCFVl1|!lQ(y%3m;iQc3KQNGc<E2k*f4)_~eAiviHSU>^DB4vqw=fbqq_3{ahVW
ztQM9|SCrJXP+1$J-h@Rg#r~{Z?Sh|R=jl5PH-HbY!sH$eF%!G3lfUd%7k+64nJKa8
zO>ktUs89MIt)$&N9t|-Q`_=7qxfCTc3t2qP&((%OHBEDS*lV6OSZu`JQ>xw=PPBV7
zp&FdxLiOr@_bJnOG{ivc=63%2sk-p7Rb-eUz_WllMng*nr!K^(Hz5*jv1NFDhuR!5
zYrNVXX=Ij8S35GBWttXkv3H$N$0|uq;7KzK-~%KlFn6M&r0k;l7=tm1$k)E5gU@TI
zZKAG)Hm5iFt=&dOGI^Pd9>L^%#q7GNop<-CD|vhsX=V!%x^k9c-(7}1rIE(@hyvk=
z-R9)8a`u(e(1s`?qE4xHsfqGxBpFF!WIBtdvv?Y5iM+B+osamI38u`aGa-*LIf{+1
zy`|i{NZ)fRkrP^k!{&Cj9AbYt5NsG&0dJ0;;zCYcP^554N#vy`Nik<Wo!zI@zH-mr
z>CO0QSc3g#dnDdJ#0#&ozZ{PgLcm`c@Aah@5Cuh0=O<R1RcT<+6cUuVm5uLs8kE@0
z?fjp=@ZNshp72wrc_iE(9G#>kAqp&<!kmeL?=mcQ8;g`Hh;x^X?$Hof?5YO-_0Lo{
zYGXQ(!P!HcO}$z*Bdcbq&G-h7(GWoFbC>zi+w{1!Oqb^I(Cg+u{>Hh>n$;N-@-o#C
zT@F^z?ecTA0T@c`+Gc+KE^bMCbD$*A>){uh)L~Lg$6$|!{RWQF;CD9O-OG!w<8a~$
zr1Zp5teVBdQKTl)*+X>$d&+_eA0`T9rt&Y36K~oi#U6?0|47?)PO*8Jy!4bocWM2K
z{kso1dJa#Z_<r{+;+{o5ez$`aJ_4Z(Mig04#8=h^*I7gIx6gS0kfP*!U!*7>Nv64-
zRwu4r+#cfNNQx&rJ(lUWeT!XI#m_edzIo|%zI+G3>1y8D%jFg_Q&>OWyHmOSC~pti
z@bJlZA7pAl2%R<*EggLS<!g_%&C29_+PkQ2^1X6NO=L;|Q^zo8B8he%7wCr%u_c)o
zUZu$qAi8>d96x-9<OHf3_~BcMU+lTHES!QQ^DnPcALy$rie#tpZ%>&x2g@(t<HUJV
z67WcLxv*LSL_D>KNHU_xoC&O(PeFE+`srhWR&ti6w!m@p7fkjhlisvX{RnUR3|U4L
z)bkggND^0CId(4C9vclwCNC4amChcoJ4V3RwjK#t#^d4WIsWYpeziGDv95iHy|sj3
zCK$8F19Z74uU7x4x!s$QM-{=_AA+EcDs2`T+W5hr*;axptjuv94>Fv($P2Hs^SJK5
zs%o(t+Niz~RC<hYxd0dHeP7(ahR#e0${;GsT&U+tYv3yl#nDP$dV{*=NSCG_4{i@{
z?c&#)y*r0Gp%(kdS?|8Z&?LosRa8YY8ldTFd2VoLFfA67jpVye@}FDi>kHq0tU`v9
z7x?izYTs%NQ43pM6_l|o`Re=XFIrT4xBAMV@kl;C2Zm*D8E@=FM&p53lBj9oryKQp
zzZGK3{ljt)w+)2&?(;Jl891&UA7n6ane!&Go|azZwe5O+Up*dboB8z?T@p<xcH13J
zdP9sUpkbd}ecnAWBh%8s?>_(`z)PKxOku9~pK&9-@5b*w<nZT#n~)?bs`=os_VHO2
zVh0}@W?-C&^W&Q_;Iq*a%81m|ZgjE#v<;U#z$0$6@}uV>YDJRy`+jB?YP<wjXchd9
zjq~a!*<ZrS)CBdF!O#`T#nGqaEESgm58$#)o0ALmT)4u8dQubl>bj8I65zFu`Nv1K
zG_xzj_V)oEOlJ=r-J~S=J#IPTYI#5l+V%Xu_eivpo<v$Q=}Dv|DgHYvHI{)GWSNbF
zyd{0&_VB$wT>Iadh2b<O$y8n8<auU|59fBDD8%+RCi~=KJu?a^%ta7<3~T+t_***Y
z2=Qg@a?$1Tz4d9ekQ9IQAxOUZC|v#Tv?P7^nvR|GCR~ml0-F!&CU!z7cKPGynNdih
zo#|uMXL+(xy<z^fT{`!BHK~H^3}CZf9Tk#DPbNF<+S8Dc9NMqulU*kfg{YqNk!7l`
zP}{_4jUu)x#8$;+9hyU*bN^zJ6S!|Nr>hmVg$I@(2uN~Nk4p5pakz(i6s~<2lmkOn
zYT#s1j!r77V{r7|B66TYGmmtI*l9`FZNaYSdwSWpmoMMJ*c`rdpJI!%KU>m{W1)Sp
zt)klhTtoWYG&=m+`-Yk*q#%l%z7%-5r3W5~6X*328yKHQ#id|Z&wI<rNa3DEOdZ2N
zJ*N24!3y5l6GA^kfx<kN&%n`1s}n~jZT<i5j7B)YAtnl<NNOTh3!)I%X-5z0TXFV~
z9IruDYO$w{;Y@8{2bBRfAK-K~t7kEBG${#mxu|YnPie?800n_tCa9fr`{{Gj*69`A
z;iRpTCWp7Ar9(5*v_B+?HYawQ?hW}vmZ@u|NQ+!`YO&`R@$TNxs;I2fAX$neaf=@}
za+{UxG{0-SF4wg&;QH~v(MfZ=X7j1w7p0nG5vgy{N9?Rr3iG&FAJu86ATT~JwCUjh
ziFOk0jPetpy30kQ!}rtB-WkFtSVK?hP!WWXm#_Ztv9ew}m)~sBruJpE)lmQd13pPa
zK~x}-VVyo%0ut?v&0%bgj~}@`ID6ECL8HU_rRXw_`?st<4H-5*#GXBo+)S>tM(O1i
z1@f|(sh#N{NURpplSohU{U~(zdLM#TCyi}vJ{axpT|+xlkq<`&0iIZ`%NCnYWSJ*c
z8_v->A&$IErWA1NRMzX69WWTQ@~ijll~R<?;%U*y$sr0XD`w)Tz*oi)t3}Hc-Jv4O
znw@p^tLLMu7?B#3i&EHFL~=6t(n=kh(25v_*Yrrix^@M`ub6fl-@cFdIK4KSM3DqL
z-~NKpqZRZsZe$E{5A`Dme%BfyS2c9xh3W=={0_Ztjn^I)kvJ>gdnkJT@e#8BG_Pz6
zVIK3f^~@hKe8};0{AzPhRpn*!uTKTr?$88yT*u__{YOZS*Ydfxh@>R){V$nDX<*uz
z7#PL@i>T!mXHYR!+PnDO2b`^qbTK9X0#ge3>N@iU*!by2&eX&pnBj|0Xtu=})C-%M
z$p3hdM^<3Bh5w3MMC>*mUCDpH-+W2~D`!SqX;EZMj%G>|d}u5|VD)U~74gv#cAdl{
z1^X2jKoGHrtenZZd47G?jL)2jWT(^A7QNwImbiD3mKBB;8mk{?4~Ht)SI(tIkg-_2
zC)EZJ1w;{#2LuYTSu%|UQ?%Kni!CK*`R)5r5?d4)lcTZ2VK`zB;OyaS4K+>Fx6;;0
zR}Vm9Jn2c~W|E&pQ9eoL*Z6vVwvjWn(b(=31petUjpwitiG2go(!q-x=;_thoGc35
zd#m<`1Y)24$6REl@U?aNF2gJ$Q^&A=zV<cW6gy;!$MK|YnW!uxqq6ufck2>|;-=W)
zu&kKJR(s6`8e$R2&*r-i>b383^P3$$M=SZ`Ry+}e_`DtgW>4g~wV@r=2(5{mVn;$l
z8~^z}wM`M(TPz}iz(dP)Pbqv;>`0MhcAsR^K3t)17g<CkiJ234bOl*qx!{GwO|iAX
z)yJ-r>^x3O2Np{JUu<t^EP-1lux>tMeECJ`!A-HXM22&9oH$Qe6?M(NzvU?jOetX6
zSYrgeyNM=95>4&2bl~cv&*OD@9+|Ge5yP;#DfSJ-&2{z-#7(hpAa06%1M&X>S?30w
T@&4e-00000NkvXXu0mjf0+QGo

diff --git a/test/visual/mpl/graph/references/state_city.png b/test/visual/mpl/graph/references/state_city.png
index 990c433c9162c5920d3b26fd36cfdf1fde20d74d..a9af6d8b87f260de8510bdc08706a7eae01e8388 100644
GIT binary patch
literal 108666
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
C+Dc3S

literal 106823
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

diff --git a/test/visual/mpl/graph/test_graph_matplotlib_drawer.py b/test/visual/mpl/graph/test_graph_matplotlib_drawer.py
index 20fae107d30d..7100602f72a5 100644
--- a/test/visual/mpl/graph/test_graph_matplotlib_drawer.py
+++ b/test/visual/mpl/graph/test_graph_matplotlib_drawer.py
@@ -113,7 +113,7 @@ def test_plot_bloch_multivector(self):
             FAILURE_DIFF_DIR,
             FAILURE_PREFIX,
         )
-        self.assertGreaterEqual(ratio, 0.99)
+        self.assertGreaterEqual(ratio, 0.99, msg=fname)
 
     def test_plot_state_hinton(self):
         """test plot_state_hinton"""
@@ -437,7 +437,7 @@ def test_plot_7_qubit_gate_map(self):
             FAILURE_DIFF_DIR,
             FAILURE_PREFIX,
         )
-        self.assertGreaterEqual(ratio, 0.99)
+        self.assertGreaterEqual(ratio, 0.99, msg=fname)
 
     def test_plot_16_qubit_gate_map(self):
         """Test plot_gate_map using 16 qubit backend"""
@@ -455,7 +455,7 @@ def test_plot_16_qubit_gate_map(self):
             FAILURE_DIFF_DIR,
             FAILURE_PREFIX,
         )
-        self.assertGreaterEqual(ratio, 0.99)
+        self.assertGreaterEqual(ratio, 0.99, msg=fname)
 
     def test_plot_27_qubit_gate_map(self):
         """Test plot_gate_map using 27 qubit backend"""
@@ -527,7 +527,7 @@ def test_qubit_size(self):
             FAILURE_DIFF_DIR,
             FAILURE_PREFIX,
         )
-        self.assertGreaterEqual(ratio, 0.99)
+        self.assertGreaterEqual(ratio, 0.99, msg=fname)
 
     def test_qubit_color(self):
         """Test qubit_color parameter of plot_gate_map"""
@@ -545,7 +545,7 @@ def test_qubit_color(self):
             FAILURE_DIFF_DIR,
             FAILURE_PREFIX,
         )
-        self.assertGreaterEqual(ratio, 0.99)
+        self.assertGreaterEqual(ratio, 0.99, msg=fname)
 
     def test_qubit_labels(self):
         """Test qubit_labels parameter of plot_gate_map"""
@@ -658,7 +658,7 @@ def test_plot_bloch_multivector_figsize_improvements(self):
             FAILURE_DIFF_DIR,
             FAILURE_PREFIX,
         )
-        self.assertGreaterEqual(ratio, 0.99)
+        self.assertGreaterEqual(ratio, 0.99, msg=fname)
 
 
 if __name__ == "__main__":

From 86c63eb3d719a129dbcb92c56e9a67954030b803 Mon Sep 17 00:00:00 2001
From: Jake Lishman <jake.lishman@ibm.com>
Date: Thu, 5 Sep 2024 12:51:06 +0100
Subject: [PATCH 49/85] Fix `Interner::with_capacity` for default keys (#13092)

The new method did not account for allocating the default key, causing
code that then tried to use it to panic.
---
 crates/circuit/src/interner.rs | 33 ++++++++++++++++++++++++++-------
 1 file changed, 26 insertions(+), 7 deletions(-)

diff --git a/crates/circuit/src/interner.rs b/crates/circuit/src/interner.rs
index a8ac269b1a18..a72efb037afb 100644
--- a/crates/circuit/src/interner.rs
+++ b/crates/circuit/src/interner.rs
@@ -105,9 +105,7 @@ where
     /// `Interner::get_default` to reliably work correctly without a hash lookup (though ideally
     /// we'd just use specialisation to do that).
     pub fn new() -> Self {
-        let mut set = IndexSet::with_capacity_and_hasher(1, Default::default());
-        set.insert(Default::default());
-        Self(set)
+        Self::with_capacity(1)
     }
 
     /// Retrieve the key corresponding to the default store, without any hash or equality lookup.
@@ -126,11 +124,14 @@ where
         }
     }
 
+    /// Create an interner with enough space to hold `capacity` entries.
+    ///
+    /// Note that the default item of the interner is always allocated and given a key immediately,
+    /// which will use one slot of the capacity.
     pub fn with_capacity(capacity: usize) -> Self {
-        Self(IndexSet::with_capacity_and_hasher(
-            capacity,
-            ::ahash::RandomState::new(),
-        ))
+        let mut set = IndexSet::with_capacity_and_hasher(capacity, ::ahash::RandomState::new());
+        set.insert(Default::default());
+        Self(set)
     }
 }
 
@@ -196,3 +197,21 @@ where
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn default_key_exists() {
+        let mut interner = Interner::<[u32]>::new();
+        assert_eq!(interner.get_default(), interner.get_default());
+        assert_eq!(interner.get(interner.get_default()), &[]);
+        assert_eq!(interner.insert_owned(Vec::new()), interner.get_default());
+        assert_eq!(interner.insert(&[]), interner.get_default());
+
+        let capacity = Interner::<str>::with_capacity(4);
+        assert_eq!(capacity.get_default(), capacity.get_default());
+        assert_eq!(capacity.get(capacity.get_default()), "");
+    }
+}

From 8606f058c85e065e8549516339491e4e666de175 Mon Sep 17 00:00:00 2001
From: Shelly Garion <46566946+ShellyGarion@users.noreply.github.com>
Date: Thu, 5 Sep 2024 15:20:17 +0300
Subject: [PATCH 50/85] Port RemoveDiagonalGatesBeforeMeasure to rust  (#13065)

* add rust code for remove_diagonal_gates_before_measure

* replace python code by rust code for remove_diagonal_gates_brefore_measure

* make some dag_circuit functions public

* fix some of the tests failures

* fix another failing test, add more diagonal gates

* add tests for added diagonal gates: p, cp, cs, csdg

* make the lists of diagonal gates into static arrays

* formatting

* change nodes_to_remove type to Vec

* remove the HashSet following review

* add CCZ diagonal gate

* add tests for CCZ diagonal gate

* add release notes

* fix lint
---
 crates/accelerate/src/lib.rs                  |   1 +
 .../remove_diagonal_gates_before_measure.rs   | 107 ++++++++++++++
 crates/circuit/src/dag_circuit.rs             |   4 +-
 crates/pyext/src/lib.rs                       |   8 +-
 qiskit/__init__.py                            |   3 +
 .../remove_diagonal_gates_before_measure.py   |  38 +----
 ...gates-before-measure-86abe39e46d5dad5.yaml |   8 +
 ...st_remove_diagonal_gates_before_measure.py | 137 +++++++++++++++++-
 8 files changed, 269 insertions(+), 37 deletions(-)
 create mode 100644 crates/accelerate/src/remove_diagonal_gates_before_measure.rs
 create mode 100644 releasenotes/notes/update-remove-diagonal-gates-before-measure-86abe39e46d5dad5.yaml

diff --git a/crates/accelerate/src/lib.rs b/crates/accelerate/src/lib.rs
index 6561dd258614..e8760ee2c616 100644
--- a/crates/accelerate/src/lib.rs
+++ b/crates/accelerate/src/lib.rs
@@ -26,6 +26,7 @@ pub mod isometry;
 pub mod nlayout;
 pub mod optimize_1q_gates;
 pub mod pauli_exp_val;
+pub mod remove_diagonal_gates_before_measure;
 pub mod results;
 pub mod sabre;
 pub mod sampled_exp_val;
diff --git a/crates/accelerate/src/remove_diagonal_gates_before_measure.rs b/crates/accelerate/src/remove_diagonal_gates_before_measure.rs
new file mode 100644
index 000000000000..10916a77fca8
--- /dev/null
+++ b/crates/accelerate/src/remove_diagonal_gates_before_measure.rs
@@ -0,0 +1,107 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// 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.
+
+/// Remove diagonal gates (including diagonal 2Q gates) before a measurement.
+use pyo3::prelude::*;
+
+use qiskit_circuit::dag_circuit::{DAGCircuit, NodeType};
+use qiskit_circuit::operations::Operation;
+use qiskit_circuit::operations::StandardGate;
+
+/// Run the RemoveDiagonalGatesBeforeMeasure pass on `dag`.
+/// Args:
+///     dag (DAGCircuit): the DAG to be optimized.
+/// Returns:
+///     DAGCircuit: the optimized DAG.
+#[pyfunction]
+#[pyo3(name = "remove_diagonal_gates_before_measure")]
+fn run_remove_diagonal_before_measure(dag: &mut DAGCircuit) -> PyResult<()> {
+    static DIAGONAL_1Q_GATES: [StandardGate; 8] = [
+        StandardGate::RZGate,
+        StandardGate::ZGate,
+        StandardGate::TGate,
+        StandardGate::SGate,
+        StandardGate::TdgGate,
+        StandardGate::SdgGate,
+        StandardGate::U1Gate,
+        StandardGate::PhaseGate,
+    ];
+    static DIAGONAL_2Q_GATES: [StandardGate; 7] = [
+        StandardGate::CZGate,
+        StandardGate::CRZGate,
+        StandardGate::CU1Gate,
+        StandardGate::RZZGate,
+        StandardGate::CPhaseGate,
+        StandardGate::CSGate,
+        StandardGate::CSdgGate,
+    ];
+    static DIAGONAL_3Q_GATES: [StandardGate; 1] = [StandardGate::CCZGate];
+
+    let mut nodes_to_remove = Vec::new();
+    for index in dag.op_nodes(true) {
+        let node = &dag.dag[index];
+        let NodeType::Operation(inst) = node else {panic!()};
+
+        if inst.op.name() == "measure" {
+            let predecessor = (dag.quantum_predecessors(index))
+                .next()
+                .expect("index is an operation node, so it must have a predecessor.");
+
+            match &dag.dag[predecessor] {
+                NodeType::Operation(pred_inst) => match pred_inst.standard_gate() {
+                    Some(gate) => {
+                        if DIAGONAL_1Q_GATES.contains(&gate) {
+                            nodes_to_remove.push(predecessor);
+                        } else if DIAGONAL_2Q_GATES.contains(&gate)
+                            || DIAGONAL_3Q_GATES.contains(&gate)
+                        {
+                            let successors = dag.quantum_successors(predecessor);
+                            let remove_s = successors
+                                .map(|s| {
+                                    let node_s = &dag.dag[s];
+                                    if let NodeType::Operation(inst_s) = node_s {
+                                        inst_s.op.name() == "measure"
+                                    } else {
+                                        false
+                                    }
+                                })
+                                .all(|ok_to_remove| ok_to_remove);
+                            if remove_s {
+                                nodes_to_remove.push(predecessor);
+                            }
+                        }
+                    }
+                    None => {
+                        continue;
+                    }
+                },
+                _ => {
+                    continue;
+                }
+            }
+        }
+    }
+
+    for node_to_remove in nodes_to_remove {
+        if dag.dag.node_weight(node_to_remove).is_some() {
+            dag.remove_op_node(node_to_remove);
+        }
+    }
+
+    Ok(())
+}
+
+#[pymodule]
+pub fn remove_diagonal_gates_before_measure(m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_wrapped(wrap_pyfunction!(run_remove_diagonal_before_measure))?;
+    Ok(())
+}
diff --git a/crates/circuit/src/dag_circuit.rs b/crates/circuit/src/dag_circuit.rs
index fdaa81e3b4ca..381ef25b7a7e 100644
--- a/crates/circuit/src/dag_circuit.rs
+++ b/crates/circuit/src/dag_circuit.rs
@@ -5122,7 +5122,7 @@ impl DAGCircuit {
         }
     }
 
-    fn quantum_predecessors(&self, node: NodeIndex) -> impl Iterator<Item = NodeIndex> + '_ {
+    pub fn quantum_predecessors(&self, node: NodeIndex) -> impl Iterator<Item = NodeIndex> + '_ {
         self.dag
             .edges_directed(node, Incoming)
             .filter_map(|e| match e.weight() {
@@ -5132,7 +5132,7 @@ impl DAGCircuit {
             .unique()
     }
 
-    fn quantum_successors(&self, node: NodeIndex) -> impl Iterator<Item = NodeIndex> + '_ {
+    pub fn quantum_successors(&self, node: NodeIndex) -> impl Iterator<Item = NodeIndex> + '_ {
         self.dag
             .edges_directed(node, Outgoing)
             .filter_map(|e| match e.weight() {
diff --git a/crates/pyext/src/lib.rs b/crates/pyext/src/lib.rs
index fdb2bff9a21d..1478fb367a13 100644
--- a/crates/pyext/src/lib.rs
+++ b/crates/pyext/src/lib.rs
@@ -17,7 +17,8 @@ use qiskit_accelerate::{
     commutation_checker::commutation_checker, convert_2q_block_matrix::convert_2q_block_matrix,
     dense_layout::dense_layout, error_map::error_map,
     euler_one_qubit_decomposer::euler_one_qubit_decomposer, isometry::isometry, nlayout::nlayout,
-    optimize_1q_gates::optimize_1q_gates, pauli_exp_val::pauli_expval, results::results,
+    optimize_1q_gates::optimize_1q_gates, pauli_exp_val::pauli_expval,
+    remove_diagonal_gates_before_measure::remove_diagonal_gates_before_measure, results::results,
     sabre::sabre, sampled_exp_val::sampled_exp_val, sparse_pauli_op::sparse_pauli_op,
     star_prerouting::star_prerouting, stochastic_swap::stochastic_swap, synthesis::synthesis,
     target_transpiler::target, two_qubit_decompose::two_qubit_decompose, uc_gate::uc_gate,
@@ -50,6 +51,11 @@ fn _accelerate(m: &Bound<PyModule>) -> PyResult<()> {
     add_submodule(m, optimize_1q_gates, "optimize_1q_gates")?;
     add_submodule(m, pauli_expval, "pauli_expval")?;
     add_submodule(m, synthesis, "synthesis")?;
+    add_submodule(
+        m,
+        remove_diagonal_gates_before_measure,
+        "remove_diagonal_gates_before_measure",
+    )?;
     add_submodule(m, results, "results")?;
     add_submodule(m, sabre, "sabre")?;
     add_submodule(m, sampled_exp_val, "sampled_exp_val")?;
diff --git a/qiskit/__init__.py b/qiskit/__init__.py
index 38a9f5952425..d9979c9d4d92 100644
--- a/qiskit/__init__.py
+++ b/qiskit/__init__.py
@@ -74,6 +74,9 @@
 sys.modules["qiskit._accelerate.pauli_expval"] = _accelerate.pauli_expval
 sys.modules["qiskit._accelerate.qasm2"] = _accelerate.qasm2
 sys.modules["qiskit._accelerate.qasm3"] = _accelerate.qasm3
+sys.modules["qiskit._accelerate.remove_diagonal_gates_before_measure"] = (
+    _accelerate.remove_diagonal_gates_before_measure
+)
 sys.modules["qiskit._accelerate.results"] = _accelerate.results
 sys.modules["qiskit._accelerate.sabre"] = _accelerate.sabre
 sys.modules["qiskit._accelerate.sampled_exp_val"] = _accelerate.sampled_exp_val
diff --git a/qiskit/transpiler/passes/optimization/remove_diagonal_gates_before_measure.py b/qiskit/transpiler/passes/optimization/remove_diagonal_gates_before_measure.py
index be4c79aa47e6..3f72cb4a5cc0 100644
--- a/qiskit/transpiler/passes/optimization/remove_diagonal_gates_before_measure.py
+++ b/qiskit/transpiler/passes/optimization/remove_diagonal_gates_before_measure.py
@@ -12,24 +12,13 @@
 
 """Remove diagonal gates (including diagonal 2Q gates) before a measurement."""
 
-from qiskit.circuit import Measure
-from qiskit.circuit.library.standard_gates import (
-    RZGate,
-    ZGate,
-    TGate,
-    SGate,
-    TdgGate,
-    SdgGate,
-    U1Gate,
-    CZGate,
-    CRZGate,
-    CU1Gate,
-    RZZGate,
-)
-from qiskit.dagcircuit import DAGOpNode
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.passes.utils import control_flow
 
+from qiskit._accelerate.remove_diagonal_gates_before_measure import (
+    remove_diagonal_gates_before_measure,
+)
+
 
 class RemoveDiagonalGatesBeforeMeasure(TransformationPass):
     """Remove diagonal gates (including diagonal 2Q gates) before a measurement.
@@ -48,22 +37,5 @@ def run(self, dag):
         Returns:
             DAGCircuit: the optimized DAG.
         """
-        diagonal_1q_gates = (RZGate, ZGate, TGate, SGate, TdgGate, SdgGate, U1Gate)
-        diagonal_2q_gates = (CZGate, CRZGate, CU1Gate, RZZGate)
-
-        nodes_to_remove = set()
-        for measure in dag.op_nodes(Measure):
-            predecessor = next(dag.quantum_predecessors(measure))
-
-            if isinstance(predecessor, DAGOpNode) and isinstance(predecessor.op, diagonal_1q_gates):
-                nodes_to_remove.add(predecessor)
-
-            if isinstance(predecessor, DAGOpNode) and isinstance(predecessor.op, diagonal_2q_gates):
-                successors = dag.quantum_successors(predecessor)
-                if all(isinstance(s, DAGOpNode) and isinstance(s.op, Measure) for s in successors):
-                    nodes_to_remove.add(predecessor)
-
-        for node_to_remove in nodes_to_remove:
-            dag.remove_op_node(node_to_remove)
-
+        remove_diagonal_gates_before_measure(dag)
         return dag
diff --git a/releasenotes/notes/update-remove-diagonal-gates-before-measure-86abe39e46d5dad5.yaml b/releasenotes/notes/update-remove-diagonal-gates-before-measure-86abe39e46d5dad5.yaml
new file mode 100644
index 000000000000..294b4ed5bbae
--- /dev/null
+++ b/releasenotes/notes/update-remove-diagonal-gates-before-measure-86abe39e46d5dad5.yaml
@@ -0,0 +1,8 @@
+---
+features_transpiler:
+  - |
+    The :class:`.RemoveDiagonalGatesBeforeMeasure` transpiler pass has been upgraded to
+    include more diagonal gates: :class:`.PhaseGate`, :class:`.CPhaseGate`,
+    :class:`.CSGate`, :class:`.CSdgGate` and :class:`.CCZGate`.
+    In addition, the code of the :class:`.RemoveDiagonalGatesBeforeMeasure` was ported to Rust,
+    and is now x20 faster for a 20 qubit circuit.
diff --git a/test/python/transpiler/test_remove_diagonal_gates_before_measure.py b/test/python/transpiler/test_remove_diagonal_gates_before_measure.py
index 499bc86d9cf2..474a586448b8 100644
--- a/test/python/transpiler/test_remove_diagonal_gates_before_measure.py
+++ b/test/python/transpiler/test_remove_diagonal_gates_before_measure.py
@@ -50,6 +50,29 @@ def test_optimize_1rz_1measure(self):
 
         self.assertEqual(circuit_to_dag(expected), after)
 
+    def test_optimize_1phase_1measure(self):
+        """Remove a single PhaseGate
+        qr0:--P--m--       qr0:--m-
+                 |               |
+        qr1:-----|--  ==>  qr1:--|-
+                 |               |
+        cr0:-----.--       cr0:--.-
+        """
+        qr = QuantumRegister(2, "qr")
+        cr = ClassicalRegister(1, "cr")
+        circuit = QuantumCircuit(qr, cr)
+        circuit.p(0.1, qr[0])
+        circuit.measure(qr[0], cr[0])
+        dag = circuit_to_dag(circuit)
+
+        expected = QuantumCircuit(qr, cr)
+        expected.measure(qr[0], cr[0])
+
+        pass_ = RemoveDiagonalGatesBeforeMeasure()
+        after = pass_.run(dag)
+
+        self.assertEqual(circuit_to_dag(expected), after)
+
     def test_optimize_1z_1measure(self):
         """Remove a single ZGate
         qr0:--Z--m--       qr0:--m-
@@ -74,7 +97,7 @@ def test_optimize_1z_1measure(self):
         self.assertEqual(circuit_to_dag(expected), after)
 
     def test_optimize_1t_1measure(self):
-        """Remove a single TGate, SGate, TdgGate, SdgGate, U1Gate
+        """Remove a single TGate
         qr0:--T--m--       qr0:--m-
                  |               |
         qr1:-----|--  ==>  qr1:--|-
@@ -298,6 +321,56 @@ def test_optimize_1cz_2measure(self):
 
         self.assertEqual(circuit_to_dag(expected), after)
 
+    def test_optimize_1cs_2measure(self):
+        """Remove a single CSGate
+        qr0:-CS--m---       qr0:--m---
+              |  |                |
+        qr1:--.--|-m-  ==>  qr1:--|-m-
+                 | |              | |
+        cr0:-----.-.-       cr0:--.-.-
+        """
+        qr = QuantumRegister(2, "qr")
+        cr = ClassicalRegister(1, "cr")
+        circuit = QuantumCircuit(qr, cr)
+        circuit.cs(qr[0], qr[1])
+        circuit.measure(qr[0], cr[0])
+        circuit.measure(qr[1], cr[0])
+        dag = circuit_to_dag(circuit)
+
+        expected = QuantumCircuit(qr, cr)
+        expected.measure(qr[0], cr[0])
+        expected.measure(qr[1], cr[0])
+
+        pass_ = RemoveDiagonalGatesBeforeMeasure()
+        after = pass_.run(dag)
+
+        self.assertEqual(circuit_to_dag(expected), after)
+
+    def test_optimize_1csdg_2measure(self):
+        """Remove a single CSdgGate
+        qr0:-CSdg--m---       qr0:--m---
+                |  |                |
+        qr1:----.--|-m-  ==>  qr1:--|-m-
+                   | |              | |
+        cr0:-------.-.-       cr0:--.-.-
+        """
+        qr = QuantumRegister(2, "qr")
+        cr = ClassicalRegister(1, "cr")
+        circuit = QuantumCircuit(qr, cr)
+        circuit.csdg(qr[0], qr[1])
+        circuit.measure(qr[0], cr[0])
+        circuit.measure(qr[1], cr[0])
+        dag = circuit_to_dag(circuit)
+
+        expected = QuantumCircuit(qr, cr)
+        expected.measure(qr[0], cr[0])
+        expected.measure(qr[1], cr[0])
+
+        pass_ = RemoveDiagonalGatesBeforeMeasure()
+        after = pass_.run(dag)
+
+        self.assertEqual(circuit_to_dag(expected), after)
+
     def test_optimize_1crz_2measure(self):
         """Remove a single CRZGate
         qr0:-RZ--m---       qr0:--m---
@@ -323,6 +396,31 @@ def test_optimize_1crz_2measure(self):
 
         self.assertEqual(circuit_to_dag(expected), after)
 
+    def test_optimize_1cp_2measure(self):
+        """Remove a single CPhaseGate
+        qr0:-CP--m---       qr0:--m---
+              |  |                |
+        qr1:--.--|-m-  ==>  qr1:--|-m-
+                 | |              | |
+        cr0:-----.-.-       cr0:--.-.-
+        """
+        qr = QuantumRegister(2, "qr")
+        cr = ClassicalRegister(1, "cr")
+        circuit = QuantumCircuit(qr, cr)
+        circuit.cp(0.1, qr[0], qr[1])
+        circuit.measure(qr[0], cr[0])
+        circuit.measure(qr[1], cr[0])
+        dag = circuit_to_dag(circuit)
+
+        expected = QuantumCircuit(qr, cr)
+        expected.measure(qr[0], cr[0])
+        expected.measure(qr[1], cr[0])
+
+        pass_ = RemoveDiagonalGatesBeforeMeasure()
+        after = pass_.run(dag)
+
+        self.assertEqual(circuit_to_dag(expected), after)
+
     def test_optimize_1cu1_2measure(self):
         """Remove a single CU1Gate
         qr0:-CU1-m---       qr0:--m---
@@ -373,6 +471,27 @@ def test_optimize_1rzz_2measure(self):
 
         self.assertEqual(circuit_to_dag(expected), after)
 
+    def test_optimize_1ccz_3measure(self):
+        """Remove a single CCZGate"""
+        qr = QuantumRegister(3, "qr")
+        cr = ClassicalRegister(1, "cr")
+        circuit = QuantumCircuit(qr, cr)
+        circuit.ccz(qr[0], qr[1], qr[2])
+        circuit.measure(qr[0], cr[0])
+        circuit.measure(qr[1], cr[0])
+        circuit.measure(qr[2], cr[0])
+        dag = circuit_to_dag(circuit)
+
+        expected = QuantumCircuit(qr, cr)
+        expected.measure(qr[0], cr[0])
+        expected.measure(qr[1], cr[0])
+        expected.measure(qr[2], cr[0])
+
+        pass_ = RemoveDiagonalGatesBeforeMeasure()
+        after = pass_.run(dag)
+
+        self.assertEqual(circuit_to_dag(expected), after)
+
 
 class TestRemoveDiagonalGatesBeforeMeasureOveroptimizations(QiskitTestCase):
     """Test situations where remove_diagonal_gates_before_measure should not optimize"""
@@ -401,6 +520,22 @@ def test_optimize_1cz_1measure(self):
 
         self.assertEqual(expected, after)
 
+    def test_optimize_1ccz_1measure(self):
+        """Do not remove a CCZGate because measure happens on only one of the wires"""
+        qr = QuantumRegister(3, "qr")
+        cr = ClassicalRegister(1, "cr")
+        circuit = QuantumCircuit(qr, cr)
+        circuit.ccz(qr[0], qr[1], qr[2])
+        circuit.measure(qr[1], cr[0])
+        dag = circuit_to_dag(circuit)
+
+        expected = deepcopy(dag)
+
+        pass_ = RemoveDiagonalGatesBeforeMeasure()
+        after = pass_.run(dag)
+
+        self.assertEqual(expected, after)
+
     def test_do_not_optimize_with_conditional(self):
         """Diagonal gates with conditionals on a measurement target.
         See https://github.com/Qiskit/qiskit-terra/pull/2208#issuecomment-487238819

From 9898979d2947340514adca7121ed8eaea75df77f Mon Sep 17 00:00:00 2001
From: Julien Gacon <jules.gacon@googlemail.com>
Date: Thu, 5 Sep 2024 18:34:48 +0200
Subject: [PATCH 51/85] Restrict `Split2QUnitaries` to run on `UnitaryGate`
 (#13095)

---
 .../passes/optimization/split_2q_unitaries.py | 34 +++++++-------
 .../restrict-split2q-d51d840cc7a7a482.yaml    |  8 ++++
 .../transpiler/test_split_2q_unitaries.py     | 44 +++++++++++--------
 3 files changed, 48 insertions(+), 38 deletions(-)
 create mode 100644 releasenotes/notes/restrict-split2q-d51d840cc7a7a482.yaml

diff --git a/qiskit/transpiler/passes/optimization/split_2q_unitaries.py b/qiskit/transpiler/passes/optimization/split_2q_unitaries.py
index 0b1788e5bbe6..1ca53c6c31d2 100644
--- a/qiskit/transpiler/passes/optimization/split_2q_unitaries.py
+++ b/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
@@ -21,34 +21,30 @@
 
 
 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.matrix, fidelity=self.requested_fidelity)
diff --git a/releasenotes/notes/restrict-split2q-d51d840cc7a7a482.yaml b/releasenotes/notes/restrict-split2q-d51d840cc7a7a482.yaml
new file mode 100644
index 000000000000..009a97720e30
--- /dev/null
+++ b/releasenotes/notes/restrict-split2q-d51d840cc7a7a482.yaml
@@ -0,0 +1,8 @@
+---
+fixes:
+  - |
+    Fixed an edge case when transpiling a circuit with ``optimization_level`` 2 or 3 with an
+    incomplete 1-qubit basis gate set on a circuit containing 2-qubit gates, that can be
+    implemented as a product of single qubit gates. This bug is resolved by restricting
+    :class:`.Split2QUnitaries` to consider only :class:`.UnitaryGate` objects.
+    Fixed `#12970 <https://github.com/Qiskit/qiskit/issues/12970>`__.
diff --git a/test/python/transpiler/test_split_2q_unitaries.py b/test/python/transpiler/test_split_2q_unitaries.py
index 7fbb93c2419d..f5727bf5313a 100644
--- a/test/python/transpiler/test_split_2q_unitaries.py
+++ b/test/python/transpiler/test_split_2q_unitaries.py
@@ -18,7 +18,7 @@
 import numpy as np
 
 from qiskit import QuantumCircuit, QuantumRegister, transpile
-from qiskit.circuit.library import UnitaryGate, XGate, ZGate, HGate
+from qiskit.circuit.library import UnitaryGate, XGate, ZGate, HGate, CPhaseGate
 from qiskit.circuit import Parameter, CircuitInstruction, Gate
 from qiskit.providers.fake_provider import GenericBackendV2
 from qiskit.quantum_info import Operator
@@ -160,15 +160,11 @@ def test_no_split(self):
     def test_almost_identity(self):
         """Test that the pass handles QFT correctly."""
         qc = QuantumCircuit(2)
-        qc.cp(pi * 2 ** -(26), 0, 1)
+        qc.unitary(CPhaseGate(pi * 2 ** -(26)).to_matrix(), [0, 1])
         pm = PassManager()
-        pm.append(Collect2qBlocks())
-        pm.append(ConsolidateBlocks())
         pm.append(Split2QUnitaries(fidelity=1.0 - 1e-9))
         qc_split = pm.run(qc)
         pm = PassManager()
-        pm.append(Collect2qBlocks())
-        pm.append(ConsolidateBlocks())
         pm.append(Split2QUnitaries())
         qc_split2 = pm.run(qc)
         self.assertEqual(qc_split.num_nonlocal_gates(), 0)
@@ -211,19 +207,6 @@ def test_single_q_gates(self):
         self.assertTrue(CircuitInstruction(ZGate(), qubits=[qr[1]], clbits=[]) in qc.data)
         self.assertTrue(CircuitInstruction(HGate(), qubits=[qr[2]], clbits=[]) in qc.data)
 
-    def test_split_qft(self):
-        """Test that the pass handles QFT correctly."""
-        qc = QuantumCircuit(100)
-        qc.h(0)
-        for i in range(qc.num_qubits - 2, 0, -1):
-            qc.cp(pi * 2 ** -(qc.num_qubits - 1 - i), qc.num_qubits - 1, i)
-        pm = PassManager()
-        pm.append(Collect2qBlocks())
-        pm.append(ConsolidateBlocks())
-        pm.append(Split2QUnitaries())
-        qc_split = pm.run(qc)
-        self.assertEqual(26, qc_split.num_nonlocal_gates())
-
     def test_gate_no_array(self):
         """
         Test that the pass doesn't fail when the circuit contains a custom gate
@@ -260,3 +243,26 @@ def mygate(self, qubit1, qubit2):
         self.assertTrue(
             matrix_equal(Operator(qc).data, Operator(qc_split).data, ignore_phase=False)
         )
+
+    def test_nosplit_custom(self):
+        """Test a single custom gate is not split, even if it is a product.
+
+        That is because we cannot guarantee the split gate is valid in a given basis.
+        Regression test for #12970.
+        """
+
+        class MyGate(Gate):
+            """A custom gate that could be split."""
+
+            def __init__(self):
+                super().__init__("mygate", 2, [])
+
+            def to_matrix(self):
+                return np.eye(4, dtype=complex)
+
+        qc = QuantumCircuit(2)
+        qc.append(MyGate(), [0, 1])
+
+        no_split = Split2QUnitaries()(qc)
+
+        self.assertDictEqual({"mygate": 1}, no_split.count_ops())

From 254ba83dc637a22a91cee0a0cd1c453f89ca55da Mon Sep 17 00:00:00 2001
From: Eric Arellano <14852634+Eric-Arellano@users.noreply.github.com>
Date: Thu, 5 Sep 2024 18:36:03 -0400
Subject: [PATCH 52/85] Fix documentation for utils.optionals data values
 (#13098)

---
 qiskit/utils/optionals.py | 323 ++++++++++++++++++++------------------
 1 file changed, 173 insertions(+), 150 deletions(-)

diff --git a/qiskit/utils/optionals.py b/qiskit/utils/optionals.py
index f2e6c860faaa..c5d0d69d11a1 100644
--- a/qiskit/utils/optionals.py
+++ b/qiskit/utils/optionals.py
@@ -25,172 +25,195 @@
 Qiskit Components
 -----------------
 
-.. list-table::
-    :widths: 25 75
+.. py:data:: HAS_AER
 
-    * - .. py:data:: HAS_AER
-      - `Qiskit Aer <https://qiskit.github.io/qiskit-aer/>` provides high-performance simulators for
-        the quantum circuits constructed within Qiskit.
+    `Qiskit Aer <https://qiskit.github.io/qiskit-aer/>` provides high-performance simulators for
+    the quantum circuits constructed within Qiskit.
 
-    * - .. py:data:: HAS_IBMQ
-      - The :mod:`Qiskit IBMQ Provider <qiskit.providers.ibmq>` is used for accessing IBM Quantum
-        hardware in the IBM cloud.
+.. py:data:: HAS_IBMQ
 
-    * - .. py:data:: HAS_IGNIS
-      - :mod:`Qiskit Ignis <qiskit.ignis>` provides tools for quantum hardware verification, noise
-        characterization, and error correction.
+    The :mod:`Qiskit IBMQ Provider <qiskit.providers.ibmq>` is used for accessing IBM Quantum
+    hardware in the IBM cloud.
 
-    * - .. py:data:: HAS_TOQM
-      - `Qiskit TOQM <https://github.com/qiskit-toqm/qiskit-toqm>`__ provides transpiler passes
-        for the `Time-optimal Qubit mapping algorithm <https://doi.org/10.1145/3445814.3446706>`__.
+.. py:data:: HAS_IGNIS
+
+    :mod:`Qiskit Ignis <qiskit.ignis>` provides tools for quantum hardware verification, noise
+    characterization, and error correction.
+
+.. py:data:: HAS_TOQM
+
+    `Qiskit TOQM <https://github.com/qiskit-toqm/qiskit-toqm>`__ provides transpiler passes
+    for the `Time-optimal Qubit mapping algorithm <https://doi.org/10.1145/3445814.3446706>`__.
 
 
 External Python Libraries
 -------------------------
 
-.. list-table::
-    :widths: 25 75
-
-    * - .. py:data:: HAS_CONSTRAINT
-      - `python-constraint <https://github.com/python-constraint/python-constraint>`__ is a
-        constraint satisfaction problem solver, used in the :class:`~.CSPLayout` transpiler pass.
-
-    * - .. py:data:: HAS_CPLEX
-      - The `IBM CPLEX Optimizer <https://www.ibm.com/analytics/cplex-optimizer>`__ is a
-        high-performance mathematical programming solver for linear, mixed-integer and quadratic
-        programming. This is no longer by Qiskit, but it weas historically and the optional
-        remains for backwards compatibility.
-
-    * - .. py:data:: HAS_CVXPY
-      - `CVXPY <https://www.cvxpy.org/>`__ is a Python package for solving convex optimization
-        problems.  It is required for calculating diamond norms with
-        :func:`.quantum_info.diamond_norm`.
-
-    * - .. py:data:: HAS_DOCPLEX
-      - `IBM Decision Optimization CPLEX Modelling
-        <http://ibmdecisionoptimization.github.io/docplex-doc/>`__ is a library for prescriptive
-        analysis.  Like CPLEX, this is no longer by Qiskit, but it weas historically and the
-        optional remains for backwards compatibility.
-
-    * - .. py:data:: HAS_FIXTURES
-      - The test suite has additional features that are available if the optional `fixtures
-        <https://launchpad.net/python-fixtures>`__ module is installed.  This generally also needs
-        :data:`HAS_TESTTOOLS` as well.  This is generally only needed for Qiskit developers.
-
-    * - .. py:data:: HAS_IPYTHON
-      - If `the IPython kernel <https://ipython.org/>`__ is available, certain additional
-        visualizations and line magics are made available.
-
-    * - .. py:data:: HAS_IPYWIDGETS
-      - Monitoring widgets for jobs running on external backends can be provided if `ipywidgets
-        <https://ipywidgets.readthedocs.io/en/latest/>`__ is available.
-
-    * - .. py:data:: HAS_JAX
-      - Some methods of gradient calculation within :mod:`.opflow.gradients` require `JAX
-        <https://github.com/google/jax>`__ for autodifferentiation.
-
-    * - .. py:data:: HAS_JUPYTER
-      - Some of the tests require a complete `Jupyter <https://jupyter.org/>`__ installation to test
-        interactivity features.
-
-    * - .. py:data:: HAS_MATPLOTLIB
-      - Qiskit provides several visualization tools in the :mod:`.visualization` module.
-        Almost all of these are built using `Matplotlib <https://matplotlib.org/>`__, which must
-        be installed in order to use them.
-
-    * - .. py:data:: HAS_NETWORKX
-      - No longer used by Qiskit.  Internally, Qiskit now uses the high-performance `rustworkx
-        <https://github.com/Qiskit/rustworkx>`__ library as a core dependency, and during the
-        change-over period, it was sometimes convenient to convert things into the Python-only
-        `NetworkX <https://networkx.org/>`__ format.  Some tests of application modules, such as
-        `Qiskit Nature <https://qiskit-community.github.io/qiskit-nature/>`__ still use NetworkX.
-
-    * - .. py:data:: HAS_NLOPT
-      - `NLopt <https://nlopt.readthedocs.io/en/latest/>`__ is a nonlinear optimization library,
-        used by the global optimizers in the :mod:`.algorithms.optimizers` module.
-
-    * - .. py:data:: HAS_PIL
-      - PIL is a Python image-manipulation library.  Qiskit actually uses the `pillow
-        <https://pillow.readthedocs.io/en/stable/>`__ fork of PIL if it is available when generating
-        certain visualizations, for example of both :class:`.QuantumCircuit` and
-        :class:`.DAGCircuit` in certain modes.
-
-    * - .. py:data:: HAS_PYDOT
-      - For some graph visualizations, Qiskit uses `pydot <https://github.com/pydot/pydot>`__ as an
-        interface to GraphViz (see :data:`HAS_GRAPHVIZ`).
-
-    * - .. py:data:: HAS_PYGMENTS
-      - Pygments is a code highlighter and formatter used by many environments that involve rich
-        display of code blocks, including Sphinx and Jupyter.  Qiskit uses this when producing rich
-        output for these environments.
-
-    * - .. py:data:: HAS_PYLATEX
-      - Various LaTeX-based visualizations, especially the circuit drawers, need access to the
-        `pylatexenc <https://github.com/phfaist/pylatexenc>`__ project to work correctly.
-
-    * - .. py:data:: HAS_QASM3_IMPORT
-      - The functions :func:`.qasm3.load` and :func:`.qasm3.loads` for importing OpenQASM 3 programs
-        into :class:`.QuantumCircuit` instances use `an external importer package
-        <https://qiskit.github.io/qiskit-qasm3-import>`__.
-
-    * - .. py:data:: HAS_SEABORN
-      - Qiskit provides several visualization tools in the :mod:`.visualization` module.  Some
-        of these are built using `Seaborn <https://seaborn.pydata.org/>`__, which must be installed
-        in order to use them.
-
-    * - .. py:data:: HAS_SKLEARN
-      - Some of the gradient functions in :mod:`.opflow.gradients` use regularisation methods from
-        `Scikit Learn <https://scikit-learn.org/stable/>`__.
-
-    * - .. py:data:: HAS_SKQUANT
-      - Some of the optimisers in :mod:`.algorithms.optimizers` are based on those found in `Scikit
-        Quant <https://github.com/scikit-quant/scikit-quant>`__, which must be installed to use
-        them.
-
-    * - .. py:data:: HAS_SQSNOBFIT
-      - `SQSnobFit <https://pypi.org/project/SQSnobFit/>`__ is a library for the "stable noisy
-        optimization by branch and fit" algorithm.  It is used by the :class:`.SNOBFIT` optimizer.
-
-    * - .. py:data:: HAS_SYMENGINE
-      - `Symengine <https://github.com/symengine/symengine>`__ is a fast C++ backend for the
-        symbolic-manipulation library `Sympy <https://www.sympy.org/en/index.html>`__.  Qiskit uses
-        special methods from Symengine to accelerate its handling of
-        :class:`~.circuit.Parameter`\\ s if available.
-
-    * - .. py:data:: HAS_TESTTOOLS
-      - Qiskit's test suite has more advanced functionality available if the optional
-        `testtools <https://pypi.org/project/testtools/>`__ library is installed.  This is generally
-        only needed for Qiskit developers.
-
-    * - .. py:data:: HAS_TWEEDLEDUM
-      - `Tweedledum <https://github.com/boschmitt/tweedledum>`__ is an extension library for
-        synthesis and optimization of circuits that may involve classical oracles.  Qiskit's
-        :class:`.PhaseOracle` uses this, which is used in turn by amplification algorithms via
-        the :class:`.AmplificationProblem`.
-
-    * - .. py:data:: HAS_Z3
-      - `Z3 <https://github.com/Z3Prover/z3>`__ is a theorem prover, used in the
-        :class:`.CrosstalkAdaptiveSchedule` and :class:`.HoareOptimizer` transpiler passes.
+.. py:data:: HAS_CONSTRAINT
+
+    `python-constraint <https://github.com/python-constraint/python-constraint>`__ is a
+    constraint satisfaction problem solver, used in the :class:`~.CSPLayout` transpiler pass.
+
+.. py:data:: HAS_CPLEX
+
+    The `IBM CPLEX Optimizer <https://www.ibm.com/analytics/cplex-optimizer>`__ is a
+    high-performance mathematical programming solver for linear, mixed-integer and quadratic
+    programming. This is no longer by Qiskit, but it weas historically and the optional
+    remains for backwards compatibility.
+
+.. py:data:: HAS_CVXPY
+
+    `CVXPY <https://www.cvxpy.org/>`__ is a Python package for solving convex optimization
+    problems.  It is required for calculating diamond norms with
+    :func:`.quantum_info.diamond_norm`.
+
+.. py:data:: HAS_DOCPLEX
+
+    `IBM Decision Optimization CPLEX Modelling
+    <http://ibmdecisionoptimization.github.io/docplex-doc/>`__ is a library for prescriptive
+    analysis.  Like CPLEX, this is no longer by Qiskit, but it weas historically and the
+    optional remains for backwards compatibility.
+
+.. py:data:: HAS_FIXTURES
+
+    The test suite has additional features that are available if the optional `fixtures
+    <https://launchpad.net/python-fixtures>`__ module is installed.  This generally also needs
+    :data:`HAS_TESTTOOLS` as well.  This is generally only needed for Qiskit developers.
+
+.. py:data:: HAS_IPYTHON
+
+    If `the IPython kernel <https://ipython.org/>`__ is available, certain additional
+    visualizations and line magics are made available.
+
+.. py:data:: HAS_IPYWIDGETS
+
+    Monitoring widgets for jobs running on external backends can be provided if `ipywidgets
+    <https://ipywidgets.readthedocs.io/en/latest/>`__ is available.
+
+.. py:data:: HAS_JAX
+
+    Some methods of gradient calculation within :mod:`.opflow.gradients` require `JAX
+    <https://github.com/google/jax>`__ for autodifferentiation.
+
+.. py:data:: HAS_JUPYTER
+
+    Some of the tests require a complete `Jupyter <https://jupyter.org/>`__ installation to test
+    interactivity features.
+
+.. py:data:: HAS_MATPLOTLIB
+
+    Qiskit provides several visualization tools in the :mod:`.visualization` module.
+    Almost all of these are built using `Matplotlib <https://matplotlib.org/>`__, which must
+    be installed in order to use them.
+
+.. py:data:: HAS_NETWORKX
+
+    No longer used by Qiskit.  Internally, Qiskit now uses the high-performance `rustworkx
+    <https://github.com/Qiskit/rustworkx>`__ library as a core dependency, and during the
+    change-over period, it was sometimes convenient to convert things into the Python-only
+    `NetworkX <https://networkx.org/>`__ format.  Some tests of application modules, such as
+    `Qiskit Nature <https://qiskit-community.github.io/qiskit-nature/>`__ still use NetworkX.
+
+.. py:data:: HAS_NLOPT
+
+    `NLopt <https://nlopt.readthedocs.io/en/latest/>`__ is a nonlinear optimization library,
+    used by the global optimizers in the :mod:`.algorithms.optimizers` module.
+
+.. py:data:: HAS_PIL
+
+    PIL is a Python image-manipulation library.  Qiskit actually uses the `pillow
+    <https://pillow.readthedocs.io/en/stable/>`__ fork of PIL if it is available when generating
+    certain visualizations, for example of both :class:`.QuantumCircuit` and
+    :class:`.DAGCircuit` in certain modes.
+
+.. py:data:: HAS_PYDOT
+
+    For some graph visualizations, Qiskit uses `pydot <https://github.com/pydot/pydot>`__ as an
+    interface to GraphViz (see :data:`HAS_GRAPHVIZ`).
+
+.. py:data:: HAS_PYGMENTS
+
+    Pygments is a code highlighter and formatter used by many environments that involve rich
+    display of code blocks, including Sphinx and Jupyter.  Qiskit uses this when producing rich
+    output for these environments.
+
+.. py:data:: HAS_PYLATEX
+
+    Various LaTeX-based visualizations, especially the circuit drawers, need access to the
+    `pylatexenc <https://github.com/phfaist/pylatexenc>`__ project to work correctly.
+
+.. py:data:: HAS_QASM3_IMPORT
+
+    The functions :func:`.qasm3.load` and :func:`.qasm3.loads` for importing OpenQASM 3 programs
+    into :class:`.QuantumCircuit` instances use `an external importer package
+    <https://qiskit.github.io/qiskit-qasm3-import>`__.
+
+.. py:data:: HAS_SEABORN
+
+    Qiskit provides several visualization tools in the :mod:`.visualization` module.  Some
+    of these are built using `Seaborn <https://seaborn.pydata.org/>`__, which must be installed
+    in order to use them.
+
+.. py:data:: HAS_SKLEARN
+
+    Some of the gradient functions in :mod:`.opflow.gradients` use regularisation methods from
+    `Scikit Learn <https://scikit-learn.org/stable/>`__.
+
+.. py:data:: HAS_SKQUANT
+
+    Some of the optimisers in :mod:`.algorithms.optimizers` are based on those found in `Scikit
+    Quant <https://github.com/scikit-quant/scikit-quant>`__, which must be installed to use
+    them.
+
+.. py:data:: HAS_SQSNOBFIT
+
+    `SQSnobFit <https://pypi.org/project/SQSnobFit/>`__ is a library for the "stable noisy
+    optimization by branch and fit" algorithm.  It is used by the :class:`.SNOBFIT` optimizer.
+
+.. py:data:: HAS_SYMENGINE
+
+    `Symengine <https://github.com/symengine/symengine>`__ is a fast C++ backend for the
+    symbolic-manipulation library `Sympy <https://www.sympy.org/en/index.html>`__.  Qiskit uses
+    special methods from Symengine to accelerate its handling of
+    :class:`~.circuit.Parameter`\\ s if available.
+
+.. py:data:: HAS_TESTTOOLS
+
+    Qiskit's test suite has more advanced functionality available if the optional
+    `testtools <https://pypi.org/project/testtools/>`__ library is installed.  This is generally
+    only needed for Qiskit developers.
+
+.. py:data:: HAS_TWEEDLEDUM
+
+    `Tweedledum <https://github.com/boschmitt/tweedledum>`__ is an extension library for
+    synthesis and optimization of circuits that may involve classical oracles.  Qiskit's
+    :class:`.PhaseOracle` uses this, which is used in turn by amplification algorithms via
+    the :class:`.AmplificationProblem`.
+
+.. py:data:: HAS_Z3
+
+    `Z3 <https://github.com/Z3Prover/z3>`__ is a theorem prover, used in the
+    :class:`.CrosstalkAdaptiveSchedule` and :class:`.HoareOptimizer` transpiler passes.
 
 External Command-Line Tools
 ---------------------------
 
-.. list-table::
-    :widths: 25 75
+.. py:data:: HAS_GRAPHVIZ
+
+    For some graph visualizations, Qiskit uses the `GraphViz <https://graphviz.org/>`__
+    visualization tool via its ``pydot`` interface (see :data:`HAS_PYDOT`).
+
+.. py:data:: HAS_PDFLATEX
 
-    * - .. py:data:: HAS_GRAPHVIZ
-      - For some graph visualizations, Qiskit uses the `GraphViz <https://graphviz.org/>`__
-        visualization tool via its ``pydot`` interface (see :data:`HAS_PYDOT`).
+    Visualization tools that use LaTeX in their output, such as the circuit drawers, require
+    ``pdflatex`` to be available.  You will generally need to ensure that you have a working
+    LaTeX installation available, and the ``qcircuit.tex`` package.
 
-    * - .. py:data:: HAS_PDFLATEX
-      - Visualization tools that use LaTeX in their output, such as the circuit drawers, require
-        ``pdflatex`` to be available.  You will generally need to ensure that you have a working
-        LaTeX installation available, and the ``qcircuit.tex`` package.
+.. py:data:: HAS_PDFTOCAIRO
 
-    * - .. py:data:: HAS_PDFTOCAIRO
-      - Visualization tools that convert LaTeX-generated files into rasterized images use the
-        ``pdftocairo`` tool.  This is part of the `Poppler suite of PDF tools
-        <https://poppler.freedesktop.org/>`__.
+    Visualization tools that convert LaTeX-generated files into rasterized images use the
+    ``pdftocairo`` tool.  This is part of the `Poppler suite of PDF tools
+    <https://poppler.freedesktop.org/>`__.
 
 
 Lazy Checker Classes

From 8982dbde157eafa8e104495472115f4257a502fa Mon Sep 17 00:00:00 2001
From: Matthew Treinish <mtreinish@kortar.org>
Date: Thu, 5 Sep 2024 19:00:08 -0400
Subject: [PATCH 53/85] Fully port FilterOpNodes to Rust (#13052)

* Fully port FilterOpNodes to Rust

This commit ports the FilterOpNodes pass to rust. This pass is
exceedingly simple and just runs a filter function over all the op
nodes and removes nodes that match the filter. However, the API for
the class exposes that filter function interface as a user provided
Python callable. So for the current pass we need to retain that python
callback. This limits the absolute performance of this pass because
we're bottlenecked by calling python.

Looking to the future, this commit adds a rust native method to
DAGCircuit to perform this filtering with a rust predicate FnMut. It
isn't leveraged by the python implementation because of layer mismatch
for the efficient rust interface and Python working with `DAGOpNode`
objects. A function using that interface is added to filter labeled
nodes. In the preset pass manager we only use FilterOpNodes to remove
nodes with a specific label (which is used to identify temporary
barriers created by qiskit). In a follow up we should consider
leveraging this new function to build a new pass specifically for
this use case.

Fixes #12263
Part of #12208

* Make filter_op_nodes() infallible

The filter_op_nodes() method originally returned a Result<()> to handle
a predicate that was fallible. This was because the original intent for
the method was to use it with Python callbacks in the predicate. But
because of differences between the rust API and the Python API this
wasn't feasible as was originally planned. So this Result<()> return
wasn't used anymore. This commit reworks it to make the
filter_op_nodes() infallible and the predicate a user provides also only
returns `bool` and not `Result<bool>`.

* Rename filter_labelled_op to filter_labeled_op
---
 crates/accelerate/src/filter_op_nodes.rs      | 63 +++++++++++++++++++
 crates/accelerate/src/lib.rs                  |  1 +
 .../remove_diagonal_gates_before_measure.rs   |  4 +-
 crates/circuit/src/dag_circuit.rs             | 19 ++++++
 crates/circuit/src/packed_instruction.rs      |  7 +++
 crates/pyext/src/lib.rs                       |  6 +-
 qiskit/__init__.py                            |  1 +
 .../passes/utils/filter_op_nodes.py           |  6 +-
 8 files changed, 101 insertions(+), 6 deletions(-)
 create mode 100644 crates/accelerate/src/filter_op_nodes.rs

diff --git a/crates/accelerate/src/filter_op_nodes.rs b/crates/accelerate/src/filter_op_nodes.rs
new file mode 100644
index 000000000000..7c41391f3788
--- /dev/null
+++ b/crates/accelerate/src/filter_op_nodes.rs
@@ -0,0 +1,63 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// 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.
+
+use pyo3::prelude::*;
+use pyo3::wrap_pyfunction;
+
+use qiskit_circuit::dag_circuit::DAGCircuit;
+use qiskit_circuit::packed_instruction::PackedInstruction;
+use rustworkx_core::petgraph::stable_graph::NodeIndex;
+
+#[pyfunction]
+#[pyo3(name = "filter_op_nodes")]
+pub fn py_filter_op_nodes(
+    py: Python,
+    dag: &mut DAGCircuit,
+    predicate: &Bound<PyAny>,
+) -> PyResult<()> {
+    let callable = |node: NodeIndex| -> PyResult<bool> {
+        let dag_op_node = dag.get_node(py, node)?;
+        predicate.call1((dag_op_node,))?.extract()
+    };
+    let mut remove_nodes: Vec<NodeIndex> = Vec::new();
+    for node in dag.op_nodes(true) {
+        if !callable(node)? {
+            remove_nodes.push(node);
+        }
+    }
+    for node in remove_nodes {
+        dag.remove_op_node(node);
+    }
+    Ok(())
+}
+
+/// Remove any nodes that have the provided label set
+///
+/// Args:
+///     dag (DAGCircuit): The dag circuit to filter the ops from
+///     label (str): The label to filter nodes on
+#[pyfunction]
+pub fn filter_labeled_op(dag: &mut DAGCircuit, label: String) {
+    let predicate = |node: &PackedInstruction| -> bool {
+        match node.label() {
+            Some(inst_label) => inst_label != label,
+            None => false,
+        }
+    };
+    dag.filter_op_nodes(predicate);
+}
+
+pub fn filter_op_nodes_mod(m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_wrapped(wrap_pyfunction!(py_filter_op_nodes))?;
+    m.add_wrapped(wrap_pyfunction!(filter_labeled_op))?;
+    Ok(())
+}
diff --git a/crates/accelerate/src/lib.rs b/crates/accelerate/src/lib.rs
index e8760ee2c616..78eea97faad0 100644
--- a/crates/accelerate/src/lib.rs
+++ b/crates/accelerate/src/lib.rs
@@ -22,6 +22,7 @@ pub mod dense_layout;
 pub mod edge_collections;
 pub mod error_map;
 pub mod euler_one_qubit_decomposer;
+pub mod filter_op_nodes;
 pub mod isometry;
 pub mod nlayout;
 pub mod optimize_1q_gates;
diff --git a/crates/accelerate/src/remove_diagonal_gates_before_measure.rs b/crates/accelerate/src/remove_diagonal_gates_before_measure.rs
index 10916a77fca8..cf2c738f131a 100644
--- a/crates/accelerate/src/remove_diagonal_gates_before_measure.rs
+++ b/crates/accelerate/src/remove_diagonal_gates_before_measure.rs
@@ -49,7 +49,9 @@ fn run_remove_diagonal_before_measure(dag: &mut DAGCircuit) -> PyResult<()> {
     let mut nodes_to_remove = Vec::new();
     for index in dag.op_nodes(true) {
         let node = &dag.dag[index];
-        let NodeType::Operation(inst) = node else {panic!()};
+        let NodeType::Operation(inst) = node else {
+            panic!()
+        };
 
         if inst.op.name() == "measure" {
             let predecessor = (dag.quantum_predecessors(index))
diff --git a/crates/circuit/src/dag_circuit.rs b/crates/circuit/src/dag_circuit.rs
index 381ef25b7a7e..32b3a77ed24c 100644
--- a/crates/circuit/src/dag_circuit.rs
+++ b/crates/circuit/src/dag_circuit.rs
@@ -5794,6 +5794,25 @@ impl DAGCircuit {
         }
     }
 
+    // Filter any nodes that don't match a given predicate function
+    pub fn filter_op_nodes<F>(&mut self, mut predicate: F)
+    where
+        F: FnMut(&PackedInstruction) -> bool,
+    {
+        let mut remove_nodes: Vec<NodeIndex> = Vec::new();
+        for node in self.op_nodes(true) {
+            let NodeType::Operation(op) = &self.dag[node] else {
+                unreachable!()
+            };
+            if !predicate(op) {
+                remove_nodes.push(node);
+            }
+        }
+        for node in remove_nodes {
+            self.remove_op_node(node);
+        }
+    }
+
     pub fn op_nodes_by_py_type<'a>(
         &'a self,
         op: &'a Bound<PyType>,
diff --git a/crates/circuit/src/packed_instruction.rs b/crates/circuit/src/packed_instruction.rs
index 77ca0c6c02dd..df8f9801314a 100644
--- a/crates/circuit/src/packed_instruction.rs
+++ b/crates/circuit/src/packed_instruction.rs
@@ -553,6 +553,13 @@ impl PackedInstruction {
             .and_then(|extra| extra.condition.as_ref())
     }
 
+    #[inline]
+    pub fn label(&self) -> Option<&str> {
+        self.extra_attrs
+            .as_ref()
+            .and_then(|extra| extra.label.as_deref())
+    }
+
     /// Build a reference to the Python-space operation object (the `Gate`, etc) packed into this
     /// instruction.  This may construct the reference if the `PackedInstruction` is a standard
     /// gate with no already stored operation.
diff --git a/crates/pyext/src/lib.rs b/crates/pyext/src/lib.rs
index 1478fb367a13..49e44bffa2ec 100644
--- a/crates/pyext/src/lib.rs
+++ b/crates/pyext/src/lib.rs
@@ -16,8 +16,9 @@ use qiskit_accelerate::{
     circuit_library::circuit_library, commutation_analysis::commutation_analysis,
     commutation_checker::commutation_checker, convert_2q_block_matrix::convert_2q_block_matrix,
     dense_layout::dense_layout, error_map::error_map,
-    euler_one_qubit_decomposer::euler_one_qubit_decomposer, isometry::isometry, nlayout::nlayout,
-    optimize_1q_gates::optimize_1q_gates, pauli_exp_val::pauli_expval,
+    euler_one_qubit_decomposer::euler_one_qubit_decomposer, filter_op_nodes::filter_op_nodes_mod,
+    isometry::isometry, nlayout::nlayout, optimize_1q_gates::optimize_1q_gates,
+    pauli_exp_val::pauli_expval,
     remove_diagonal_gates_before_measure::remove_diagonal_gates_before_measure, results::results,
     sabre::sabre, sampled_exp_val::sampled_exp_val, sparse_pauli_op::sparse_pauli_op,
     star_prerouting::star_prerouting, stochastic_swap::stochastic_swap, synthesis::synthesis,
@@ -46,6 +47,7 @@ fn _accelerate(m: &Bound<PyModule>) -> PyResult<()> {
     add_submodule(m, dense_layout, "dense_layout")?;
     add_submodule(m, error_map, "error_map")?;
     add_submodule(m, euler_one_qubit_decomposer, "euler_one_qubit_decomposer")?;
+    add_submodule(m, filter_op_nodes_mod, "filter_op_nodes")?;
     add_submodule(m, isometry, "isometry")?;
     add_submodule(m, nlayout, "nlayout")?;
     add_submodule(m, optimize_1q_gates, "optimize_1q_gates")?;
diff --git a/qiskit/__init__.py b/qiskit/__init__.py
index d9979c9d4d92..3cc10bf96a31 100644
--- a/qiskit/__init__.py
+++ b/qiskit/__init__.py
@@ -92,6 +92,7 @@
 sys.modules["qiskit._accelerate.commutation_checker"] = _accelerate.commutation_checker
 sys.modules["qiskit._accelerate.commutation_analysis"] = _accelerate.commutation_analysis
 sys.modules["qiskit._accelerate.synthesis.linear_phase"] = _accelerate.synthesis.linear_phase
+sys.modules["qiskit._accelerate.filter_op_nodes"] = _accelerate.filter_op_nodes
 
 from qiskit.exceptions import QiskitError, MissingOptionalLibraryError
 
diff --git a/qiskit/transpiler/passes/utils/filter_op_nodes.py b/qiskit/transpiler/passes/utils/filter_op_nodes.py
index 344d2280e3f4..75b824332aee 100644
--- a/qiskit/transpiler/passes/utils/filter_op_nodes.py
+++ b/qiskit/transpiler/passes/utils/filter_op_nodes.py
@@ -18,6 +18,8 @@
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.passes.utils import control_flow
 
+from qiskit._accelerate.filter_op_nodes import filter_op_nodes
+
 
 class FilterOpNodes(TransformationPass):
     """Remove all operations that match a filter function
@@ -59,7 +61,5 @@ def __init__(self, predicate: Callable[[DAGOpNode], bool]):
     @control_flow.trivial_recurse
     def run(self, dag: DAGCircuit) -> DAGCircuit:
         """Run the RemoveBarriers pass on `dag`."""
-        for node in dag.op_nodes():
-            if not self.predicate(node):
-                dag.remove_op_node(node)
+        filter_op_nodes(dag, self.predicate)
         return dag

From b80b454c8763f650b134a514faf959aee51d9dd3 Mon Sep 17 00:00:00 2001
From: Matthew Treinish <mtreinish@kortar.org>
Date: Thu, 5 Sep 2024 19:29:26 -0400
Subject: [PATCH 54/85] Fix clippy failures with Rust 1.81.0 (#13100)

The recently released Rust 1.81.0 introduced some new on by default
clippy rules and these rules are flagging issues in the rust code in the
library. While we use Rust 1.70 for clippy in CI and these won't cause
failures until we raise our MSRV to >= 1.81.0 these clippy
warnings/failures are still good to fix as the either make the code more
consise and/or efficient. This commit fixes these issues identified by
clippy.
---
 crates/accelerate/src/results/marginalization.rs | 9 ++-------
 crates/circuit/src/operations.rs                 | 5 +----
 2 files changed, 3 insertions(+), 11 deletions(-)

diff --git a/crates/accelerate/src/results/marginalization.rs b/crates/accelerate/src/results/marginalization.rs
index 5260287e771d..b9e7ec4ba65c 100644
--- a/crates/accelerate/src/results/marginalization.rs
+++ b/crates/accelerate/src/results/marginalization.rs
@@ -26,16 +26,11 @@ fn marginalize<T: std::ops::AddAssign + Copy>(
     indices: Option<Vec<usize>>,
 ) -> HashMap<String, T> {
     let mut out_counts: HashMap<String, T> = HashMap::with_capacity(counts.len());
-    let clbit_size = counts
-        .keys()
-        .next()
-        .unwrap()
-        .replace(|c| c == '_' || c == ' ', "")
-        .len();
+    let clbit_size = counts.keys().next().unwrap().replace(['_', ' '], "").len();
     let all_indices: Vec<usize> = (0..clbit_size).collect();
     counts
         .iter()
-        .map(|(k, v)| (k.replace(|c| c == '_' || c == ' ', ""), *v))
+        .map(|(k, v)| (k.replace(['_', ' '], ""), *v))
         .for_each(|(k, v)| match &indices {
             Some(indices) => {
                 if all_indices == *indices {
diff --git a/crates/circuit/src/operations.rs b/crates/circuit/src/operations.rs
index 8cc2256af518..a3fd2fc83c3d 100644
--- a/crates/circuit/src/operations.rs
+++ b/crates/circuit/src/operations.rs
@@ -2225,10 +2225,7 @@ impl Operation for PyGate {
     fn standard_gate(&self) -> Option<StandardGate> {
         Python::with_gil(|py| -> Option<StandardGate> {
             match self.gate.getattr(py, intern!(py, "_standard_gate")) {
-                Ok(stdgate) => match stdgate.extract(py) {
-                    Ok(out_gate) => out_gate,
-                    Err(_) => None,
-                },
+                Ok(stdgate) => stdgate.extract(py).unwrap_or_default(),
                 Err(_) => None,
             }
         })

From 1a4193a1c52f73f081407b8f234da1b154198da6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 6 Sep 2024 13:08:35 +0000
Subject: [PATCH 55/85] Bump bytemuck from 1.17.1 to 1.18.0 (#13105)

Bumps [bytemuck](https://github.com/Lokathor/bytemuck) from 1.17.1 to 1.18.0.
- [Changelog](https://github.com/Lokathor/bytemuck/blob/main/changelog.md)
- [Commits](https://github.com/Lokathor/bytemuck/compare/v1.17.1...v1.18.0)

---
updated-dependencies:
- dependency-name: bytemuck
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 7921b7aeba83..9745b67b7405 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -120,9 +120,9 @@ dependencies = [
 
 [[package]]
 name = "bytemuck"
-version = "1.17.1"
+version = "1.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "773d90827bc3feecfb67fab12e24de0749aad83c74b9504ecde46237b5cd24e2"
+checksum = "94bbb0ad554ad961ddc5da507a12a29b14e4ae5bda06b19f575a3e6079d2e2ae"
 dependencies = [
  "bytemuck_derive",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 4f7f8ad86b96..2f5fd8ce077b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,7 +14,7 @@ license = "Apache-2.0"
 #
 # Each crate can add on specific features freely as it inherits.
 [workspace.dependencies]
-bytemuck = "1.17"
+bytemuck = "1.18"
 indexmap.version = "2.5.0"
 hashbrown.version = "0.14.5"
 num-bigint = "0.4"

From 7c409123a369c7df0b86f99ae00fefd41bc142fd Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 6 Sep 2024 13:34:52 +0000
Subject: [PATCH 56/85] Bump faer from 0.19.2 to 0.19.3 (#13104)

Bumps [faer](https://github.com/sarah-ek/faer-rs) from 0.19.2 to 0.19.3.
- [Changelog](https://github.com/sarah-ek/faer-rs/blob/main/CHANGELOG.md)
- [Commits](https://github.com/sarah-ek/faer-rs/commits)

---
updated-dependencies:
- dependency-name: faer
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock                   | 4 ++--
 crates/accelerate/Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 9745b67b7405..d00620630e79 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -345,9 +345,9 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
 
 [[package]]
 name = "faer"
-version = "0.19.2"
+version = "0.19.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe8894ad9275f1fd708e2f114f4059e80057ad3cc150b77a3f8a7991dd47ab37"
+checksum = "0821d176d7fd17ea91d8a5ce84c56413e11410f404e418bfd205acf40184d819"
 dependencies = [
  "bytemuck",
  "coe-rs",
diff --git a/crates/accelerate/Cargo.toml b/crates/accelerate/Cargo.toml
index f444a5c8ed66..4b5c18e5eb93 100644
--- a/crates/accelerate/Cargo.toml
+++ b/crates/accelerate/Cargo.toml
@@ -20,7 +20,7 @@ num-traits = "0.2"
 num-complex.workspace = true
 rustworkx-core.workspace = true
 num-bigint.workspace = true
-faer = "0.19.2"
+faer = "0.19.3"
 itertools.workspace = true
 qiskit-circuit.workspace = true
 thiserror.workspace = true

From 3d4bab2be7fd09f6dcf734a3386355cae6cded39 Mon Sep 17 00:00:00 2001
From: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>
Date: Fri, 6 Sep 2024 12:26:48 -0400
Subject: [PATCH 57/85] Add method to add instructions to a DAGCircuit from an
 iterator of PackedInstruction (#13032)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Initial: Add add_from_iter method to DAGCircuit
- Introduce a method that adds a chain of `PackedInstruction` continuously avoiding the re-linking of each bit's output-node until the very end of the iterator.
   - TODO: Add handling of vars
- Add header for a `from_iter` function that will create a `DAGCircuit` based on a chain of `PackedInstruction`.

* Fix: leverage new methods in layers
- Fix incorrect re-insertion of last_node.

* Fix: Keep track of Vars for add_from_iter
- Remove `from_iter`

* Fix: Incorrect modification of last nodes in `add_from_iter`.
- Use `entry` api to either modify or insert a value if missing.

* Fix: Cycling edges in when adding vars.
- A bug that adds duplicate edges to vars has been temporarily fixed. However, the root of this problem hasn't been found yet. A proper fix is pending. For now skip those instances.

* Fix: Remove set collecting all nodes to be connected.
- A set collecting all the new nodes to connect with a new node was preventing additional wires to connect to subsequent nodes.

* Fix: Adapt to #13033

* Refactor: `add_from_iter` is now called `extend` to stick with `Rust` nomenclature.

* Fix docstring

- Caught by @ElePT

Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>

* Fix: Remove duplicate vars check

* Fix: Corrections from code review.
- Use Entry API to modify last nodes in the var.
- Build new_nodes with an allocated vec.
- Add comment explaining the removal of the edge between the output node and its predecessor.

* Fix: Improper use of `Entry API`.
- Use `or_insert_with` instead of `or_insert` to perform actions before inserting a value.

---------

Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>
---
 crates/circuit/src/dag_circuit.rs | 141 +++++++++++++++++++++++++++++-
 1 file changed, 138 insertions(+), 3 deletions(-)

diff --git a/crates/circuit/src/dag_circuit.rs b/crates/circuit/src/dag_circuit.rs
index 32b3a77ed24c..4d41660708d3 100644
--- a/crates/circuit/src/dag_circuit.rs
+++ b/crates/circuit/src/dag_circuit.rs
@@ -4350,9 +4350,7 @@ def _format(operand):
 
             let mut new_layer = self.copy_empty_like(py, vars_mode)?;
 
-            for (node, _) in op_nodes {
-                new_layer.push_back(py, node.clone())?;
-            }
+            new_layer.extend(py, op_nodes.iter().map(|(inst, _)| (*inst).clone()))?;
 
             let new_layer_op_nodes = new_layer.op_nodes(false).filter_map(|node_index| {
                 match new_layer.dag.node_weight(node_index) {
@@ -6366,6 +6364,143 @@ impl DAGCircuit {
             Err(DAGCircuitError::new_err("Specified node is not an op node"))
         }
     }
+
+    /// Extends the DAG with valid instances of [PackedInstruction]
+    pub fn extend<I>(&mut self, py: Python, iter: I) -> PyResult<Vec<NodeIndex>>
+    where
+        I: IntoIterator<Item = PackedInstruction>,
+    {
+        // Create HashSets to keep track of each bit/var's last node
+        let mut qubit_last_nodes: HashMap<Qubit, NodeIndex> = HashMap::default();
+        let mut clbit_last_nodes: HashMap<Clbit, NodeIndex> = HashMap::default();
+        // TODO: Refactor once Vars are in rust
+        // Dict [ Var: (int, VarWeight)]
+        let vars_last_nodes: Bound<PyDict> = PyDict::new_bound(py);
+
+        // Consume into iterator to obtain size hint
+        let iter = iter.into_iter();
+        // Store new nodes to return
+        let mut new_nodes = Vec::with_capacity(iter.size_hint().1.unwrap_or_default());
+        for instr in iter {
+            let op_name = instr.op.name();
+            let (all_cbits, vars): (Vec<Clbit>, Option<Vec<PyObject>>) = {
+                if self.may_have_additional_wires(py, &instr) {
+                    let mut clbits: HashSet<Clbit> =
+                        HashSet::from_iter(self.cargs_interner.get(instr.clbits).iter().copied());
+                    let (additional_clbits, additional_vars) =
+                        self.additional_wires(py, instr.op.view(), instr.condition())?;
+                    for clbit in additional_clbits {
+                        clbits.insert(clbit);
+                    }
+                    (clbits.into_iter().collect(), Some(additional_vars))
+                } else {
+                    (self.cargs_interner.get(instr.clbits).to_vec(), None)
+                }
+            };
+
+            // Increment the operation count
+            self.increment_op(op_name);
+
+            // Get the correct qubit indices
+            let qubits_id = instr.qubits;
+
+            // Insert op-node to graph.
+            let new_node = self.dag.add_node(NodeType::Operation(instr));
+            new_nodes.push(new_node);
+
+            // Check all the qubits in this instruction.
+            for qubit in self.qargs_interner.get(qubits_id) {
+                // Retrieve each qubit's last node
+                let qubit_last_node = *qubit_last_nodes.entry(*qubit).or_insert_with(|| {
+                    // If the qubit is not in the last nodes collection, the edge between the output node and its predecessor.
+                    // Then, store the predecessor's NodeIndex in the last nodes collection.
+                    let output_node = self.qubit_io_map[qubit.0 as usize][1];
+                    let (edge_id, predecessor_node) = self
+                        .dag
+                        .edges_directed(output_node, Incoming)
+                        .next()
+                        .map(|edge| (edge.id(), edge.source()))
+                        .unwrap();
+                    self.dag.remove_edge(edge_id);
+                    predecessor_node
+                });
+                qubit_last_nodes
+                    .entry(*qubit)
+                    .and_modify(|val| *val = new_node);
+                self.dag
+                    .add_edge(qubit_last_node, new_node, Wire::Qubit(*qubit));
+            }
+
+            // Check all the clbits in this instruction.
+            for clbit in all_cbits {
+                let clbit_last_node = *clbit_last_nodes.entry(clbit).or_insert_with(|| {
+                    // If the qubit is not in the last nodes collection, the edge between the output node and its predecessor.
+                    // Then, store the predecessor's NodeIndex in the last nodes collection.
+                    let output_node = self.clbit_io_map[clbit.0 as usize][1];
+                    let (edge_id, predecessor_node) = self
+                        .dag
+                        .edges_directed(output_node, Incoming)
+                        .next()
+                        .map(|edge| (edge.id(), edge.source()))
+                        .unwrap();
+                    self.dag.remove_edge(edge_id);
+                    predecessor_node
+                });
+                clbit_last_nodes
+                    .entry(clbit)
+                    .and_modify(|val| *val = new_node);
+                self.dag
+                    .add_edge(clbit_last_node, new_node, Wire::Clbit(clbit));
+            }
+
+            // If available, check all the vars in this instruction
+            for var in vars.iter().flatten() {
+                let var_last_node = if let Some(result) = vars_last_nodes.get_item(var)? {
+                    let node: usize = result.extract()?;
+                    vars_last_nodes.del_item(var)?;
+                    NodeIndex::new(node)
+                } else {
+                    // If the var is not in the last nodes collection, the edge between the output node and its predecessor.
+                    // Then, store the predecessor's NodeIndex in the last nodes collection.
+                    let output_node = self.var_output_map.get(py, var).unwrap();
+                    let (edge_id, predecessor_node) = self
+                        .dag
+                        .edges_directed(output_node, Incoming)
+                        .next()
+                        .map(|edge| (edge.id(), edge.source()))
+                        .unwrap();
+                    self.dag.remove_edge(edge_id);
+                    predecessor_node
+                };
+
+                vars_last_nodes.set_item(var, new_node.index())?;
+                self.dag
+                    .add_edge(var_last_node, new_node, Wire::Var(var.clone_ref(py)));
+            }
+        }
+
+        // Add the output_nodes back to qargs
+        for (qubit, node) in qubit_last_nodes {
+            let output_node = self.qubit_io_map[qubit.0 as usize][1];
+            self.dag.add_edge(node, output_node, Wire::Qubit(qubit));
+        }
+
+        // Add the output_nodes back to cargs
+        for (clbit, node) in clbit_last_nodes {
+            let output_node = self.clbit_io_map[clbit.0 as usize][1];
+            self.dag.add_edge(node, output_node, Wire::Clbit(clbit));
+        }
+
+        // Add the output_nodes back to vars
+        for item in vars_last_nodes.items() {
+            let (var, node): (PyObject, usize) = item.extract()?;
+            let output_node = self.var_output_map.get(py, &var).unwrap();
+            self.dag
+                .add_edge(NodeIndex::new(node), output_node, Wire::Var(var));
+        }
+
+        Ok(new_nodes)
+    }
 }
 
 /// Add to global phase. Global phase can only be Float or ParameterExpression so this

From 41dc41888ec60a7aab9b93aaa0aaebb5d4711a77 Mon Sep 17 00:00:00 2001
From: Matthew Treinish <mtreinish@kortar.org>
Date: Fri, 6 Sep 2024 16:52:42 -0400
Subject: [PATCH 58/85] Fully port CheckMap to Rust (#13030)

* Fully port CheckMap to Rust

This commit migrates the entirety of the CheckMap analysis pass to Rust.
The pass operates solely in the rust domain and returns an
`Option<(String, [u32; 2])>` to Python which is used to set the two
property set fields appropriately. All the analysis of the dag is done
in Rust. There is still Python interaction required though because
control flow operations are only defined in Python. However the
interaction is minimal and only to get the circuits for control flow
blocks and converting them into DAGs (at least until #13001 is complete).

This commit is based on top of #12959 and will need to be rebased after
that merges.

Closes #12251
Part of #12208

* Use a Vec<Qubit> for wire_map instead of a HashMap

This commit switches to using a Vec<Qubit> for the internal wire_map
used to map control flow qubits. A HashMap was originally used because
in Python a dictionary is used. However, in the rust domain the inner
qubits are contiguous integers starting from 0 so a Vec can be used for
better performance in the case we have control flow.

* Update crates/accelerate/src/check_map.rs

Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>

---------

Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>
---
 crates/accelerate/src/check_map.rs          | 98 +++++++++++++++++++++
 crates/accelerate/src/lib.rs                |  1 +
 crates/pyext/src/lib.rs                     | 13 +--
 qiskit/__init__.py                          |  1 +
 qiskit/transpiler/passes/utils/check_map.py | 33 +++----
 5 files changed, 117 insertions(+), 29 deletions(-)
 create mode 100644 crates/accelerate/src/check_map.rs

diff --git a/crates/accelerate/src/check_map.rs b/crates/accelerate/src/check_map.rs
new file mode 100644
index 000000000000..8ebf50cd372d
--- /dev/null
+++ b/crates/accelerate/src/check_map.rs
@@ -0,0 +1,98 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// 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.
+
+use hashbrown::HashSet;
+use pyo3::intern;
+use pyo3::prelude::*;
+use pyo3::wrap_pyfunction;
+
+use qiskit_circuit::circuit_data::CircuitData;
+use qiskit_circuit::dag_circuit::{DAGCircuit, NodeType};
+use qiskit_circuit::imports::CIRCUIT_TO_DAG;
+use qiskit_circuit::operations::{Operation, OperationRef};
+use qiskit_circuit::Qubit;
+
+fn recurse<'py>(
+    py: Python<'py>,
+    dag: &'py DAGCircuit,
+    edge_set: &'py HashSet<[u32; 2]>,
+    wire_map: Option<&'py [Qubit]>,
+) -> PyResult<Option<(String, [u32; 2])>> {
+    let check_qubits = |qubits: &[Qubit]| -> bool {
+        match wire_map {
+            Some(wire_map) => {
+                let mapped_bits = [
+                    wire_map[qubits[0].0 as usize],
+                    wire_map[qubits[1].0 as usize],
+                ];
+                edge_set.contains(&[mapped_bits[0].into(), mapped_bits[1].into()])
+            }
+            None => edge_set.contains(&[qubits[0].into(), qubits[1].into()]),
+        }
+    };
+    for node in dag.op_nodes(false) {
+        if let NodeType::Operation(inst) = &dag.dag[node] {
+            let qubits = dag.get_qargs(inst.qubits);
+            if inst.op.control_flow() {
+                if let OperationRef::Instruction(py_inst) = inst.op.view() {
+                    let raw_blocks = py_inst.instruction.getattr(py, "blocks")?;
+                    let circuit_to_dag = CIRCUIT_TO_DAG.get_bound(py);
+                    for raw_block in raw_blocks.bind(py).iter().unwrap() {
+                        let block_obj = raw_block?;
+                        let block = block_obj
+                            .getattr(intern!(py, "_data"))?
+                            .downcast::<CircuitData>()?
+                            .borrow();
+                        let new_dag: DAGCircuit =
+                            circuit_to_dag.call1((block_obj.clone(),))?.extract()?;
+                        let wire_map = (0..block.num_qubits())
+                            .map(|inner| {
+                                let outer = qubits[inner];
+                                match wire_map {
+                                    Some(wire_map) => wire_map[outer.0 as usize],
+                                    None => outer,
+                                }
+                            })
+                            .collect::<Vec<_>>();
+                        let res = recurse(py, &new_dag, edge_set, Some(&wire_map))?;
+                        if res.is_some() {
+                            return Ok(res);
+                        }
+                    }
+                }
+            } else if qubits.len() == 2
+                && (dag.calibrations_empty() || !dag.has_calibration_for_index(py, node)?)
+                && !check_qubits(qubits)
+            {
+                return Ok(Some((
+                    inst.op.name().to_string(),
+                    [qubits[0].0, qubits[1].0],
+                )));
+            }
+        }
+    }
+    Ok(None)
+}
+
+#[pyfunction]
+pub fn check_map(
+    py: Python,
+    dag: &DAGCircuit,
+    edge_set: HashSet<[u32; 2]>,
+) -> PyResult<Option<(String, [u32; 2])>> {
+    recurse(py, dag, &edge_set, None)
+}
+
+pub fn check_map_mod(m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_wrapped(wrap_pyfunction!(check_map))?;
+    Ok(())
+}
diff --git a/crates/accelerate/src/lib.rs b/crates/accelerate/src/lib.rs
index 78eea97faad0..f11f28071e2c 100644
--- a/crates/accelerate/src/lib.rs
+++ b/crates/accelerate/src/lib.rs
@@ -14,6 +14,7 @@ use std::env;
 
 use pyo3::import_exception;
 
+pub mod check_map;
 pub mod circuit_library;
 pub mod commutation_analysis;
 pub mod commutation_checker;
diff --git a/crates/pyext/src/lib.rs b/crates/pyext/src/lib.rs
index 49e44bffa2ec..ec883c69c3f1 100644
--- a/crates/pyext/src/lib.rs
+++ b/crates/pyext/src/lib.rs
@@ -13,12 +13,12 @@
 use pyo3::prelude::*;
 
 use qiskit_accelerate::{
-    circuit_library::circuit_library, commutation_analysis::commutation_analysis,
-    commutation_checker::commutation_checker, convert_2q_block_matrix::convert_2q_block_matrix,
-    dense_layout::dense_layout, error_map::error_map,
-    euler_one_qubit_decomposer::euler_one_qubit_decomposer, filter_op_nodes::filter_op_nodes_mod,
-    isometry::isometry, nlayout::nlayout, optimize_1q_gates::optimize_1q_gates,
-    pauli_exp_val::pauli_expval,
+    check_map::check_map_mod, circuit_library::circuit_library,
+    commutation_analysis::commutation_analysis, commutation_checker::commutation_checker,
+    convert_2q_block_matrix::convert_2q_block_matrix, dense_layout::dense_layout,
+    error_map::error_map, euler_one_qubit_decomposer::euler_one_qubit_decomposer,
+    filter_op_nodes::filter_op_nodes_mod, isometry::isometry, nlayout::nlayout,
+    optimize_1q_gates::optimize_1q_gates, pauli_exp_val::pauli_expval,
     remove_diagonal_gates_before_measure::remove_diagonal_gates_before_measure, results::results,
     sabre::sabre, sampled_exp_val::sampled_exp_val, sparse_pauli_op::sparse_pauli_op,
     star_prerouting::star_prerouting, stochastic_swap::stochastic_swap, synthesis::synthesis,
@@ -43,6 +43,7 @@ fn _accelerate(m: &Bound<PyModule>) -> PyResult<()> {
     add_submodule(m, qiskit_qasm2::qasm2, "qasm2")?;
     add_submodule(m, qiskit_qasm3::qasm3, "qasm3")?;
     add_submodule(m, circuit_library, "circuit_library")?;
+    add_submodule(m, check_map_mod, "check_map")?;
     add_submodule(m, convert_2q_block_matrix, "convert_2q_block_matrix")?;
     add_submodule(m, dense_layout, "dense_layout")?;
     add_submodule(m, error_map, "error_map")?;
diff --git a/qiskit/__init__.py b/qiskit/__init__.py
index 3cc10bf96a31..386b9cd082da 100644
--- a/qiskit/__init__.py
+++ b/qiskit/__init__.py
@@ -92,6 +92,7 @@
 sys.modules["qiskit._accelerate.commutation_checker"] = _accelerate.commutation_checker
 sys.modules["qiskit._accelerate.commutation_analysis"] = _accelerate.commutation_analysis
 sys.modules["qiskit._accelerate.synthesis.linear_phase"] = _accelerate.synthesis.linear_phase
+sys.modules["qiskit._accelerate.check_map"] = _accelerate.check_map
 sys.modules["qiskit._accelerate.filter_op_nodes"] = _accelerate.filter_op_nodes
 
 from qiskit.exceptions import QiskitError, MissingOptionalLibraryError
diff --git a/qiskit/transpiler/passes/utils/check_map.py b/qiskit/transpiler/passes/utils/check_map.py
index bd78c65de5f4..4048d93df22c 100644
--- a/qiskit/transpiler/passes/utils/check_map.py
+++ b/qiskit/transpiler/passes/utils/check_map.py
@@ -14,7 +14,8 @@
 
 from qiskit.transpiler.basepasses import AnalysisPass
 from qiskit.transpiler.target import Target
-from qiskit.converters import circuit_to_dag
+
+from qiskit._accelerate import check_map
 
 
 class CheckMap(AnalysisPass):
@@ -67,25 +68,11 @@ def run(self, dag):
         if not self.qargs:
             self.property_set[self.property_set_field] = True
             return
-        wire_map = {bit: index for index, bit in enumerate(dag.qubits)}
-        self.property_set[self.property_set_field] = self._recurse(dag, wire_map)
-
-    def _recurse(self, dag, wire_map) -> bool:
-        for node in dag.op_nodes(include_directives=False):
-            if node.is_control_flow():
-                for block in node.op.blocks:
-                    inner_wire_map = {
-                        inner: wire_map[outer] for inner, outer in zip(block.qubits, node.qargs)
-                    }
-                    if not self._recurse(circuit_to_dag(block), inner_wire_map):
-                        return False
-            elif (
-                len(node.qargs) == 2
-                and not dag.has_calibration_for(node)
-                and (wire_map[node.qargs[0]], wire_map[node.qargs[1]]) not in self.qargs
-            ):
-                self.property_set["check_map_msg"] = (
-                    f"{node.name}({wire_map[node.qargs[0]]}, {wire_map[node.qargs[1]]}) failed"
-                )
-                return False
-        return True
+        res = check_map.check_map(dag, self.qargs)
+        if res is None:
+            self.property_set[self.property_set_field] = True
+            return
+        self.property_set[self.property_set_field] = False
+        self.property_set["check_map_msg"] = (
+            f"{res[0]}({dag.qubits[res[1][0]]}, {dag.qubits[res[1][1]]}) failed"
+        )

From 94ba19e9fbbbdc0176b235e907354c0fab7468f5 Mon Sep 17 00:00:00 2001
From: Matthew Treinish <mtreinish@kortar.org>
Date: Fri, 6 Sep 2024 19:08:47 -0400
Subject: [PATCH 59/85] Fully port InverseCancellation to Rust (#13013)

* Fully port InverseCancellation to Rust

This commit builds off of #12959 and the other data model in Rust
infrastructure and migrates the InverseCancellation pass to
operate fully in Rust. The full path of the transpiler pass now never
leaves Rust until it has finished modifying the DAGCircuit. There is
still some python interaction necessary to handle parts of the data
model that are still in Python, mainly for handling parameter
expressions. But otherwise the entirety of the pass
operates in rust now.

This is just a first pass at the migration here, it moves the pass to
use loops in rust. The next steps here are to look at operating
the pass in parallel. There is no data dependency between the
optimizations being done for different inverse gates/pairs so we should
be able to the throughput of the pass by leveraging multithreading to
handle each inverse option in parallel. This commit does not attempt
this though, because of the Python dependency and also the data
structures around gates and the dag aren't really setup for
multithreading yet and there likely will need to be some work to
support that.

Fixes #12271
Part of #12208

* Remove temporary variable for chunk empty check

* Destructure gate pairs

* Rework short circuit logic
---
 crates/accelerate/src/inverse_cancellation.rs | 191 ++++++++++++++++++
 crates/accelerate/src/lib.rs                  |   1 +
 crates/circuit/src/dag_circuit.rs             |  94 +++++----
 crates/pyext/src/lib.rs                       |   6 +-
 qiskit/__init__.py                            |   1 +
 .../optimization/inverse_cancellation.py      | 101 +--------
 6 files changed, 260 insertions(+), 134 deletions(-)
 create mode 100644 crates/accelerate/src/inverse_cancellation.rs

diff --git a/crates/accelerate/src/inverse_cancellation.rs b/crates/accelerate/src/inverse_cancellation.rs
new file mode 100644
index 000000000000..0b3404c92ffb
--- /dev/null
+++ b/crates/accelerate/src/inverse_cancellation.rs
@@ -0,0 +1,191 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// 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.
+
+use ahash::RandomState;
+use hashbrown::HashSet;
+use indexmap::IndexMap;
+use pyo3::prelude::*;
+use rustworkx_core::petgraph::stable_graph::NodeIndex;
+
+use qiskit_circuit::circuit_instruction::OperationFromPython;
+use qiskit_circuit::dag_circuit::{DAGCircuit, NodeType};
+use qiskit_circuit::operations::Operation;
+use qiskit_circuit::packed_instruction::PackedInstruction;
+
+fn gate_eq(py: Python, gate_a: &PackedInstruction, gate_b: &OperationFromPython) -> PyResult<bool> {
+    if gate_a.op.name() != gate_b.operation.name() {
+        return Ok(false);
+    }
+    let a_params = gate_a.params_view();
+    if a_params.len() != gate_b.params.len() {
+        return Ok(false);
+    }
+    let mut param_eq = true;
+    for (a, b) in a_params.iter().zip(&gate_b.params) {
+        if !a.is_close(py, b, 1e-10)? {
+            param_eq = false;
+            break;
+        }
+    }
+    Ok(param_eq)
+}
+
+fn run_on_self_inverse(
+    py: Python,
+    dag: &mut DAGCircuit,
+    op_counts: &IndexMap<String, usize, RandomState>,
+    self_inverse_gate_names: HashSet<String>,
+    self_inverse_gates: Vec<OperationFromPython>,
+) -> PyResult<()> {
+    if !self_inverse_gate_names
+        .iter()
+        .any(|name| op_counts.contains_key(name))
+    {
+        return Ok(());
+    }
+    for gate in self_inverse_gates {
+        let gate_count = op_counts.get(gate.operation.name()).unwrap_or(&0);
+        if *gate_count <= 1 {
+            continue;
+        }
+        let mut collect_set: HashSet<String> = HashSet::with_capacity(1);
+        collect_set.insert(gate.operation.name().to_string());
+        let gate_runs: Vec<Vec<NodeIndex>> = dag.collect_runs(collect_set).unwrap().collect();
+        for gate_cancel_run in gate_runs {
+            let mut partitions: Vec<Vec<NodeIndex>> = Vec::new();
+            let mut chunk: Vec<NodeIndex> = Vec::new();
+            let max_index = gate_cancel_run.len() - 1;
+            for (i, cancel_gate) in gate_cancel_run.iter().enumerate() {
+                let node = &dag.dag[*cancel_gate];
+                if let NodeType::Operation(inst) = node {
+                    if gate_eq(py, inst, &gate)? {
+                        chunk.push(*cancel_gate);
+                    } else {
+                        if !chunk.is_empty() {
+                            partitions.push(std::mem::take(&mut chunk));
+                        }
+                        continue;
+                    }
+                    if i == max_index {
+                        partitions.push(std::mem::take(&mut chunk));
+                    } else {
+                        let next_qargs = if let NodeType::Operation(next_inst) =
+                            &dag.dag[gate_cancel_run[i + 1]]
+                        {
+                            next_inst.qubits
+                        } else {
+                            panic!("Not an op node")
+                        };
+                        if inst.qubits != next_qargs {
+                            partitions.push(std::mem::take(&mut chunk));
+                        }
+                    }
+                } else {
+                    panic!("Not an op node");
+                }
+            }
+            for chunk in partitions {
+                if chunk.len() % 2 == 0 {
+                    dag.remove_op_node(chunk[0]);
+                }
+                for node in &chunk[1..] {
+                    dag.remove_op_node(*node);
+                }
+            }
+        }
+    }
+    Ok(())
+}
+fn run_on_inverse_pairs(
+    py: Python,
+    dag: &mut DAGCircuit,
+    op_counts: &IndexMap<String, usize, RandomState>,
+    inverse_gate_names: HashSet<String>,
+    inverse_gates: Vec<[OperationFromPython; 2]>,
+) -> PyResult<()> {
+    if !inverse_gate_names
+        .iter()
+        .any(|name| op_counts.contains_key(name))
+    {
+        return Ok(());
+    }
+    for [gate_0, gate_1] in inverse_gates {
+        let gate_0_name = gate_0.operation.name();
+        let gate_1_name = gate_1.operation.name();
+        if !op_counts.contains_key(gate_0_name) || !op_counts.contains_key(gate_1_name) {
+            continue;
+        }
+        let names: HashSet<String> = [&gate_0, &gate_1]
+            .iter()
+            .map(|x| x.operation.name().to_string())
+            .collect();
+        let runs: Vec<Vec<NodeIndex>> = dag.collect_runs(names).unwrap().collect();
+        for nodes in runs {
+            let mut i = 0;
+            while i < nodes.len() - 1 {
+                if let NodeType::Operation(inst) = &dag.dag[nodes[i]] {
+                    if let NodeType::Operation(next_inst) = &dag.dag[nodes[i + 1]] {
+                        if inst.qubits == next_inst.qubits
+                            && ((gate_eq(py, inst, &gate_0)? && gate_eq(py, next_inst, &gate_1)?)
+                                || (gate_eq(py, inst, &gate_1)?
+                                    && gate_eq(py, next_inst, &gate_0)?))
+                        {
+                            dag.remove_op_node(nodes[i]);
+                            dag.remove_op_node(nodes[i + 1]);
+                            i += 2;
+                        } else {
+                            i += 1;
+                        }
+                    } else {
+                        panic!("Not an op node")
+                    }
+                } else {
+                    panic!("Not an op node")
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+#[pyfunction]
+pub fn inverse_cancellation(
+    py: Python,
+    dag: &mut DAGCircuit,
+    inverse_gates: Vec<[OperationFromPython; 2]>,
+    self_inverse_gates: Vec<OperationFromPython>,
+    inverse_gate_names: HashSet<String>,
+    self_inverse_gate_names: HashSet<String>,
+) -> PyResult<()> {
+    if self_inverse_gate_names.is_empty() && inverse_gate_names.is_empty() {
+        return Ok(());
+    }
+    let op_counts = dag.count_ops(py, true)?;
+    if !self_inverse_gate_names.is_empty() {
+        run_on_self_inverse(
+            py,
+            dag,
+            &op_counts,
+            self_inverse_gate_names,
+            self_inverse_gates,
+        )?;
+    }
+    if !inverse_gate_names.is_empty() {
+        run_on_inverse_pairs(py, dag, &op_counts, inverse_gate_names, inverse_gates)?;
+    }
+    Ok(())
+}
+
+pub fn inverse_cancellation_mod(m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_wrapped(wrap_pyfunction!(inverse_cancellation))?;
+    Ok(())
+}
diff --git a/crates/accelerate/src/lib.rs b/crates/accelerate/src/lib.rs
index f11f28071e2c..26d93ab3f65e 100644
--- a/crates/accelerate/src/lib.rs
+++ b/crates/accelerate/src/lib.rs
@@ -24,6 +24,7 @@ pub mod edge_collections;
 pub mod error_map;
 pub mod euler_one_qubit_decomposer;
 pub mod filter_op_nodes;
+pub mod inverse_cancellation;
 pub mod isometry;
 pub mod nlayout;
 pub mod optimize_1q_gates;
diff --git a/crates/circuit/src/dag_circuit.rs b/crates/circuit/src/dag_circuit.rs
index 4d41660708d3..e57942f87cc0 100644
--- a/crates/circuit/src/dag_circuit.rs
+++ b/crates/circuit/src/dag_circuit.rs
@@ -4575,45 +4575,9 @@ def _format(operand):
     ///
     /// Returns:
     ///     Mapping[str, int]: a mapping of operation names to the number of times it appears.
-    #[pyo3(signature = (*, recurse=true))]
-    fn count_ops(&self, py: Python, recurse: bool) -> PyResult<PyObject> {
-        if !recurse || !self.has_control_flow() {
-            Ok(self.op_names.to_object(py))
-        } else {
-            fn inner(
-                py: Python,
-                dag: &DAGCircuit,
-                counts: &mut HashMap<String, usize>,
-            ) -> PyResult<()> {
-                for (key, value) in dag.op_names.iter() {
-                    counts
-                        .entry(key.clone())
-                        .and_modify(|count| *count += value)
-                        .or_insert(*value);
-                }
-                let circuit_to_dag = imports::CIRCUIT_TO_DAG.get_bound(py);
-                for node in dag.dag.node_weights() {
-                    let NodeType::Operation(node) = node else {
-                        continue;
-                    };
-                    if !node.op.control_flow() {
-                        continue;
-                    }
-                    let OperationRef::Instruction(inst) = node.op.view() else {
-                        panic!("control flow op must be an instruction")
-                    };
-                    let blocks = inst.instruction.bind(py).getattr("blocks")?;
-                    for block in blocks.iter()? {
-                        let inner_dag: &DAGCircuit = &circuit_to_dag.call1((block?,))?.extract()?;
-                        inner(py, inner_dag, counts)?;
-                    }
-                }
-                Ok(())
-            }
-            let mut counts = HashMap::with_capacity(self.op_names.len());
-            inner(py, self, &mut counts)?;
-            Ok(counts.to_object(py))
-        }
+    #[pyo3(name = "count_ops", signature = (*, recurse=true))]
+    fn py_count_ops(&self, py: Python, recurse: bool) -> PyResult<PyObject> {
+        self.count_ops(py, recurse).map(|x| x.into_py(py))
     }
 
     /// Count the occurrences of operation names on the longest path.
@@ -4745,7 +4709,7 @@ def _format(operand):
             ("qubits", self.num_qubits().into_py(py)),
             ("bits", self.num_clbits().into_py(py)),
             ("factors", self.num_tensor_factors().into_py(py)),
-            ("operations", self.count_ops(py, true)?),
+            ("operations", self.py_count_ops(py, true)?),
         ]))
     }
 
@@ -6365,6 +6329,56 @@ impl DAGCircuit {
         }
     }
 
+    /// Return the op name counts in the circuit
+    ///
+    /// Args:
+    ///     py: The python token necessary for control flow recursion
+    ///     recurse: Whether to recurse into control flow ops or not
+    pub fn count_ops(
+        &self,
+        py: Python,
+        recurse: bool,
+    ) -> PyResult<IndexMap<String, usize, RandomState>> {
+        if !recurse || !self.has_control_flow() {
+            Ok(self.op_names.clone())
+        } else {
+            fn inner(
+                py: Python,
+                dag: &DAGCircuit,
+                counts: &mut IndexMap<String, usize, RandomState>,
+            ) -> PyResult<()> {
+                for (key, value) in dag.op_names.iter() {
+                    counts
+                        .entry(key.clone())
+                        .and_modify(|count| *count += value)
+                        .or_insert(*value);
+                }
+                let circuit_to_dag = imports::CIRCUIT_TO_DAG.get_bound(py);
+                for node in dag.dag.node_weights() {
+                    let NodeType::Operation(node) = node else {
+                        continue;
+                    };
+                    if !node.op.control_flow() {
+                        continue;
+                    }
+                    let OperationRef::Instruction(inst) = node.op.view() else {
+                        panic!("control flow op must be an instruction")
+                    };
+                    let blocks = inst.instruction.bind(py).getattr("blocks")?;
+                    for block in blocks.iter()? {
+                        let inner_dag: &DAGCircuit = &circuit_to_dag.call1((block?,))?.extract()?;
+                        inner(py, inner_dag, counts)?;
+                    }
+                }
+                Ok(())
+            }
+            let mut counts =
+                IndexMap::with_capacity_and_hasher(self.op_names.len(), RandomState::default());
+            inner(py, self, &mut counts)?;
+            Ok(counts)
+        }
+    }
+
     /// Extends the DAG with valid instances of [PackedInstruction]
     pub fn extend<I>(&mut self, py: Python, iter: I) -> PyResult<Vec<NodeIndex>>
     where
diff --git a/crates/pyext/src/lib.rs b/crates/pyext/src/lib.rs
index ec883c69c3f1..331703809397 100644
--- a/crates/pyext/src/lib.rs
+++ b/crates/pyext/src/lib.rs
@@ -17,8 +17,9 @@ use qiskit_accelerate::{
     commutation_analysis::commutation_analysis, commutation_checker::commutation_checker,
     convert_2q_block_matrix::convert_2q_block_matrix, dense_layout::dense_layout,
     error_map::error_map, euler_one_qubit_decomposer::euler_one_qubit_decomposer,
-    filter_op_nodes::filter_op_nodes_mod, isometry::isometry, nlayout::nlayout,
-    optimize_1q_gates::optimize_1q_gates, pauli_exp_val::pauli_expval,
+    filter_op_nodes::filter_op_nodes_mod, inverse_cancellation::inverse_cancellation_mod,
+    isometry::isometry, nlayout::nlayout, optimize_1q_gates::optimize_1q_gates,
+    pauli_exp_val::pauli_expval,
     remove_diagonal_gates_before_measure::remove_diagonal_gates_before_measure, results::results,
     sabre::sabre, sampled_exp_val::sampled_exp_val, sparse_pauli_op::sparse_pauli_op,
     star_prerouting::star_prerouting, stochastic_swap::stochastic_swap, synthesis::synthesis,
@@ -48,6 +49,7 @@ fn _accelerate(m: &Bound<PyModule>) -> PyResult<()> {
     add_submodule(m, dense_layout, "dense_layout")?;
     add_submodule(m, error_map, "error_map")?;
     add_submodule(m, euler_one_qubit_decomposer, "euler_one_qubit_decomposer")?;
+    add_submodule(m, inverse_cancellation_mod, "inverse_cancellation")?;
     add_submodule(m, filter_op_nodes_mod, "filter_op_nodes")?;
     add_submodule(m, isometry, "isometry")?;
     add_submodule(m, nlayout, "nlayout")?;
diff --git a/qiskit/__init__.py b/qiskit/__init__.py
index 386b9cd082da..27830243d852 100644
--- a/qiskit/__init__.py
+++ b/qiskit/__init__.py
@@ -92,6 +92,7 @@
 sys.modules["qiskit._accelerate.commutation_checker"] = _accelerate.commutation_checker
 sys.modules["qiskit._accelerate.commutation_analysis"] = _accelerate.commutation_analysis
 sys.modules["qiskit._accelerate.synthesis.linear_phase"] = _accelerate.synthesis.linear_phase
+sys.modules["qiskit._accelerate.inverse_cancellation"] = _accelerate.inverse_cancellation
 sys.modules["qiskit._accelerate.check_map"] = _accelerate.check_map
 sys.modules["qiskit._accelerate.filter_op_nodes"] = _accelerate.filter_op_nodes
 
diff --git a/qiskit/transpiler/passes/optimization/inverse_cancellation.py b/qiskit/transpiler/passes/optimization/inverse_cancellation.py
index f5523432c26e..40876679e8d9 100644
--- a/qiskit/transpiler/passes/optimization/inverse_cancellation.py
+++ b/qiskit/transpiler/passes/optimization/inverse_cancellation.py
@@ -20,6 +20,8 @@
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.exceptions import TranspilerError
 
+from qiskit._accelerate.inverse_cancellation import inverse_cancellation
+
 
 class InverseCancellation(TransformationPass):
     """Cancel specific Gates which are inverses of each other when they occur back-to-
@@ -81,96 +83,11 @@ def run(self, dag: DAGCircuit):
         Returns:
             DAGCircuit: Transformed DAG.
         """
-        if self.self_inverse_gates:
-            dag = self._run_on_self_inverse(dag)
-        if self.inverse_gate_pairs:
-            dag = self._run_on_inverse_pairs(dag)
-        return dag
-
-    def _run_on_self_inverse(self, dag: DAGCircuit):
-        """
-        Run self-inverse gates on `dag`.
-
-        Args:
-            dag: the directed acyclic graph to run on.
-            self_inverse_gates: list of gates who cancel themeselves in pairs
-
-        Returns:
-            DAGCircuit: Transformed DAG.
-        """
-        op_counts = dag.count_ops()
-        if not self.self_inverse_gate_names.intersection(op_counts):
-            return dag
-        # Sets of gate runs by name, for instance: [{(H 0, H 0), (H 1, H 1)}, {(X 0, X 0}]
-        for gate in self.self_inverse_gates:
-            gate_name = gate.name
-            gate_count = op_counts.get(gate_name, 0)
-            if gate_count <= 1:
-                continue
-            gate_runs = dag.collect_runs([gate_name])
-            for gate_cancel_run in gate_runs:
-                partitions = []
-                chunk = []
-                max_index = len(gate_cancel_run) - 1
-                for i, cancel_gate in enumerate(gate_cancel_run):
-                    if cancel_gate.op == gate:
-                        chunk.append(cancel_gate)
-                    else:
-                        if chunk:
-                            partitions.append(chunk)
-                            chunk = []
-                        continue
-                    if i == max_index or cancel_gate.qargs != gate_cancel_run[i + 1].qargs:
-                        partitions.append(chunk)
-                        chunk = []
-                # Remove an even number of gates from each chunk
-                for chunk in partitions:
-                    if len(chunk) % 2 == 0:
-                        dag.remove_op_node(chunk[0])
-                    for node in chunk[1:]:
-                        dag.remove_op_node(node)
-        return dag
-
-    def _run_on_inverse_pairs(self, dag: DAGCircuit):
-        """
-        Run inverse gate pairs on `dag`.
-
-        Args:
-            dag: the directed acyclic graph to run on.
-            inverse_gate_pairs: list of gates with inverse angles that cancel each other.
-
-        Returns:
-            DAGCircuit: Transformed DAG.
-        """
-        op_counts = dag.count_ops()
-        if not self.inverse_gate_pairs_names.intersection(op_counts):
-            return dag
-
-        for pair in self.inverse_gate_pairs:
-            gate_0_name = pair[0].name
-            gate_1_name = pair[1].name
-            if gate_0_name not in op_counts or gate_1_name not in op_counts:
-                continue
-            gate_cancel_runs = dag.collect_runs([gate_0_name, gate_1_name])
-            for dag_nodes in gate_cancel_runs:
-                i = 0
-                while i < len(dag_nodes) - 1:
-                    if (
-                        dag_nodes[i].qargs == dag_nodes[i + 1].qargs
-                        and dag_nodes[i].op == pair[0]
-                        and dag_nodes[i + 1].op == pair[1]
-                    ):
-                        dag.remove_op_node(dag_nodes[i])
-                        dag.remove_op_node(dag_nodes[i + 1])
-                        i = i + 2
-                    elif (
-                        dag_nodes[i].qargs == dag_nodes[i + 1].qargs
-                        and dag_nodes[i].op == pair[1]
-                        and dag_nodes[i + 1].op == pair[0]
-                    ):
-                        dag.remove_op_node(dag_nodes[i])
-                        dag.remove_op_node(dag_nodes[i + 1])
-                        i = i + 2
-                    else:
-                        i = i + 1
+        inverse_cancellation(
+            dag,
+            self.inverse_gate_pairs,
+            self.self_inverse_gates,
+            self.inverse_gate_pairs_names,
+            self.self_inverse_gate_names,
+        )
         return dag

From 734560e6c922afb88f2d4796e611e16a2d7923fa Mon Sep 17 00:00:00 2001
From: Eli Arbel <46826214+eliarbel@users.noreply.github.com>
Date: Sun, 8 Sep 2024 15:10:30 +0300
Subject: [PATCH 60/85] Oxidize CheckGateDirection (#13042)

* First working implementation

* A control flow fix, lint, doc and some more polishing

* Addressing review comments and further simplifying the code

* Address more review comments

* Use explicit temp storage for mapping to avoid E0716 in Rust 1.70

* Allow checking 2Q non-control flow instructions
---
 crates/accelerate/src/gate_direction.rs       | 150 ++++++++++++++++++
 crates/accelerate/src/lib.rs                  |   1 +
 .../accelerate/src/target_transpiler/mod.rs   |   2 +-
 crates/circuit/src/dag_circuit.rs             |  30 ++--
 crates/circuit/src/lib.rs                     |   2 +-
 crates/pyext/src/lib.rs                       |   7 +-
 qiskit/__init__.py                            |   1 +
 .../passes/utils/check_gate_direction.py      |  49 +-----
 .../transpiler/test_check_gate_direction.py   |  26 +--
 9 files changed, 196 insertions(+), 72 deletions(-)
 create mode 100644 crates/accelerate/src/gate_direction.rs

diff --git a/crates/accelerate/src/gate_direction.rs b/crates/accelerate/src/gate_direction.rs
new file mode 100644
index 000000000000..aee5ca097322
--- /dev/null
+++ b/crates/accelerate/src/gate_direction.rs
@@ -0,0 +1,150 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// 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.
+
+use crate::nlayout::PhysicalQubit;
+use crate::target_transpiler::Target;
+use hashbrown::HashSet;
+use pyo3::prelude::*;
+use qiskit_circuit::imports;
+use qiskit_circuit::operations::OperationRef;
+use qiskit_circuit::{
+    dag_circuit::{DAGCircuit, NodeType},
+    operations::Operation,
+    packed_instruction::PackedInstruction,
+    Qubit,
+};
+use smallvec::smallvec;
+
+/// Check if the two-qubit gates follow the right direction with respect to the coupling map.
+///
+/// Args:
+///     dag: the DAGCircuit to analyze
+///
+///     coupling_edges: set of edge pairs representing a directed coupling map, against which gate directionality is checked
+///
+/// Returns:
+///     true iff all two-qubit gates comply with the coupling constraints
+#[pyfunction]
+#[pyo3(name = "check_gate_direction_coupling")]
+fn py_check_with_coupling_map(
+    py: Python,
+    dag: &DAGCircuit,
+    coupling_edges: HashSet<[Qubit; 2]>,
+) -> PyResult<bool> {
+    let coupling_map_check =
+        |_: &PackedInstruction, op_args: &[Qubit]| -> bool { coupling_edges.contains(op_args) };
+
+    check_gate_direction(py, dag, &coupling_map_check, None)
+}
+
+/// Check if the two-qubit gates follow the right direction with respect to instructions supported in the given target.
+///
+/// Args:
+///     dag: the DAGCircuit to analyze
+///
+///     target: the Target against which gate directionality compliance is checked
+///
+/// Returns:
+///     true iff all two-qubit gates comply with the target's coupling constraints
+#[pyfunction]
+#[pyo3(name = "check_gate_direction_target")]
+fn py_check_with_target(py: Python, dag: &DAGCircuit, target: &Target) -> PyResult<bool> {
+    let target_check = |inst: &PackedInstruction, op_args: &[Qubit]| -> bool {
+        let qargs = smallvec![
+            PhysicalQubit::new(op_args[0].0),
+            PhysicalQubit::new(op_args[1].0)
+        ];
+
+        target.instruction_supported(inst.op.name(), Some(&qargs))
+    };
+
+    check_gate_direction(py, dag, &target_check, None)
+}
+
+// The main routine for checking gate directionality.
+//
+// gate_complies: a function returning true iff the two-qubit gate direction complies with directionality constraints
+//
+// qubit_mapping: used for mapping the index of a given qubit within an instruction qargs vector to the corresponding qubit index of the
+//  original DAGCircuit the pass was called with. This mapping is required since control flow blocks are represented by nested DAGCircuit
+//  objects whose instruction qubit indices are relative to the parent DAGCircuit they reside in, thus when we recurse into nested DAGs, we need
+//  to carry the mapping context relative to the original DAG.
+//  When qubit_mapping is None, the identity mapping is assumed
+fn check_gate_direction<T>(
+    py: Python,
+    dag: &DAGCircuit,
+    gate_complies: &T,
+    qubit_mapping: Option<&[Qubit]>,
+) -> PyResult<bool>
+where
+    T: Fn(&PackedInstruction, &[Qubit]) -> bool,
+{
+    for node in dag.op_nodes(false) {
+        let NodeType::Operation(packed_inst) = &dag.dag[node] else {
+            panic!("PackedInstruction is expected");
+        };
+
+        let inst_qargs = dag.get_qargs(packed_inst.qubits);
+
+        if let OperationRef::Instruction(py_inst) = packed_inst.op.view() {
+            if py_inst.control_flow() {
+                let circuit_to_dag = imports::CIRCUIT_TO_DAG.get_bound(py); // TODO: Take out of the recursion
+                let py_inst = py_inst.instruction.bind(py);
+
+                for block in py_inst.getattr("blocks")?.iter()? {
+                    let inner_dag: DAGCircuit = circuit_to_dag.call1((block?,))?.extract()?;
+
+                    let block_ok = if let Some(mapping) = qubit_mapping {
+                        let mapping = inst_qargs // Create a temp mapping for the recursive call
+                            .iter()
+                            .map(|q| mapping[q.0 as usize])
+                            .collect::<Vec<Qubit>>();
+
+                        check_gate_direction(py, &inner_dag, gate_complies, Some(&mapping))?
+                    } else {
+                        check_gate_direction(py, &inner_dag, gate_complies, Some(inst_qargs))?
+                    };
+
+                    if !block_ok {
+                        return Ok(false);
+                    }
+                }
+                continue;
+            }
+        }
+
+        if inst_qargs.len() == 2
+            && !match qubit_mapping {
+                // Check gate direction based either on a given custom mapping or the identity mapping
+                Some(mapping) => gate_complies(
+                    packed_inst,
+                    &[
+                        mapping[inst_qargs[0].0 as usize],
+                        mapping[inst_qargs[1].0 as usize],
+                    ],
+                ),
+                None => gate_complies(packed_inst, inst_qargs),
+            }
+        {
+            return Ok(false);
+        }
+    }
+
+    Ok(true)
+}
+
+#[pymodule]
+pub fn gate_direction(m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_wrapped(wrap_pyfunction!(py_check_with_coupling_map))?;
+    m.add_wrapped(wrap_pyfunction!(py_check_with_target))?;
+    Ok(())
+}
diff --git a/crates/accelerate/src/lib.rs b/crates/accelerate/src/lib.rs
index 26d93ab3f65e..916aeeb8351c 100644
--- a/crates/accelerate/src/lib.rs
+++ b/crates/accelerate/src/lib.rs
@@ -24,6 +24,7 @@ pub mod edge_collections;
 pub mod error_map;
 pub mod euler_one_qubit_decomposer;
 pub mod filter_op_nodes;
+pub mod gate_direction;
 pub mod inverse_cancellation;
 pub mod isometry;
 pub mod nlayout;
diff --git a/crates/accelerate/src/target_transpiler/mod.rs b/crates/accelerate/src/target_transpiler/mod.rs
index 08b3e90eabba..65fc8e80d750 100644
--- a/crates/accelerate/src/target_transpiler/mod.rs
+++ b/crates/accelerate/src/target_transpiler/mod.rs
@@ -50,7 +50,7 @@ mod exceptions {
 }
 
 // Custom types
-type Qargs = SmallVec<[PhysicalQubit; 2]>;
+pub type Qargs = SmallVec<[PhysicalQubit; 2]>;
 type GateMap = IndexMap<String, PropsMap, RandomState>;
 type PropsMap = NullableIndexMap<Qargs, Option<InstructionProperties>>;
 type GateMapState = Vec<(String, Vec<(Option<Qargs>, Option<InstructionProperties>)>)>;
diff --git a/crates/circuit/src/dag_circuit.rs b/crates/circuit/src/dag_circuit.rs
index e57942f87cc0..5b9769b4d19e 100644
--- a/crates/circuit/src/dag_circuit.rs
+++ b/crates/circuit/src/dag_circuit.rs
@@ -3975,19 +3975,12 @@ def _format(operand):
     }
 
     /// Get list of 2 qubit operations. Ignore directives like snapshot and barrier.
-    fn two_qubit_ops(&self, py: Python) -> PyResult<Vec<Py<PyAny>>> {
+    #[pyo3(name = "two_qubit_ops")]
+    pub fn py_two_qubit_ops(&self, py: Python) -> PyResult<Vec<Py<PyAny>>> {
         let mut nodes = Vec::new();
-        for (node, weight) in self.dag.node_references() {
-            if let NodeType::Operation(ref packed) = weight {
-                if packed.op.directive() {
-                    continue;
-                }
-
-                let qargs = self.qargs_interner.get(packed.qubits);
-                if qargs.len() == 2 {
-                    nodes.push(self.unpack_into(py, node, weight)?);
-                }
-            }
+        for node in self.two_qubit_ops() {
+            let weight = self.dag.node_weight(node).expect("NodeIndex in graph");
+            nodes.push(self.unpack_into(py, node, weight)?);
         }
         Ok(nodes)
     }
@@ -5756,6 +5749,19 @@ impl DAGCircuit {
         }
     }
 
+    /// Return an iterator of 2 qubit operations. Ignore directives like snapshot and barrier.
+    pub fn two_qubit_ops(&self) -> impl Iterator<Item = NodeIndex> + '_ {
+        Box::new(self.op_nodes(false).filter(|index| {
+            let weight = self.dag.node_weight(*index).expect("NodeIndex in graph");
+            if let NodeType::Operation(ref packed) = weight {
+                let qargs = self.qargs_interner.get(packed.qubits);
+                qargs.len() == 2
+            } else {
+                false
+            }
+        }))
+    }
+
     // Filter any nodes that don't match a given predicate function
     pub fn filter_op_nodes<F>(&mut self, mut predicate: F)
     where
diff --git a/crates/circuit/src/lib.rs b/crates/circuit/src/lib.rs
index 4ca86c2ca83c..5106ba030288 100644
--- a/crates/circuit/src/lib.rs
+++ b/crates/circuit/src/lib.rs
@@ -32,7 +32,7 @@ use pyo3::prelude::*;
 use pyo3::types::{PySequence, PyTuple};
 
 pub type BitType = u32;
-#[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
+#[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq, FromPyObject)]
 pub struct Qubit(pub BitType);
 #[derive(Copy, Clone, Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
 pub struct Clbit(pub BitType);
diff --git a/crates/pyext/src/lib.rs b/crates/pyext/src/lib.rs
index 331703809397..96b5e84a9cbe 100644
--- a/crates/pyext/src/lib.rs
+++ b/crates/pyext/src/lib.rs
@@ -17,9 +17,9 @@ use qiskit_accelerate::{
     commutation_analysis::commutation_analysis, commutation_checker::commutation_checker,
     convert_2q_block_matrix::convert_2q_block_matrix, dense_layout::dense_layout,
     error_map::error_map, euler_one_qubit_decomposer::euler_one_qubit_decomposer,
-    filter_op_nodes::filter_op_nodes_mod, inverse_cancellation::inverse_cancellation_mod,
-    isometry::isometry, nlayout::nlayout, optimize_1q_gates::optimize_1q_gates,
-    pauli_exp_val::pauli_expval,
+    filter_op_nodes::filter_op_nodes_mod, gate_direction::gate_direction,
+    inverse_cancellation::inverse_cancellation_mod, isometry::isometry, nlayout::nlayout,
+    optimize_1q_gates::optimize_1q_gates, pauli_exp_val::pauli_expval,
     remove_diagonal_gates_before_measure::remove_diagonal_gates_before_measure, results::results,
     sabre::sabre, sampled_exp_val::sampled_exp_val, sparse_pauli_op::sparse_pauli_op,
     star_prerouting::star_prerouting, stochastic_swap::stochastic_swap, synthesis::synthesis,
@@ -72,6 +72,7 @@ fn _accelerate(m: &Bound<PyModule>) -> PyResult<()> {
     add_submodule(m, uc_gate, "uc_gate")?;
     add_submodule(m, utils, "utils")?;
     add_submodule(m, vf2_layout, "vf2_layout")?;
+    add_submodule(m, gate_direction, "gate_direction")?;
     add_submodule(m, commutation_checker, "commutation_checker")?;
     add_submodule(m, commutation_analysis, "commutation_analysis")?;
     Ok(())
diff --git a/qiskit/__init__.py b/qiskit/__init__.py
index 27830243d852..f731465beecb 100644
--- a/qiskit/__init__.py
+++ b/qiskit/__init__.py
@@ -92,6 +92,7 @@
 sys.modules["qiskit._accelerate.commutation_checker"] = _accelerate.commutation_checker
 sys.modules["qiskit._accelerate.commutation_analysis"] = _accelerate.commutation_analysis
 sys.modules["qiskit._accelerate.synthesis.linear_phase"] = _accelerate.synthesis.linear_phase
+sys.modules["qiskit._accelerate.gate_direction"] = _accelerate.gate_direction
 sys.modules["qiskit._accelerate.inverse_cancellation"] = _accelerate.inverse_cancellation
 sys.modules["qiskit._accelerate.check_map"] = _accelerate.check_map
 sys.modules["qiskit._accelerate.filter_op_nodes"] = _accelerate.filter_op_nodes
diff --git a/qiskit/transpiler/passes/utils/check_gate_direction.py b/qiskit/transpiler/passes/utils/check_gate_direction.py
index e797be95c4a1..5251bfc8de96 100644
--- a/qiskit/transpiler/passes/utils/check_gate_direction.py
+++ b/qiskit/transpiler/passes/utils/check_gate_direction.py
@@ -12,9 +12,11 @@
 
 """Check if the gates follow the right direction with respect to the coupling map."""
 
-from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES
-from qiskit.converters import circuit_to_dag
 from qiskit.transpiler.basepasses import AnalysisPass
+from qiskit._accelerate.gate_direction import (
+    check_gate_direction_coupling,
+    check_gate_direction_target,
+)
 
 
 class CheckGateDirection(AnalysisPass):
@@ -34,42 +36,6 @@ def __init__(self, coupling_map, target=None):
         self.coupling_map = coupling_map
         self.target = target
 
-    def _coupling_map_visit(self, dag, wire_map, edges=None):
-        if edges is None:
-            edges = self.coupling_map.get_edges()
-        # Don't include directives to avoid things like barrier, which are assumed always supported.
-        for node in dag.op_nodes(include_directives=False):
-            if node.name in CONTROL_FLOW_OP_NAMES:
-                for block in node.op.blocks:
-                    inner_wire_map = {
-                        inner: wire_map[outer] for outer, inner in zip(node.qargs, block.qubits)
-                    }
-
-                    if not self._coupling_map_visit(circuit_to_dag(block), inner_wire_map, edges):
-                        return False
-            elif (
-                len(node.qargs) == 2
-                and (wire_map[node.qargs[0]], wire_map[node.qargs[1]]) not in edges
-            ):
-                return False
-        return True
-
-    def _target_visit(self, dag, wire_map):
-        # Don't include directives to avoid things like barrier, which are assumed always supported.
-        for node in dag.op_nodes(include_directives=False):
-            if node.name in CONTROL_FLOW_OP_NAMES:
-                for block in node.op.blocks:
-                    inner_wire_map = {
-                        inner: wire_map[outer] for outer, inner in zip(node.qargs, block.qubits)
-                    }
-                    if not self._target_visit(circuit_to_dag(block), inner_wire_map):
-                        return False
-            elif len(node.qargs) == 2 and not self.target.instruction_supported(
-                node.name, (wire_map[node.qargs[0]], wire_map[node.qargs[1]])
-            ):
-                return False
-        return True
-
     def run(self, dag):
         """Run the CheckGateDirection pass on `dag`.
 
@@ -79,9 +45,8 @@ def run(self, dag):
         Args:
             dag (DAGCircuit): DAG to check.
         """
-        wire_map = {bit: i for i, bit in enumerate(dag.qubits)}
         self.property_set["is_direction_mapped"] = (
-            self._coupling_map_visit(dag, wire_map)
-            if self.target is None
-            else self._target_visit(dag, wire_map)
+            check_gate_direction_target(dag, self.target)
+            if self.target
+            else check_gate_direction_coupling(dag, set(self.coupling_map.get_edges()))
         )
diff --git a/test/python/transpiler/test_check_gate_direction.py b/test/python/transpiler/test_check_gate_direction.py
index 0743f4c04cfc..efd38af16634 100644
--- a/test/python/transpiler/test_check_gate_direction.py
+++ b/test/python/transpiler/test_check_gate_direction.py
@@ -72,13 +72,13 @@ def test_true_direction(self):
 
     def test_true_direction_in_same_layer(self):
         """Two CXs distance_qubits 1 to each other, in the same layer
-        qr0:--(+)--
+        qr0:---.--
                |
-        qr1:---.---
+        qr1:--(+)---
 
-        qr2:--(+)--
+        qr2:---.---
                |
-        qr3:---.---
+        qr3:--(+)--
 
         CouplingMap map: [0]->[1]->[2]->[3]
         """
@@ -96,9 +96,9 @@ def test_true_direction_in_same_layer(self):
 
     def test_wrongly_mapped(self):
         """Needs [0]-[1] in a [0]--[2]--[1]
-        qr0:--(+)--
+        qr0:---.---
                |
-        qr1:---.---
+        qr1:--(+)--
 
         CouplingMap map: [0]->[2]->[1]
         """
@@ -115,11 +115,11 @@ def test_wrongly_mapped(self):
 
     def test_true_direction_undirected(self):
         """Mapped but with wrong direction
-        qr0:--(+)-[H]--.--
+        qr0:---.--[H]-(+)-
                |       |
-        qr1:---.-------|--
+        qr1:--(+)------|--
                        |
-        qr2:----------(+)-
+        qr2:-----------.--
 
         CouplingMap map: [1]<-[0]->[2]
         """
@@ -138,13 +138,13 @@ def test_true_direction_undirected(self):
 
     def test_false_direction_in_same_layer_undirected(self):
         """Two CXs in the same layer, but one is wrongly directed
-        qr0:--(+)--
+        qr0:---.---
                |
-        qr1:---.---
+        qr1:--(+)--
 
-        qr2:---.---
+        qr2:--(+)--
                |
-        qr3:--(+)--
+        qr3:---.---
 
         CouplingMap map: [0]->[1]->[2]->[3]
         """

From 3aa58cc2ab8bc0c4e600dbfe9c01c6ce4872ec0d Mon Sep 17 00:00:00 2001
From: Jake Lishman <jake.lishman@ibm.com>
Date: Mon, 9 Sep 2024 09:49:41 +0100
Subject: [PATCH 61/85] Add equivalence-library rules between `rzz` and `cp`
 (#13019)

* Add equivalence-library rules between `rzz` and `cp`

These gates are locally equivalence (as are all the Ising-interaction
gates), and this simple additional rule lets things like QFT, which are
defined by Qiskit's default constructor in terms of `cp`, get converted
into `rzz` or `rzx`.

One `ControlledGate` test needed a case removing, because the underlying
control mechanism now works correctly.

* Rewrite release note
---
 .../standard_gates/equivalence_library.py     | 43 +++++++++++++++++++
 ...hase-rzz-equivalence-e8afc37b71a74366.yaml | 17 ++++++++
 test/python/circuit/test_controlled_gate.py   |  1 -
 3 files changed, 60 insertions(+), 1 deletion(-)
 create mode 100644 releasenotes/notes/cphase-rzz-equivalence-e8afc37b71a74366.yaml

diff --git a/qiskit/circuit/library/standard_gates/equivalence_library.py b/qiskit/circuit/library/standard_gates/equivalence_library.py
index c4619ca27858..93e772ff842d 100644
--- a/qiskit/circuit/library/standard_gates/equivalence_library.py
+++ b/qiskit/circuit/library/standard_gates/equivalence_library.py
@@ -189,6 +189,21 @@ def _cnot_rxx_decompose(plus_ry: bool = True, plus_rxx: bool = True):
 cphase_to_cu1.append(CU1Gate(theta), [0, 1])
 _sel.add_equivalence(CPhaseGate(theta), cphase_to_cu1)
 
+# CPhaseGate
+#
+#                  global phase: ϴ/4
+#                                  ┌─────────┐
+#  q_0: ─■────     q_0: ─■─────────┤ Rz(ϴ/2) ├
+#        │P(ϴ)  ≡        │ZZ(-ϴ/2) ├─────────┤
+#  q_1: ─■────     q_1: ─■─────────┤ Rz(ϴ/2) ├
+#                                  └─────────┘
+theta = Parameter("theta")
+cphase_to_rzz = QuantumCircuit(2, global_phase=theta / 4)
+cphase_to_rzz.rzz(-theta / 2, 0, 1)
+cphase_to_rzz.rz(theta / 2, 0)
+cphase_to_rzz.rz(theta / 2, 1)
+_sel.add_equivalence(CPhaseGate(theta), cphase_to_rzz)
+
 # RGate
 #
 #    ┌────────┐        ┌───────────────────────┐
@@ -394,6 +409,19 @@ def _cnot_rxx_decompose(plus_ry: bool = True, plus_rxx: bool = True):
     def_rzx.append(inst, qargs, cargs)
 _sel.add_equivalence(RZXGate(theta), def_rzx)
 
+# RZXGate to RZZGate
+#      ┌─────────┐
+# q_0: ┤0        ├     q_0: ──────■───────────
+#      │  Rzx(ϴ) │  ≡       ┌───┐ │ZZ(ϴ) ┌───┐
+# q_1: ┤1        ├     q_1: ┤ H ├─■──────┤ H ├
+#      └─────────┘          └───┘        └───┘
+theta = Parameter("theta")
+rzx_to_rzz = QuantumCircuit(2)
+rzx_to_rzz.h(1)
+rzx_to_rzz.rzz(theta, 0, 1)
+rzx_to_rzz.h(1)
+_sel.add_equivalence(RZXGate(theta), rzx_to_rzz)
+
 
 # RYGate
 #
@@ -654,6 +682,21 @@ def _cnot_rxx_decompose(plus_ry: bool = True, plus_rxx: bool = True):
 rzz_to_rzx.h(1)
 _sel.add_equivalence(RZZGate(theta), rzz_to_rzx)
 
+# RZZ to CPhase
+#
+#                 global phase: ϴ/2
+#                                ┌───────┐
+#  q_0: ─■─────   q_0: ─■────────┤ Rz(ϴ) ├
+#        │ZZ(ϴ) ≡       │P(-2*ϴ) ├───────┤
+#  q_1: ─■─────   q_1: ─■────────┤ Rz(ϴ) ├
+#                                └───────┘
+theta = Parameter("theta")
+rzz_to_cphase = QuantumCircuit(2, global_phase=theta / 2)
+rzz_to_cphase.cp(-theta * 2, 0, 1)
+rzz_to_cphase.rz(theta, 0)
+rzz_to_cphase.rz(theta, 1)
+_sel.add_equivalence(RZZGate(theta), rzz_to_cphase)
+
 # RZZ to RYY
 q = QuantumRegister(2, "q")
 theta = Parameter("theta")
diff --git a/releasenotes/notes/cphase-rzz-equivalence-e8afc37b71a74366.yaml b/releasenotes/notes/cphase-rzz-equivalence-e8afc37b71a74366.yaml
new file mode 100644
index 000000000000..9f4d9d384172
--- /dev/null
+++ b/releasenotes/notes/cphase-rzz-equivalence-e8afc37b71a74366.yaml
@@ -0,0 +1,17 @@
+---
+features_circuits:
+  - |
+    The standard equivalence library (:data:`.SessionEquivalenceLibrary`) now has rules that can
+    directly convert between Qiskit's standard-library 2q continuous Ising-type interactions (e.g.
+    :class:`.CPhaseGate`, :class:`.RZZGate`, :class:`.RZXGate`, and so on) using local equivalence
+    relations.  Previously, several of these conversions would go via a 2-CX form, which resulted
+    in less efficient circuit generation.
+
+    .. note::
+
+      In general, the :class:`.BasisTranslator` is not guaranteed to find the "best" equivalence
+      relation for a given :class:`.Target`, but will always find an equivalence if one exists.  We
+      rely on more expensive resynthesis and gate-optimization passes in the transpiler to improve
+      the output.  These passes are currently not as effective for basis sets with a continuously
+      parametrized two-qubit interaction as they are for discrete super-controlled two-qubit
+      interactions.
diff --git a/test/python/circuit/test_controlled_gate.py b/test/python/circuit/test_controlled_gate.py
index a517d5d1e4a4..03a041355b87 100644
--- a/test/python/circuit/test_controlled_gate.py
+++ b/test/python/circuit/test_controlled_gate.py
@@ -1438,7 +1438,6 @@ def test_control_zero_operand_gate(self, num_ctrl_qubits):
     @data(
         RXGate,
         RYGate,
-        RZGate,
         RXXGate,
         RYYGate,
         RZXGate,

From 2ef371ae0d159a6dfd643805f3e5e5fdec37ab88 Mon Sep 17 00:00:00 2001
From: Matthew Treinish <mtreinish@kortar.org>
Date: Mon, 9 Sep 2024 09:09:24 -0400
Subject: [PATCH 62/85] Fully port Split2QUnitaries to rust (#13025)

* Fully port Split2QUnitaries to rust

This commit builds off of #13013 and the other data model in Rust
infrastructure and migrates the InverseCancellation pass to
operate fully in Rust. The full path of the transpiler pass now never
leaves Rust until it has finished modifying the DAGCircuit. There is
still some python interaction necessary to handle parts of the data
model that are still in Python, mainly for creating `UnitaryGate`
instances and `ParameterExpression` for global phase. But otherwise
the entirety of the pass operates in rust now.

This is just a first pass at the migration here, it moves the pass to
use loops in rust. The next steps here are to look at operating
the pass in parallel. There is no data dependency between the
optimizations being done for different gates so we should be able to
increase the throughput of the pass by leveraging multithreading to
handle each gate in parallel. This commit does not attempt
this though, because of the Python dependency and also the data
structures around gates and the dag aren't really setup for
multithreading yet and there likely will need to be some work to
support that.

Part of #12208

* Update pass logic with changes from #13095

Some of the logic inside the Split2QUnitaries pass was updated in a
recently merged PR. This commit makes those changes so the rust
implementation matches the current state of the previous python version.

* Use op_nodes() instead of topological_op_nodes()

* Use Fn trait instead of FnMut for callback

We don't need the callback to be mutable currently so relax the trait to
just be `Fn` instead of `FnMut`. If we have a need for a mutable
environment callback in the future we can change this easily enough
without any issues.

* Avoid extra edge operations in replace_on_incoming_qubits

* Rename function
---
 crates/accelerate/src/lib.rs                  |  1 +
 crates/accelerate/src/split_2q_unitaries.rs   | 75 +++++++++++++++++++
 crates/accelerate/src/two_qubit_decompose.rs  | 12 +--
 crates/circuit/src/dag_circuit.rs             | 71 +++++++++++++++++-
 crates/circuit/src/imports.rs                 |  4 +
 crates/pyext/src/lib.rs                       |  8 +-
 qiskit/__init__.py                            |  1 +
 .../passes/optimization/split_2q_unitaries.py | 44 +----------
 8 files changed, 164 insertions(+), 52 deletions(-)
 create mode 100644 crates/accelerate/src/split_2q_unitaries.rs

diff --git a/crates/accelerate/src/lib.rs b/crates/accelerate/src/lib.rs
index 916aeeb8351c..9e391e0a9030 100644
--- a/crates/accelerate/src/lib.rs
+++ b/crates/accelerate/src/lib.rs
@@ -35,6 +35,7 @@ pub mod results;
 pub mod sabre;
 pub mod sampled_exp_val;
 pub mod sparse_pauli_op;
+pub mod split_2q_unitaries;
 pub mod star_prerouting;
 pub mod stochastic_swap;
 pub mod synthesis;
diff --git a/crates/accelerate/src/split_2q_unitaries.rs b/crates/accelerate/src/split_2q_unitaries.rs
new file mode 100644
index 000000000000..83ab94bf301d
--- /dev/null
+++ b/crates/accelerate/src/split_2q_unitaries.rs
@@ -0,0 +1,75 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// 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.
+
+use pyo3::prelude::*;
+use rustworkx_core::petgraph::stable_graph::NodeIndex;
+
+use qiskit_circuit::circuit_instruction::OperationFromPython;
+use qiskit_circuit::dag_circuit::{DAGCircuit, NodeType, Wire};
+use qiskit_circuit::imports::UNITARY_GATE;
+use qiskit_circuit::operations::{Operation, Param};
+
+use crate::two_qubit_decompose::{Specialization, TwoQubitWeylDecomposition};
+
+#[pyfunction]
+pub fn split_2q_unitaries(
+    py: Python,
+    dag: &mut DAGCircuit,
+    requested_fidelity: f64,
+) -> PyResult<()> {
+    let nodes: Vec<NodeIndex> = dag.op_nodes(false).collect();
+    for node in nodes {
+        if let NodeType::Operation(inst) = &dag.dag[node] {
+            let qubits = dag.get_qargs(inst.qubits).to_vec();
+            let matrix = inst.op.matrix(inst.params_view());
+            // 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 qubits.len() != 2 || inst.op.name() != "unitary" {
+                continue;
+            }
+            let decomp = TwoQubitWeylDecomposition::new_inner(
+                matrix.unwrap().view(),
+                Some(requested_fidelity),
+                None,
+            )?;
+            if matches!(decomp.specialization, Specialization::IdEquiv) {
+                let k1r_arr = decomp.K1r(py);
+                let k1l_arr = decomp.K1l(py);
+                let k1r_gate = UNITARY_GATE.get_bound(py).call1((k1r_arr,))?;
+                let k1l_gate = UNITARY_GATE.get_bound(py).call1((k1l_arr,))?;
+                let insert_fn = |edge: &Wire| -> PyResult<OperationFromPython> {
+                    if let Wire::Qubit(qubit) = edge {
+                        if *qubit == qubits[0] {
+                            k1r_gate.extract()
+                        } else {
+                            k1l_gate.extract()
+                        }
+                    } else {
+                        unreachable!("This will only be called on ops with no classical wires.");
+                    }
+                };
+                dag.replace_node_with_1q_ops(py, node, insert_fn)?;
+                dag.add_global_phase(py, &Param::Float(decomp.global_phase))?;
+            }
+            // TODO: also look into splitting on Specialization::Swap and just
+            // swap the virtual qubits. Doing this we will need to update the
+            // permutation like in ElidePermutations
+        }
+    }
+    Ok(())
+}
+
+pub fn split_2q_unitaries_mod(m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_wrapped(wrap_pyfunction!(split_2q_unitaries))?;
+    Ok(())
+}
diff --git a/crates/accelerate/src/two_qubit_decompose.rs b/crates/accelerate/src/two_qubit_decompose.rs
index 2c745b199e9e..92ad4724682f 100644
--- a/crates/accelerate/src/two_qubit_decompose.rs
+++ b/crates/accelerate/src/two_qubit_decompose.rs
@@ -341,7 +341,7 @@ const DEFAULT_FIDELITY: f64 = 1.0 - 1.0e-9;
 
 #[derive(Clone, Debug, Copy)]
 #[pyclass(module = "qiskit._accelerate.two_qubit_decompose")]
-enum Specialization {
+pub enum Specialization {
     General,
     IdEquiv,
     SWAPEquiv,
@@ -410,13 +410,13 @@ pub struct TwoQubitWeylDecomposition {
     #[pyo3(get)]
     c: f64,
     #[pyo3(get)]
-    global_phase: f64,
+    pub global_phase: f64,
     K1l: Array2<Complex64>,
     K2l: Array2<Complex64>,
     K1r: Array2<Complex64>,
     K2r: Array2<Complex64>,
     #[pyo3(get)]
-    specialization: Specialization,
+    pub specialization: Specialization,
     default_euler_basis: EulerBasis,
     #[pyo3(get)]
     requested_fidelity: Option<f64>,
@@ -476,7 +476,7 @@ impl TwoQubitWeylDecomposition {
 
     /// Instantiate a new TwoQubitWeylDecomposition with rust native
     /// data structures
-    fn new_inner(
+    pub fn new_inner(
         unitary_matrix: ArrayView2<Complex64>,
 
         fidelity: Option<f64>,
@@ -1021,13 +1021,13 @@ impl TwoQubitWeylDecomposition {
 
     #[allow(non_snake_case)]
     #[getter]
-    fn K1l(&self, py: Python) -> PyObject {
+    pub fn K1l(&self, py: Python) -> PyObject {
         self.K1l.to_pyarray_bound(py).into()
     }
 
     #[allow(non_snake_case)]
     #[getter]
-    fn K1r(&self, py: Python) -> PyObject {
+    pub fn K1r(&self, py: Python) -> PyObject {
         self.K1r.to_pyarray_bound(py).into()
     }
 
diff --git a/crates/circuit/src/dag_circuit.rs b/crates/circuit/src/dag_circuit.rs
index 5b9769b4d19e..0b5a43c1eb4b 100644
--- a/crates/circuit/src/dag_circuit.rs
+++ b/crates/circuit/src/dag_circuit.rs
@@ -5254,7 +5254,7 @@ impl DAGCircuit {
         Ok(nodes.into_iter())
     }
 
-    fn topological_op_nodes(&self) -> PyResult<impl Iterator<Item = NodeIndex> + '_> {
+    pub fn topological_op_nodes(&self) -> PyResult<impl Iterator<Item = NodeIndex> + '_> {
         Ok(self.topological_nodes()?.filter(|node: &NodeIndex| {
             matches!(self.dag.node_weight(*node), Some(NodeType::Operation(_)))
         }))
@@ -6285,6 +6285,75 @@ impl DAGCircuit {
         }
     }
 
+    /// Replace a node with individual operations from a provided callback
+    /// function on each qubit of that node.
+    #[allow(unused_variables)]
+    pub fn replace_node_with_1q_ops<F>(
+        &mut self,
+        py: Python, // Unused if cache_pygates isn't enabled
+        node: NodeIndex,
+        insert: F,
+    ) -> PyResult<()>
+    where
+        F: Fn(&Wire) -> PyResult<OperationFromPython>,
+    {
+        let mut edge_list: Vec<(NodeIndex, NodeIndex, Wire)> = Vec::with_capacity(2);
+        for (source, in_weight) in self
+            .dag
+            .edges_directed(node, Incoming)
+            .map(|x| (x.source(), x.weight()))
+        {
+            for (target, out_weight) in self
+                .dag
+                .edges_directed(node, Outgoing)
+                .map(|x| (x.target(), x.weight()))
+            {
+                if in_weight == out_weight {
+                    edge_list.push((source, target, in_weight.clone()));
+                }
+            }
+        }
+        for (source, target, weight) in edge_list {
+            let new_op = insert(&weight)?;
+            self.increment_op(new_op.operation.name());
+            let qubits = if let Wire::Qubit(qubit) = weight {
+                vec![qubit]
+            } else {
+                panic!("This method only works if the gate being replaced has no classical incident wires")
+            };
+            #[cfg(feature = "cache_pygates")]
+            let py_op = match new_op.operation.view() {
+                OperationRef::Standard(_) => OnceCell::new(),
+                OperationRef::Gate(gate) => OnceCell::from(gate.gate.clone_ref(py)),
+                OperationRef::Instruction(instruction) => {
+                    OnceCell::from(instruction.instruction.clone_ref(py))
+                }
+                OperationRef::Operation(op) => OnceCell::from(op.operation.clone_ref(py)),
+            };
+            let inst = PackedInstruction {
+                op: new_op.operation,
+                qubits: self.qargs_interner.insert_owned(qubits),
+                clbits: self.cargs_interner.get_default(),
+                params: (!new_op.params.is_empty()).then(|| Box::new(new_op.params)),
+                extra_attrs: new_op.extra_attrs,
+                #[cfg(feature = "cache_pygates")]
+                py_op: py_op,
+            };
+            let new_index = self.dag.add_node(NodeType::Operation(inst));
+            self.dag.add_edge(source, new_index, weight.clone());
+            self.dag.add_edge(new_index, target, weight);
+        }
+
+        match self.dag.remove_node(node) {
+            Some(NodeType::Operation(packed)) => {
+                let op_name = packed.op.name();
+                self.decrement_op(op_name);
+            }
+            _ => panic!("Must be called with valid operation node"),
+        }
+        Ok(())
+    }
+
     pub fn add_global_phase(&mut self, py: Python, value: &Param) -> PyResult<()> {
         match value {
             Param::Obj(_) => {
diff --git a/crates/circuit/src/imports.rs b/crates/circuit/src/imports.rs
index 588471546273..a8f6d9562559 100644
--- a/crates/circuit/src/imports.rs
+++ b/crates/circuit/src/imports.rs
@@ -109,6 +109,10 @@ pub static SWITCH_CASE_OP_CHECK: ImportOnceCell =
 pub static FOR_LOOP_OP_CHECK: ImportOnceCell =
     ImportOnceCell::new("qiskit.dagcircuit.dagnode", "_for_loop_eq");
 pub static UUID: ImportOnceCell = ImportOnceCell::new("uuid", "UUID");
+pub static UNITARY_GATE: ImportOnceCell = ImportOnceCell::new(
+    "qiskit.circuit.library.generalized_gates.unitary",
+    "UnitaryGate",
+);
 
 /// A mapping from the enum variant in crate::operations::StandardGate to the python
 /// module path and class name to import it. This is used to populate the conversion table
diff --git a/crates/pyext/src/lib.rs b/crates/pyext/src/lib.rs
index 96b5e84a9cbe..03bd0202dae4 100644
--- a/crates/pyext/src/lib.rs
+++ b/crates/pyext/src/lib.rs
@@ -22,9 +22,10 @@ use qiskit_accelerate::{
     optimize_1q_gates::optimize_1q_gates, pauli_exp_val::pauli_expval,
     remove_diagonal_gates_before_measure::remove_diagonal_gates_before_measure, results::results,
     sabre::sabre, sampled_exp_val::sampled_exp_val, sparse_pauli_op::sparse_pauli_op,
-    star_prerouting::star_prerouting, stochastic_swap::stochastic_swap, synthesis::synthesis,
-    target_transpiler::target, two_qubit_decompose::two_qubit_decompose, uc_gate::uc_gate,
-    utils::utils, vf2_layout::vf2_layout,
+    split_2q_unitaries::split_2q_unitaries_mod, star_prerouting::star_prerouting,
+    stochastic_swap::stochastic_swap, synthesis::synthesis, target_transpiler::target,
+    two_qubit_decompose::two_qubit_decompose, uc_gate::uc_gate, utils::utils,
+    vf2_layout::vf2_layout,
 };
 
 #[inline(always)]
@@ -65,6 +66,7 @@ fn _accelerate(m: &Bound<PyModule>) -> PyResult<()> {
     add_submodule(m, sabre, "sabre")?;
     add_submodule(m, sampled_exp_val, "sampled_exp_val")?;
     add_submodule(m, sparse_pauli_op, "sparse_pauli_op")?;
+    add_submodule(m, split_2q_unitaries_mod, "split_2q_unitaries")?;
     add_submodule(m, star_prerouting, "star_prerouting")?;
     add_submodule(m, stochastic_swap, "stochastic_swap")?;
     add_submodule(m, target, "target")?;
diff --git a/qiskit/__init__.py b/qiskit/__init__.py
index f731465beecb..29e2b8ba5c11 100644
--- a/qiskit/__init__.py
+++ b/qiskit/__init__.py
@@ -92,6 +92,7 @@
 sys.modules["qiskit._accelerate.commutation_checker"] = _accelerate.commutation_checker
 sys.modules["qiskit._accelerate.commutation_analysis"] = _accelerate.commutation_analysis
 sys.modules["qiskit._accelerate.synthesis.linear_phase"] = _accelerate.synthesis.linear_phase
+sys.modules["qiskit._accelerate.split_2q_unitaries"] = _accelerate.split_2q_unitaries
 sys.modules["qiskit._accelerate.gate_direction"] = _accelerate.gate_direction
 sys.modules["qiskit._accelerate.inverse_cancellation"] = _accelerate.inverse_cancellation
 sys.modules["qiskit._accelerate.check_map"] = _accelerate.check_map
diff --git a/qiskit/transpiler/passes/optimization/split_2q_unitaries.py b/qiskit/transpiler/passes/optimization/split_2q_unitaries.py
index 1ca53c6c31d2..f6958a00a4c1 100644
--- a/qiskit/transpiler/passes/optimization/split_2q_unitaries.py
+++ b/qiskit/transpiler/passes/optimization/split_2q_unitaries.py
@@ -13,11 +13,8 @@
 """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.circuit.quantumcircuitdata import CircuitInstruction
 from qiskit.dagcircuit.dagcircuit import DAGCircuit
-from qiskit.dagcircuit.dagnode import DAGOpNode
-from qiskit.circuit.library.generalized_gates import UnitaryGate
-from qiskit.synthesis.two_qubit.two_qubit_decompose import TwoQubitWeylDecomposition
+from qiskit._accelerate.split_2q_unitaries import split_2q_unitaries
 
 
 class Split2QUnitaries(TransformationPass):
@@ -39,42 +36,5 @@ def __init__(self, fidelity: float = 1.0 - 1e-16):
 
     def run(self, dag: DAGCircuit) -> DAGCircuit:
         """Run the Split2QUnitaries pass on `dag`."""
-
-        for node in dag.topological_op_nodes():
-            # 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.matrix, fidelity=self.requested_fidelity)
-            if (
-                decomp._inner_decomposition.specialization
-                == TwoQubitWeylDecomposition._specializations.IdEquiv
-            ):
-                new_dag = DAGCircuit()
-                new_dag.add_qubits(node.qargs)
-
-                ur = decomp.K1r
-                ur_node = DAGOpNode.from_instruction(
-                    CircuitInstruction(UnitaryGate(ur), qubits=(node.qargs[0],))
-                )
-
-                ul = decomp.K1l
-                ul_node = DAGOpNode.from_instruction(
-                    CircuitInstruction(UnitaryGate(ul), qubits=(node.qargs[1],))
-                )
-                new_dag._apply_op_node_back(ur_node)
-                new_dag._apply_op_node_back(ul_node)
-                new_dag.global_phase = decomp.global_phase
-                dag.substitute_node_with_dag(node, new_dag)
-            elif (
-                decomp._inner_decomposition.specialization
-                == TwoQubitWeylDecomposition._specializations.SWAPEquiv
-            ):
-                # TODO maybe also look into swap-gate-like gates? Things to consider:
-                #   * As the qubit mapping may change, we'll always need to build a new dag in this pass
-                #   * There may not be many swap-gate-like gates in an arbitrary input circuit
-                #   * Removing swap gates from a user-routed input circuit here is unexpected
-                pass
+        split_2q_unitaries(dag, self.requested_fidelity)
         return dag

From d14eb9c4829268cd531c4a6ff68f5a297dc84b3c Mon Sep 17 00:00:00 2001
From: Julien Gacon <jules.gacon@googlemail.com>
Date: Tue, 10 Sep 2024 16:10:24 +0200
Subject: [PATCH 63/85] Fix skipping of slow tests (#13119)

---
 test/utils/decorators.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/utils/decorators.py b/test/utils/decorators.py
index d3abb37bbef1..1b1df0efc9c1 100644
--- a/test/utils/decorators.py
+++ b/test/utils/decorators.py
@@ -33,7 +33,7 @@ def slow_test(func):
 
     @functools.wraps(func)
     def _wrapper(*args, **kwargs):
-        if "run_slow" in os.environ.get("QISKIT_TESTS", ""):
+        if "run_slow" not in os.environ.get("QISKIT_TESTS", ""):
             raise unittest.SkipTest("Skipping slow tests")
         return func(*args, **kwargs)
 

From 1962704cf120499cee5f017eb21d3e217353c4d7 Mon Sep 17 00:00:00 2001
From: Julien Gacon <jules.gacon@googlemail.com>
Date: Tue, 10 Sep 2024 16:22:33 +0200
Subject: [PATCH 64/85] Fix creation of registers in synthesis methods (#13086)

* add qregs to output circuits

* never develop while not on up-to-date main

* one shan't commit faster than ones IDE can run black

* avoid compose
---
 qiskit/circuit/quantumcircuit.py              | 53 ++++++++++++++-----
 .../clifford/clifford_decompose_bm.py         |  2 +-
 .../clifford/clifford_decompose_greedy.py     |  2 +-
 qiskit/synthesis/linear/cnot_synth.py         |  2 +-
 qiskit/synthesis/linear_phase/cz_depth_lnn.py |  4 +-
 .../one_qubit/one_qubit_decompose.py          |  3 +-
 .../synthesis/permutation/permutation_full.py |  4 +-
 .../synthesis/permutation/permutation_lnn.py  |  4 +-
 .../permutation/permutation_reverse_lnn.py    |  4 +-
 .../two_qubit/two_qubit_decompose.py          |  4 +-
 .../fix-synth-qregs-7662681c0ff02511.yaml     |  7 +++
 .../operators/symplectic/test_clifford.py     | 17 ++++++
 12 files changed, 81 insertions(+), 25 deletions(-)
 create mode 100644 releasenotes/notes/fix-synth-qregs-7662681c0ff02511.yaml

diff --git a/qiskit/circuit/quantumcircuit.py b/qiskit/circuit/quantumcircuit.py
index ebc63511ca7b..566a6fef9f70 100644
--- a/qiskit/circuit/quantumcircuit.py
+++ b/qiskit/circuit/quantumcircuit.py
@@ -1152,17 +1152,41 @@ def __init__(
         """The unit that :attr:`duration` is specified in."""
         self.metadata = {} if metadata is None else metadata
         """Arbitrary user-defined metadata for the circuit.
-
+ 
         Qiskit will not examine the content of this mapping, but it will pass it through the
         transpiler and reattach it to the output, so you can track your own metadata."""
 
     @classmethod
-    def _from_circuit_data(cls, data: CircuitData) -> typing.Self:
+    def _from_circuit_data(cls, data: CircuitData, add_regs: bool = False) -> typing.Self:
         """A private constructor from rust space circuit data."""
         out = QuantumCircuit()
+
+        if data.num_qubits > 0:
+            if add_regs:
+                qr = QuantumRegister(name="q", bits=data.qubits)
+                out.qregs = [qr]
+                out._qubit_indices = {
+                    bit: BitLocations(index, [(qr, index)]) for index, bit in enumerate(data.qubits)
+                }
+            else:
+                out._qubit_indices = {
+                    bit: BitLocations(index, []) for index, bit in enumerate(data.qubits)
+                }
+
+        if data.num_clbits > 0:
+            if add_regs:
+                cr = ClassicalRegister(name="c", bits=data.clbits)
+                out.cregs = [cr]
+                out._clbit_indices = {
+                    bit: BitLocations(index, [(cr, index)]) for index, bit in enumerate(data.clbits)
+                }
+            else:
+                out._clbit_indices = {
+                    bit: BitLocations(index, []) for index, bit in enumerate(data.clbits)
+                }
+
         out._data = data
-        out._qubit_indices = {bit: BitLocations(index, []) for index, bit in enumerate(data.qubits)}
-        out._clbit_indices = {bit: BitLocations(index, []) for index, bit in enumerate(data.clbits)}
+
         return out
 
     @staticmethod
@@ -3013,16 +3037,7 @@ def add_register(self, *regs: Register | int | Sequence[Bit]) -> None:
                         self._ancillas.append(bit)
 
             if isinstance(register, QuantumRegister):
-                self.qregs.append(register)
-
-                for idx, bit in enumerate(register):
-                    if bit in self._qubit_indices:
-                        self._qubit_indices[bit].registers.append((register, idx))
-                    else:
-                        self._data.add_qubit(bit)
-                        self._qubit_indices[bit] = BitLocations(
-                            self._data.num_qubits - 1, [(register, idx)]
-                        )
+                self._add_qreg(register)
 
             elif isinstance(register, ClassicalRegister):
                 self.cregs.append(register)
@@ -3041,6 +3056,16 @@ def add_register(self, *regs: Register | int | Sequence[Bit]) -> None:
             else:
                 raise CircuitError("expected a register")
 
+    def _add_qreg(self, qreg: QuantumRegister) -> None:
+        self.qregs.append(qreg)
+
+        for idx, bit in enumerate(qreg):
+            if bit in self._qubit_indices:
+                self._qubit_indices[bit].registers.append((qreg, idx))
+            else:
+                self._data.add_qubit(bit)
+                self._qubit_indices[bit] = BitLocations(self._data.num_qubits - 1, [(qreg, idx)])
+
     def add_bits(self, bits: Iterable[Bit]) -> None:
         """Add Bits to the circuit."""
         duplicate_bits = {
diff --git a/qiskit/synthesis/clifford/clifford_decompose_bm.py b/qiskit/synthesis/clifford/clifford_decompose_bm.py
index ac4923446bcd..5ead6945eba2 100644
--- a/qiskit/synthesis/clifford/clifford_decompose_bm.py
+++ b/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
diff --git a/qiskit/synthesis/clifford/clifford_decompose_greedy.py b/qiskit/synthesis/clifford/clifford_decompose_greedy.py
index 0a679a8a7a6f..9766efe4aa8f 100644
--- a/qiskit/synthesis/clifford/clifford_decompose_greedy.py
+++ b/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
diff --git a/qiskit/synthesis/linear/cnot_synth.py b/qiskit/synthesis/linear/cnot_synth.py
index f900ff86d17e..bb3d9c6896ff 100644
--- a/qiskit/synthesis/linear/cnot_synth.py
+++ b/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)
diff --git a/qiskit/synthesis/linear_phase/cz_depth_lnn.py b/qiskit/synthesis/linear_phase/cz_depth_lnn.py
index 419aec806f2e..d7dd071956e0 100644
--- a/qiskit/synthesis/linear_phase/cz_depth_lnn.py
+++ b/qiskit/synthesis/linear_phase/cz_depth_lnn.py
@@ -53,4 +53,6 @@ def synth_cz_depth_line_mr(mat: np.ndarray) -> QuantumCircuit:
     """
 
     # Call Rust implementaton
-    return QuantumCircuit._from_circuit_data(synth_cz_depth_line_mr_inner(mat.astype(bool)))
+    return QuantumCircuit._from_circuit_data(
+        synth_cz_depth_line_mr_inner(mat.astype(bool)), add_regs=True
+    )
diff --git a/qiskit/synthesis/one_qubit/one_qubit_decompose.py b/qiskit/synthesis/one_qubit/one_qubit_decompose.py
index f60f20f9524e..60da6ed6e82b 100644
--- a/qiskit/synthesis/one_qubit/one_qubit_decompose.py
+++ b/qiskit/synthesis/one_qubit/one_qubit_decompose.py
@@ -224,7 +224,8 @@ def _decompose(self, unitary, simplify=True, atol=DEFAULT_ATOL):
         return QuantumCircuit._from_circuit_data(
             euler_one_qubit_decomposer.unitary_to_circuit(
                 unitary, [self.basis], 0, None, simplify, atol
-            )
+            ),
+            add_regs=True,
         )
 
     @property
diff --git a/qiskit/synthesis/permutation/permutation_full.py b/qiskit/synthesis/permutation/permutation_full.py
index 2fd892a0427e..7dd5ae99dc4c 100644
--- a/qiskit/synthesis/permutation/permutation_full.py
+++ b/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)
diff --git a/qiskit/synthesis/permutation/permutation_lnn.py b/qiskit/synthesis/permutation/permutation_lnn.py
index d5da6929463c..5f1bfbeaa1a8 100644
--- a/qiskit/synthesis/permutation/permutation_lnn.py
+++ b/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
+    )
diff --git a/qiskit/synthesis/permutation/permutation_reverse_lnn.py b/qiskit/synthesis/permutation/permutation_reverse_lnn.py
index f214fd7ce294..ccc820d97e62 100644
--- a/qiskit/synthesis/permutation/permutation_reverse_lnn.py
+++ b/qiskit/synthesis/permutation/permutation_reverse_lnn.py
@@ -88,4 +88,6 @@ def synth_permutation_reverse_lnn_kms(num_qubits: int) -> QuantumCircuit:
     """
 
     # Call Rust implementation
-    return QuantumCircuit._from_circuit_data(synth_permutation_reverse_lnn_kms_inner(num_qubits))
+    return QuantumCircuit._from_circuit_data(
+        synth_permutation_reverse_lnn_kms_inner(num_qubits), add_regs=True
+    )
diff --git a/qiskit/synthesis/two_qubit/two_qubit_decompose.py b/qiskit/synthesis/two_qubit/two_qubit_decompose.py
index 633de3a64f78..0e3427773387 100644
--- a/qiskit/synthesis/two_qubit/two_qubit_decompose.py
+++ b/qiskit/synthesis/two_qubit/two_qubit_decompose.py
@@ -233,7 +233,7 @@ def circuit(
         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."""
@@ -672,7 +672,7 @@ def __call__(
                     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),
diff --git a/releasenotes/notes/fix-synth-qregs-7662681c0ff02511.yaml b/releasenotes/notes/fix-synth-qregs-7662681c0ff02511.yaml
new file mode 100644
index 000000000000..d838032ffaf9
--- /dev/null
+++ b/releasenotes/notes/fix-synth-qregs-7662681c0ff02511.yaml
@@ -0,0 +1,7 @@
+---
+fixes:
+  - |
+    Fixed a bug where various synthesis methods created circuits without quantum or
+    classical registers. This also affected functions that internally used the synthesis
+    methods, such as :meth:`.Clifford.to_circuit`.
+    Fixed `#13041 <https://github.com/Qiskit/qiskit/issues/13041>`__.
diff --git a/test/python/quantum_info/operators/symplectic/test_clifford.py b/test/python/quantum_info/operators/symplectic/test_clifford.py
index 061348c78cdb..e78feaf3b78f 100644
--- a/test/python/quantum_info/operators/symplectic/test_clifford.py
+++ b/test/python/quantum_info/operators/symplectic/test_clifford.py
@@ -598,6 +598,23 @@ def test_to_circuit(self, num_qubits):
             # Convert back to clifford and check it is the same
             self.assertEqual(Clifford(decomp), target)
 
+    def test_to_circuit_manual(self):
+        """Test a manual comparison to a known circuit.
+
+        This also tests whether the resulting Clifford circuit has quantum registers, thereby
+        regression testing #13041.
+        """
+        # this is set to a circuit that remains the same under Clifford reconstruction
+        circuit = QuantumCircuit(2)
+        circuit.z(0)
+        circuit.h(0)
+        circuit.cx(0, 1)
+
+        cliff = Clifford(circuit)
+        reconstructed = cliff.to_circuit()
+
+        self.assertEqual(circuit, reconstructed)
+
     @combine(num_qubits=[1, 2, 3, 4, 5])
     def test_to_instruction(self, num_qubits):
         """Test to_instruction method"""

From 8929e12bab1cefb429eb1ea3b59a9f98a2b09c55 Mon Sep 17 00:00:00 2001
From: Julien Gacon <jules.gacon@googlemail.com>
Date: Tue, 10 Sep 2024 17:30:00 +0200
Subject: [PATCH 65/85] Fix the matrix representation of CUGate in Rust
 (#13121)

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>
---
 crates/circuit/src/gate_matrix.rs                    | 4 ++--
 releasenotes/notes/fix-cu-rust-6464b6893ecca1b3.yaml | 9 +++++++++
 test/python/circuit/test_rust_equivalence.py         | 4 ++--
 3 files changed, 13 insertions(+), 4 deletions(-)
 create mode 100644 releasenotes/notes/fix-cu-rust-6464b6893ecca1b3.yaml

diff --git a/crates/circuit/src/gate_matrix.rs b/crates/circuit/src/gate_matrix.rs
index a38783ef7e7f..6b04b8512fb0 100644
--- a/crates/circuit/src/gate_matrix.rs
+++ b/crates/circuit/src/gate_matrix.rs
@@ -387,12 +387,12 @@ pub fn cu_gate(theta: f64, phi: f64, lam: f64, gamma: f64) -> GateArray2Q {
             C_ZERO,
             c64(0., gamma).exp() * cos_theta,
             C_ZERO,
-            c64(0., gamma + phi).exp() * (-1.) * sin_theta,
+            c64(0., gamma + lam).exp() * (-1.) * sin_theta,
         ],
         [C_ZERO, C_ZERO, C_ONE, C_ZERO],
         [
             C_ZERO,
-            c64(0., gamma + lam).exp() * sin_theta,
+            c64(0., gamma + phi).exp() * sin_theta,
             C_ZERO,
             c64(0., gamma + phi + lam).exp() * cos_theta,
         ],
diff --git a/releasenotes/notes/fix-cu-rust-6464b6893ecca1b3.yaml b/releasenotes/notes/fix-cu-rust-6464b6893ecca1b3.yaml
new file mode 100644
index 000000000000..406d6052a1df
--- /dev/null
+++ b/releasenotes/notes/fix-cu-rust-6464b6893ecca1b3.yaml
@@ -0,0 +1,9 @@
+---
+fixes:
+  - |
+    Fixed the definition of the :class:`.CUGate` matrix in Rust-space. 
+    While this was not noticable while handling the :class:`.CUGate` purely on 
+    Python side, this had knock-on effects when transpiler passes were using the 
+    Rust representation, such as could happen in :class:`.Consolidate2qBlocks`.
+    Fixed `#13118 <https://github.com/Qiskit/qiskit/issues/13118>`__.
+
diff --git a/test/python/circuit/test_rust_equivalence.py b/test/python/circuit/test_rust_equivalence.py
index b6ec28f82e8d..db4f1441bea3 100644
--- a/test/python/circuit/test_rust_equivalence.py
+++ b/test/python/circuit/test_rust_equivalence.py
@@ -66,7 +66,7 @@ def test_definitions(self):
                 continue
 
             with self.subTest(name=name):
-                params = [pi] * standard_gate._num_params()
+                params = [0.1 * (i + 1) for i in range(standard_gate._num_params())]
                 py_def = gate_class.base_class(*params).definition
                 rs_def = standard_gate._get_definition(params)
                 if py_def is None:
@@ -141,7 +141,7 @@ def test_matrix(self):
                 continue
 
             with self.subTest(name=name):
-                params = [0.1] * standard_gate._num_params()
+                params = [0.1 * (i + 1) for i in range(standard_gate._num_params())]
                 py_def = gate_class.base_class(*params).to_matrix()
                 rs_def = standard_gate._to_matrix(params)
                 np.testing.assert_allclose(rs_def, py_def)

From 49b8a5fe9a980b976f027846ce4d7b8a0217e547 Mon Sep 17 00:00:00 2001
From: Sebastian Brandhofer <148463728+sbrandhsn@users.noreply.github.com>
Date: Tue, 10 Sep 2024 20:51:28 +0200
Subject: [PATCH 66/85] Oxidize commutative cancellation (#13091)

* fix

* fmt

* comments from code review

* comments from code review

* Update lib.rs

* Apply suggestions from code review

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>

* code review

* Fix rustfmt

* Don't change interface for DAGCircuit

Previously this PR was making the op_names field of the DAGCircuit
struct public so it was accessible to the new transpiler pass code.
However, this opened up the possibility of mutating the field by
mistake, instead this makes the field private again and adds a no-copy
method to get an immutable reference to the field. Additionally, there
were some interface changes made to one method in DAGCircuit that were
not needed anymore, which this reverts to minimize the diff.

* Remove last .first().unwrap()

---------

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>
---
 crates/accelerate/src/commutation_analysis.rs |   2 +-
 .../src/commutation_cancellation.rs           | 280 ++++++++++++++++++
 .../src/euler_one_qubit_decomposer.rs         |   2 +-
 crates/accelerate/src/lib.rs                  |   1 +
 crates/circuit/src/dag_circuit.rs             |  10 +
 crates/pyext/src/lib.rs                       |  14 +-
 qiskit/__init__.py                            |   1 +
 .../optimization/commutative_cancellation.py  | 161 +---------
 .../test_commutative_cancellation.py          |   5 +-
 test/python/transpiler/test_passmanager.py    |  10 +-
 10 files changed, 318 insertions(+), 168 deletions(-)
 create mode 100644 crates/accelerate/src/commutation_cancellation.rs

diff --git a/crates/accelerate/src/commutation_analysis.rs b/crates/accelerate/src/commutation_analysis.rs
index 08fa1dda5ec9..2da8cfce931e 100644
--- a/crates/accelerate/src/commutation_analysis.rs
+++ b/crates/accelerate/src/commutation_analysis.rs
@@ -50,7 +50,7 @@ const MAX_NUM_QUBITS: u32 = 3;
 ///     commutation_set = {0: [[0], [2, 3], [4], [1]]}
 ///     node_indices = {(0, 0): 0, (1, 0): 3, (2, 0): 1, (3, 0): 1, (4, 0): 2}
 ///
-fn analyze_commutations_inner(
+pub(crate) fn analyze_commutations_inner(
     py: Python,
     dag: &mut DAGCircuit,
     commutation_checker: &mut CommutationChecker,
diff --git a/crates/accelerate/src/commutation_cancellation.rs b/crates/accelerate/src/commutation_cancellation.rs
new file mode 100644
index 000000000000..dc2d4436d83a
--- /dev/null
+++ b/crates/accelerate/src/commutation_cancellation.rs
@@ -0,0 +1,280 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// 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.
+
+use std::f64::consts::PI;
+
+use hashbrown::{HashMap, HashSet};
+use pyo3::exceptions::PyRuntimeError;
+use pyo3::prelude::*;
+use pyo3::{pyfunction, pymodule, wrap_pyfunction, Bound, PyResult, Python};
+use rustworkx_core::petgraph::stable_graph::NodeIndex;
+use smallvec::{smallvec, SmallVec};
+
+use qiskit_circuit::dag_circuit::{DAGCircuit, NodeType, Wire};
+use qiskit_circuit::operations::StandardGate::{
+    CXGate, CYGate, CZGate, HGate, PhaseGate, RXGate, RZGate, SGate, TGate, U1Gate, XGate, YGate,
+    ZGate,
+};
+use qiskit_circuit::operations::{Operation, Param, StandardGate};
+use qiskit_circuit::Qubit;
+
+use crate::commutation_analysis::analyze_commutations_inner;
+use crate::commutation_checker::CommutationChecker;
+use crate::{euler_one_qubit_decomposer, QiskitError};
+
+const _CUTOFF_PRECISION: f64 = 1e-5;
+static ROTATION_GATES: [&str; 4] = ["p", "u1", "rz", "rx"];
+static HALF_TURNS: [&str; 2] = ["z", "x"];
+static QUARTER_TURNS: [&str; 1] = ["s"];
+static EIGHTH_TURNS: [&str; 1] = ["t"];
+
+static VAR_Z_MAP: [(&str, StandardGate); 3] = [("rz", RZGate), ("p", PhaseGate), ("u1", U1Gate)];
+static Z_ROTATIONS: [StandardGate; 6] = [PhaseGate, ZGate, U1Gate, RZGate, TGate, SGate];
+static X_ROTATIONS: [StandardGate; 2] = [XGate, RXGate];
+static SUPPORTED_GATES: [StandardGate; 5] = [CXGate, CYGate, CZGate, HGate, YGate];
+
+#[derive(Hash, Eq, PartialEq, Debug)]
+enum GateOrRotation {
+    Gate(StandardGate),
+    ZRotation,
+    XRotation,
+}
+#[derive(Hash, Eq, PartialEq, Debug)]
+struct CancellationSetKey {
+    gate: GateOrRotation,
+    qubits: SmallVec<[Qubit; 2]>,
+    com_set_index: usize,
+    second_index: Option<usize>,
+}
+
+#[pyfunction]
+#[pyo3(signature = (dag, commutation_checker, basis_gates=None))]
+pub(crate) fn cancel_commutations(
+    py: Python,
+    dag: &mut DAGCircuit,
+    commutation_checker: &mut CommutationChecker,
+    basis_gates: Option<HashSet<String>>,
+) -> PyResult<()> {
+    let basis: HashSet<String> = if let Some(basis) = basis_gates {
+        basis
+    } else {
+        HashSet::new()
+    };
+    let z_var_gate = dag
+        .get_op_counts()
+        .keys()
+        .find_map(|g| {
+            VAR_Z_MAP
+                .iter()
+                .find(|(key, _)| *key == g.as_str())
+                .map(|(_, gate)| gate)
+        })
+        .or_else(|| {
+            basis.iter().find_map(|g| {
+                VAR_Z_MAP
+                    .iter()
+                    .find(|(key, _)| *key == g.as_str())
+                    .map(|(_, gate)| gate)
+            })
+        });
+    // Fallback to the first matching key from basis if there is no match in dag.op_names
+
+    // Gate sets to be cancelled
+    /* Traverse each qubit to generate the cancel dictionaries
+     Cancel dictionaries:
+      - For 1-qubit gates the key is (gate_type, qubit_id, commutation_set_id),
+        the value is the list of gates that share the same gate type, qubit, commutation set.
+      - For 2qbit gates the key: (gate_type, first_qbit, sec_qbit, first commutation_set_id,
+        sec_commutation_set_id), the value is the list gates that share the same gate type,
+        qubits and commutation sets.
+    */
+    let (commutation_set, node_indices) = analyze_commutations_inner(py, dag, commutation_checker)?;
+    let mut cancellation_sets: HashMap<CancellationSetKey, Vec<NodeIndex>> = HashMap::new();
+
+    (0..dag.num_qubits() as u32).for_each(|qubit| {
+        let wire = Qubit(qubit);
+        if let Some(wire_commutation_set) = commutation_set.get(&Wire::Qubit(wire)) {
+            for (com_set_idx, com_set) in wire_commutation_set.iter().enumerate() {
+                if let Some(&nd) = com_set.first() {
+                    if !matches!(dag.dag[nd], NodeType::Operation(_)) {
+                        continue;
+                    }
+                } else {
+                    continue;
+                }
+                for node in com_set.iter() {
+                    let instr = match &dag.dag[*node] {
+                        NodeType::Operation(instr) => instr,
+                        _ => panic!("Unexpected type in commutation set."),
+                    };
+                    let num_qargs = dag.get_qargs(instr.qubits).len();
+                    // no support for cancellation of parameterized gates
+                    if instr.is_parameterized() {
+                        continue;
+                    }
+                    if let Some(op_gate) = instr.op.try_standard_gate() {
+                        if num_qargs == 1 && SUPPORTED_GATES.contains(&op_gate) {
+                            cancellation_sets
+                                .entry(CancellationSetKey {
+                                    gate: GateOrRotation::Gate(op_gate),
+                                    qubits: smallvec![wire],
+                                    com_set_index: com_set_idx,
+                                    second_index: None,
+                                })
+                                .or_insert_with(Vec::new)
+                                .push(*node);
+                        }
+
+                        if num_qargs == 1 && Z_ROTATIONS.contains(&op_gate) {
+                            cancellation_sets
+                                .entry(CancellationSetKey {
+                                    gate: GateOrRotation::ZRotation,
+                                    qubits: smallvec![wire],
+                                    com_set_index: com_set_idx,
+                                    second_index: None,
+                                })
+                                .or_insert_with(Vec::new)
+                                .push(*node);
+                        }
+                        if num_qargs == 1 && X_ROTATIONS.contains(&op_gate) {
+                            cancellation_sets
+                                .entry(CancellationSetKey {
+                                    gate: GateOrRotation::XRotation,
+                                    qubits: smallvec![wire],
+                                    com_set_index: com_set_idx,
+                                    second_index: None,
+                                })
+                                .or_insert_with(Vec::new)
+                                .push(*node);
+                        }
+                        // Don't deal with Y rotation, because Y rotation doesn't commute with
+                        // CNOT, so it should be dealt with by optimized1qgate pass
+                        if num_qargs == 2 && dag.get_qargs(instr.qubits)[0] == wire {
+                            let second_qarg = dag.get_qargs(instr.qubits)[1];
+                            cancellation_sets
+                                .entry(CancellationSetKey {
+                                    gate: GateOrRotation::Gate(op_gate),
+                                    qubits: smallvec![wire, second_qarg],
+                                    com_set_index: com_set_idx,
+                                    second_index: node_indices
+                                        .get(&(*node, Wire::Qubit(second_qarg)))
+                                        .copied(),
+                                })
+                                .or_insert_with(Vec::new)
+                                .push(*node);
+                        }
+                    }
+                }
+            }
+        }
+    });
+
+    for (cancel_key, cancel_set) in &cancellation_sets {
+        if cancel_set.len() > 1 {
+            if let GateOrRotation::Gate(g) = cancel_key.gate {
+                if SUPPORTED_GATES.contains(&g) {
+                    for &c_node in &cancel_set[0..(cancel_set.len() / 2) * 2] {
+                        dag.remove_op_node(c_node);
+                    }
+                }
+                continue;
+            }
+            if matches!(cancel_key.gate, GateOrRotation::ZRotation) && z_var_gate.is_none() {
+                continue;
+            }
+            if matches!(
+                cancel_key.gate,
+                GateOrRotation::ZRotation | GateOrRotation::XRotation
+            ) {
+                let mut total_angle: f64 = 0.0;
+                let mut total_phase: f64 = 0.0;
+                for current_node in cancel_set {
+                    let node_op = match &dag.dag[*current_node] {
+                        NodeType::Operation(instr) => instr,
+                        _ => panic!("Unexpected type in commutation set run."),
+                    };
+                    let node_op_name = node_op.op.name();
+
+                    let node_angle = if ROTATION_GATES.contains(&node_op_name) {
+                        match node_op.params_view().first() {
+                            Some(Param::Float(f)) => Ok(*f),
+                            _ => return Err(QiskitError::new_err(format!(
+                                "Rotational gate with parameter expression encountered in cancellation {:?}",
+                                node_op.op
+                            )))
+                        }
+                    } else if HALF_TURNS.contains(&node_op_name) {
+                        Ok(PI)
+                    } else if QUARTER_TURNS.contains(&node_op_name) {
+                        Ok(PI / 2.0)
+                    } else if EIGHTH_TURNS.contains(&node_op_name) {
+                        Ok(PI / 4.0)
+                    } else {
+                        Err(PyRuntimeError::new_err(format!(
+                            "Angle for operation {} is not defined",
+                            node_op_name
+                        )))
+                    };
+                    total_angle += node_angle?;
+
+                    let Param::Float(new_phase) = node_op
+                        .op
+                        .definition(node_op.params_view())
+                        .unwrap()
+                        .global_phase()
+                        .clone()
+                    else {
+                        unreachable!()
+                    };
+                    total_phase += new_phase
+                }
+
+                let new_op = match cancel_key.gate {
+                    GateOrRotation::ZRotation => z_var_gate.unwrap(),
+                    GateOrRotation::XRotation => &RXGate,
+                    _ => unreachable!(),
+                };
+
+                let gate_angle = euler_one_qubit_decomposer::mod_2pi(total_angle, 0.);
+
+                let new_op_phase: f64 = if gate_angle.abs() > _CUTOFF_PRECISION {
+                    dag.insert_1q_on_incoming_qubit((*new_op, &[total_angle]), cancel_set[0]);
+                    let Param::Float(new_phase) = new_op
+                        .definition(&[Param::Float(total_angle)])
+                        .unwrap()
+                        .global_phase()
+                        .clone()
+                    else {
+                        unreachable!();
+                    };
+                    new_phase
+                } else {
+                    0.0
+                };
+
+                dag.add_global_phase(py, &Param::Float(total_phase - new_op_phase))?;
+
+                for node in cancel_set {
+                    dag.remove_op_node(*node);
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+#[pymodule]
+pub fn commutation_cancellation(m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_wrapped(wrap_pyfunction!(cancel_commutations))?;
+    Ok(())
+}
diff --git a/crates/accelerate/src/euler_one_qubit_decomposer.rs b/crates/accelerate/src/euler_one_qubit_decomposer.rs
index a3cb11ea45a2..4c0a8539cf34 100644
--- a/crates/accelerate/src/euler_one_qubit_decomposer.rs
+++ b/crates/accelerate/src/euler_one_qubit_decomposer.rs
@@ -924,7 +924,7 @@ pub fn det_one_qubit(mat: ArrayView2<Complex64>) -> Complex64 {
 
 /// Wrap angle into interval [-π,π). If within atol of the endpoint, clamp to -π
 #[inline]
-fn mod_2pi(angle: f64, atol: f64) -> f64 {
+pub(crate) fn mod_2pi(angle: f64, atol: f64) -> f64 {
     // f64::rem_euclid() isn't exactly the same as Python's % operator, but because
     // the RHS here is a constant and positive it is effectively equivalent for
     // this case
diff --git a/crates/accelerate/src/lib.rs b/crates/accelerate/src/lib.rs
index 9e391e0a9030..9111f932e270 100644
--- a/crates/accelerate/src/lib.rs
+++ b/crates/accelerate/src/lib.rs
@@ -17,6 +17,7 @@ use pyo3::import_exception;
 pub mod check_map;
 pub mod circuit_library;
 pub mod commutation_analysis;
+pub mod commutation_cancellation;
 pub mod commutation_checker;
 pub mod convert_2q_block_matrix;
 pub mod dense_layout;
diff --git a/crates/circuit/src/dag_circuit.rs b/crates/circuit/src/dag_circuit.rs
index 0b5a43c1eb4b..81dd8ffd3322 100644
--- a/crates/circuit/src/dag_circuit.rs
+++ b/crates/circuit/src/dag_circuit.rs
@@ -6454,6 +6454,16 @@ impl DAGCircuit {
         }
     }
 
+    /// Get an immutable reference to the op counts for this DAGCircuit
+    ///
+    /// This differs from count_ops() in that it doesn't handle control flow recursion at all
+    /// and it returns a reference instead of an owned copy. If you don't need to work with
+    /// control flow or ownership of the counts this is a more efficient alternative to
+    /// `DAGCircuit::count_ops(py, false)`
+    pub fn get_op_counts(&self) -> &IndexMap<String, usize, RandomState> {
+        &self.op_names
+    }
+
     /// Extends the DAG with valid instances of [PackedInstruction]
     pub fn extend<I>(&mut self, py: Python, iter: I) -> PyResult<Vec<NodeIndex>>
     where
diff --git a/crates/pyext/src/lib.rs b/crates/pyext/src/lib.rs
index 03bd0202dae4..43b693a4d6c1 100644
--- a/crates/pyext/src/lib.rs
+++ b/crates/pyext/src/lib.rs
@@ -14,12 +14,13 @@ use pyo3::prelude::*;
 
 use qiskit_accelerate::{
     check_map::check_map_mod, circuit_library::circuit_library,
-    commutation_analysis::commutation_analysis, commutation_checker::commutation_checker,
-    convert_2q_block_matrix::convert_2q_block_matrix, dense_layout::dense_layout,
-    error_map::error_map, euler_one_qubit_decomposer::euler_one_qubit_decomposer,
-    filter_op_nodes::filter_op_nodes_mod, gate_direction::gate_direction,
-    inverse_cancellation::inverse_cancellation_mod, isometry::isometry, nlayout::nlayout,
-    optimize_1q_gates::optimize_1q_gates, pauli_exp_val::pauli_expval,
+    commutation_analysis::commutation_analysis, commutation_cancellation::commutation_cancellation,
+    commutation_checker::commutation_checker, convert_2q_block_matrix::convert_2q_block_matrix,
+    dense_layout::dense_layout, error_map::error_map,
+    euler_one_qubit_decomposer::euler_one_qubit_decomposer, filter_op_nodes::filter_op_nodes_mod,
+    gate_direction::gate_direction, inverse_cancellation::inverse_cancellation_mod,
+    isometry::isometry, nlayout::nlayout, optimize_1q_gates::optimize_1q_gates,
+    pauli_exp_val::pauli_expval,
     remove_diagonal_gates_before_measure::remove_diagonal_gates_before_measure, results::results,
     sabre::sabre, sampled_exp_val::sampled_exp_val, sparse_pauli_op::sparse_pauli_op,
     split_2q_unitaries::split_2q_unitaries_mod, star_prerouting::star_prerouting,
@@ -77,5 +78,6 @@ fn _accelerate(m: &Bound<PyModule>) -> PyResult<()> {
     add_submodule(m, gate_direction, "gate_direction")?;
     add_submodule(m, commutation_checker, "commutation_checker")?;
     add_submodule(m, commutation_analysis, "commutation_analysis")?;
+    add_submodule(m, commutation_cancellation, "commutation_cancellation")?;
     Ok(())
 }
diff --git a/qiskit/__init__.py b/qiskit/__init__.py
index 29e2b8ba5c11..d0811c172d69 100644
--- a/qiskit/__init__.py
+++ b/qiskit/__init__.py
@@ -91,6 +91,7 @@
 sys.modules["qiskit._accelerate.synthesis.clifford"] = _accelerate.synthesis.clifford
 sys.modules["qiskit._accelerate.commutation_checker"] = _accelerate.commutation_checker
 sys.modules["qiskit._accelerate.commutation_analysis"] = _accelerate.commutation_analysis
+sys.modules["qiskit._accelerate.commutation_cancellation"] = _accelerate.commutation_cancellation
 sys.modules["qiskit._accelerate.synthesis.linear_phase"] = _accelerate.synthesis.linear_phase
 sys.modules["qiskit._accelerate.split_2q_unitaries"] = _accelerate.split_2q_unitaries
 sys.modules["qiskit._accelerate.gate_direction"] = _accelerate.gate_direction
diff --git a/qiskit/transpiler/passes/optimization/commutative_cancellation.py b/qiskit/transpiler/passes/optimization/commutative_cancellation.py
index 836fa112fd84..130ff0609354 100644
--- a/qiskit/transpiler/passes/optimization/commutative_cancellation.py
+++ b/qiskit/transpiler/passes/optimization/commutative_cancellation.py
@@ -11,23 +11,16 @@
 # that they have been altered from the originals.
 
 """Cancel the redundant (self-adjoint) gates through commutation relations."""
-
-from collections import defaultdict
-import numpy as np
-
-from qiskit.circuit.quantumregister import QuantumRegister
-from qiskit.circuit.parameterexpression import ParameterExpression
 from qiskit.transpiler.basepasses import TransformationPass
-from qiskit.transpiler.passmanager import PassManager
-from qiskit.transpiler.passes.optimization.commutation_analysis import CommutationAnalysis
-from qiskit.dagcircuit import DAGCircuit, DAGInNode, DAGOutNode
-from qiskit.circuit.commutation_library import CommutationChecker, StandardGateCommutations
+from qiskit.circuit.commutation_library import StandardGateCommutations
+
 from qiskit.circuit.library.standard_gates.u1 import U1Gate
-from qiskit.circuit.library.standard_gates.rx import RXGate
 from qiskit.circuit.library.standard_gates.p import PhaseGate
 from qiskit.circuit.library.standard_gates.rz import RZGate
-from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES
+from qiskit._accelerate import commutation_cancellation
+from qiskit._accelerate.commutation_checker import CommutationChecker
 
+from qiskit.transpiler.passes.utils.control_flow import trivial_recurse
 
 _CUTOFF_PRECISION = 1e-5
 
@@ -59,6 +52,7 @@ def __init__(self, basis_gates=None, target=None):
             self.basis = set(basis_gates)
         else:
             self.basis = set()
+        self.target = target
         if target is not None:
             self.basis = set(target.operation_names)
 
@@ -70,12 +64,11 @@ def __init__(self, basis_gates=None, target=None):
 
         # build a commutation checker restricted to the gates we cancel -- the others we
         # do not have to investigate, which allows to save time
-        commutation_checker = CommutationChecker(
+        self._commutation_checker = CommutationChecker(
             StandardGateCommutations, gates=self._gates | self._z_rotations | self._x_rotations
         )
 
-        self.requires.append(CommutationAnalysis(_commutation_checker=commutation_checker))
-
+    @trivial_recurse
     def run(self, dag):
         """Run the CommutativeCancellation pass on `dag`.
 
@@ -85,141 +78,5 @@ def run(self, dag):
         Returns:
             DAGCircuit: the optimized DAG.
         """
-        var_z_gate = None
-        z_var_gates = [gate for gate in dag.count_ops().keys() if gate in self._var_z_map]
-        if z_var_gates:
-            # prioritize z gates in circuit
-            var_z_gate = self._var_z_map[next(iter(z_var_gates))]
-        else:
-            z_var_gates = [gate for gate in self.basis if gate in self._var_z_map]
-            if z_var_gates:
-                var_z_gate = self._var_z_map[next(iter(z_var_gates))]
-
-        # Gate sets to be cancelled
-        cancellation_sets = defaultdict(lambda: [])
-
-        # Traverse each qubit to generate the cancel dictionaries
-        # Cancel dictionaries:
-        #  - For 1-qubit gates the key is (gate_type, qubit_id, commutation_set_id),
-        #    the value is the list of gates that share the same gate type, qubit, commutation set.
-        #  - For 2qbit gates the key: (gate_type, first_qbit, sec_qbit, first commutation_set_id,
-        #    sec_commutation_set_id), the value is the list gates that share the same gate type,
-        #    qubits and commutation sets.
-        for wire in dag.qubits:
-            wire_commutation_set = self.property_set["commutation_set"][wire]
-
-            for com_set_idx, com_set in enumerate(wire_commutation_set):
-                if isinstance(com_set[0], (DAGInNode, DAGOutNode)):
-                    continue
-                for node in com_set:
-                    num_qargs = len(node.qargs)
-                    if any(isinstance(p, ParameterExpression) for p in node.params):
-                        continue  # no support for cancellation of parameterized gates
-                    if num_qargs == 1 and node.name in self._gates:
-                        cancellation_sets[(node.name, wire, com_set_idx)].append(node)
-                    if num_qargs == 1 and node.name in self._z_rotations:
-                        cancellation_sets[("z_rotation", wire, com_set_idx)].append(node)
-                    if num_qargs == 1 and node.name in ["rx", "x"]:
-                        cancellation_sets[("x_rotation", wire, com_set_idx)].append(node)
-                    # Don't deal with Y rotation, because Y rotation doesn't commute with CNOT, so
-                    # it should be dealt with by optimized1qgate pass
-                    elif num_qargs == 2 and node.qargs[0] == wire:
-                        second_qarg = node.qargs[1]
-                        q2_key = (
-                            node.name,
-                            wire,
-                            second_qarg,
-                            com_set_idx,
-                            self.property_set["commutation_set"][(node, second_qarg)],
-                        )
-                        cancellation_sets[q2_key].append(node)
-
-        for cancel_set_key in cancellation_sets:
-            if cancel_set_key[0] == "z_rotation" and var_z_gate is None:
-                continue
-            set_len = len(cancellation_sets[cancel_set_key])
-            if set_len > 1 and cancel_set_key[0] in self._gates:
-                gates_to_cancel = cancellation_sets[cancel_set_key]
-                for c_node in gates_to_cancel[: (set_len // 2) * 2]:
-                    dag.remove_op_node(c_node)
-
-            elif set_len > 1 and cancel_set_key[0] in ["z_rotation", "x_rotation"]:
-                run = cancellation_sets[cancel_set_key]
-                run_qarg = run[0].qargs[0]
-                total_angle = 0.0  # lambda
-                total_phase = 0.0
-                for current_node in run:
-                    if (
-                        current_node.condition is not None
-                        or len(current_node.qargs) != 1
-                        or current_node.qargs[0] != run_qarg
-                    ):
-                        raise RuntimeError("internal error")
-
-                    if current_node.name in ["p", "u1", "rz", "rx"]:
-                        current_angle = float(current_node.params[0])
-                    elif current_node.name in ["z", "x"]:
-                        current_angle = np.pi
-                    elif current_node.name == "t":
-                        current_angle = np.pi / 4
-                    elif current_node.name == "s":
-                        current_angle = np.pi / 2
-                    else:
-                        raise RuntimeError(
-                            f"Angle for operation {current_node.name } is not defined"
-                        )
-
-                    # Compose gates
-                    total_angle = current_angle + total_angle
-                    if current_node.definition:
-                        total_phase += current_node.definition.global_phase
-
-                # Replace the data of the first node in the run
-                if cancel_set_key[0] == "z_rotation":
-                    new_op = var_z_gate(total_angle)
-                elif cancel_set_key[0] == "x_rotation":
-                    new_op = RXGate(total_angle)
-                else:
-                    raise RuntimeError("impossible case")
-
-                new_op_phase = 0
-                if np.mod(total_angle, (2 * np.pi)) > _CUTOFF_PRECISION:
-                    new_qarg = QuantumRegister(1, "q")
-                    new_dag = DAGCircuit()
-                    new_dag.add_qreg(new_qarg)
-                    new_dag.apply_operation_back(new_op, [new_qarg[0]])
-                    dag.substitute_node_with_dag(run[0], new_dag)
-                    if new_op.definition:
-                        new_op_phase = new_op.definition.global_phase
-
-                dag.global_phase = total_phase - new_op_phase
-
-                # Delete the other nodes in the run
-                for current_node in run[1:]:
-                    dag.remove_op_node(current_node)
-
-                if np.mod(total_angle, (2 * np.pi)) < _CUTOFF_PRECISION:
-                    dag.remove_op_node(run[0])
-
-        dag = self._handle_control_flow_ops(dag)
-
-        return dag
-
-    def _handle_control_flow_ops(self, dag):
-        """
-        This is similar to transpiler/passes/utils/control_flow.py except that the
-        commutation analysis is redone for the control flow blocks.
-        """
-
-        pass_manager = PassManager([CommutationAnalysis(), self])
-        for node in dag.op_nodes():
-            if node.name not in CONTROL_FLOW_OP_NAMES:
-                continue
-            mapped_blocks = []
-            for block in node.op.blocks:
-                new_circ = pass_manager.run(block)
-                mapped_blocks.append(new_circ)
-            dag.substitute_node(
-                node, node.op.replace_blocks(mapped_blocks), propagate_condition=False
-            )
+        commutation_cancellation.cancel_commutations(dag, self._commutation_checker, self.basis)
         return dag
diff --git a/test/python/transpiler/test_commutative_cancellation.py b/test/python/transpiler/test_commutative_cancellation.py
index 71bab61708cd..88f1d99bef31 100644
--- a/test/python/transpiler/test_commutative_cancellation.py
+++ b/test/python/transpiler/test_commutative_cancellation.py
@@ -13,6 +13,7 @@
 """Gate cancellation pass testing"""
 
 import unittest
+
 import numpy as np
 
 from qiskit import QuantumRegister, QuantumCircuit
@@ -76,7 +77,7 @@ def test_all_gates(self):
         expected = QuantumCircuit(qr)
         expected.append(RZGate(2.0), [qr[0]])
         expected.rx(1.0, qr[0])
-
+        expected.global_phase = 0.5
         self.assertEqual(expected, new_circuit)
 
     def test_commutative_circuit1(self):
@@ -433,7 +434,7 @@ def test_commutative_circuit3(self):
         expected.append(RZGate(np.pi * 17 / 12), [qr[2]])
         expected.append(RZGate(np.pi * 2 / 3), [qr[3]])
         expected.cx(qr[2], qr[1])
-
+        expected.global_phase = 3 * np.pi / 8
         self.assertEqual(
             expected, new_circuit, msg=f"expected:\n{expected}\nnew_circuit:\n{new_circuit}"
         )
diff --git a/test/python/transpiler/test_passmanager.py b/test/python/transpiler/test_passmanager.py
index ce4d28bf314e..60375a820655 100644
--- a/test/python/transpiler/test_passmanager.py
+++ b/test/python/transpiler/test_passmanager.py
@@ -27,7 +27,7 @@
     DoWhileController,
 )
 from qiskit.transpiler import PassManager, PropertySet, TransformationPass
-from qiskit.transpiler.passes import CommutativeCancellation
+from qiskit.transpiler.passes import RXCalibrationBuilder
 from qiskit.transpiler.passes import Optimize1qGates, BasisTranslator
 from qiskit.circuit.library.standard_gates.equivalence_library import (
     StandardEquivalenceLibrary as std_eqlib,
@@ -97,7 +97,6 @@ def test_callback_with_pass_requires(self):
 
         expected_end = QuantumCircuit(qr)
         expected_end.cx(qr[0], qr[2])
-        expected_end_dag = circuit_to_dag(expected_end)
 
         calls = []
 
@@ -107,20 +106,19 @@ def callback(**kwargs):
             calls.append(out_dict)
 
         passmanager = PassManager()
-        passmanager.append(CommutativeCancellation(basis_gates=["u1", "u2", "u3", "cx"]))
+        passmanager.append(RXCalibrationBuilder())
         passmanager.run(circuit, callback=callback)
         self.assertEqual(len(calls), 2)
         self.assertEqual(len(calls[0]), 5)
         self.assertEqual(calls[0]["count"], 0)
-        self.assertEqual(calls[0]["pass_"].name(), "CommutationAnalysis")
+        self.assertEqual(calls[0]["pass_"].name(), "NormalizeRXAngle")
         self.assertEqual(expected_start_dag, calls[0]["dag"])
         self.assertIsInstance(calls[0]["time"], float)
         self.assertIsInstance(calls[0]["property_set"], PropertySet)
         self.assertEqual("MyCircuit", calls[0]["dag"].name)
         self.assertEqual(len(calls[1]), 5)
         self.assertEqual(calls[1]["count"], 1)
-        self.assertEqual(calls[1]["pass_"].name(), "CommutativeCancellation")
-        self.assertEqual(expected_end_dag, calls[1]["dag"])
+        self.assertEqual(calls[1]["pass_"].name(), "RXCalibrationBuilder")
         self.assertIsInstance(calls[0]["time"], float)
         self.assertIsInstance(calls[0]["property_set"], PropertySet)
         self.assertEqual("MyCircuit", calls[1]["dag"].name)

From 86a1b496ac44698422c0428b9d76820148c2a707 Mon Sep 17 00:00:00 2001
From: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>
Date: Tue, 10 Sep 2024 16:23:21 -0400
Subject: [PATCH 67/85] Port `circuit_to_dag` to Rust (#13036)

* Initial: Add add_from_iter method to DAGCircuit
- Introduce a method that adds a chain of `PackedInstruction` continuously avoiding the re-linking of each bit's output-node until the very end of the iterator.
   - TODO: Add handling of vars
- Add header for a `from_iter` function that will create a `DAGCircuit` based on a chain of `PackedInstruction`.

* Fix: leverage new methods in layers
- Fix incorrect re-insertion of last_node.

* Fix: Keep track of Vars for add_from_iter
- Remove `from_iter`

* Fix: Incorrect modification of last nodes in `add_from_iter`.
- Use `entry` api to either modify or insert a value if missing.

* Fix: Cycling edges in when adding vars.
- A bug that adds duplicate edges to vars has been temporarily fixed. However, the root of this problem hasn't been found yet. A proper fix is pending. For now skip those instances.

* Fix: Remove set collecting all nodes to be connected.
- A set collecting all the new nodes to connect with a new node was preventing additional wires to connect to subsequent nodes.

* Fix: Adapt to #13033

* Refactor: `add_from_iter` is now called `extend` to stick with `Rust` nomenclature.

* Fix: Remove duplicate vars check

* Fix: Corrections from code review.
- Use Entry API to modify last nodes in the var.
- Build new_nodes with an allocated vec.
- Add comment explaining the removal of the edge between the output node and its predecessor.

* Fix: Improper use of `Entry API`.
- Use `or_insert_with` instead of `or_insert` to perform actions before inserting a value.

* Initial: Add add_from_iter method to DAGCircuit
- Introduce a method that adds a chain of `PackedInstruction` continuously avoiding the re-linking of each bit's output-node until the very end of the iterator.
   - TODO: Add handling of vars
- Add header for a `from_iter` function that will create a `DAGCircuit` based on a chain of `PackedInstruction`.

* Initial: Expose `CircuitData` interners and registers to the `qiskit-circuit` crate.
- Make the `CircuitData` iter method be an exact-size iterator.

* FIx: Expose immutable views of interners, registers and global phase.
- Revert the changes making the interners and registers visible to the crate `qiskit-circuit`.
- Create methods to expose immutable borrowed views of the interners, registers and global_phase to prevent from mutating the DAGCircuit.
- Add `get_qargs` and `get_cargs` to unpack interned qargs ans cargs.
- Other tweaks and fixes.

* Refactor: Use naming convention for getters.

* Docs: Apply suggestions from code review

- Correct incorrect docstrings for `qubits()` and `clbits()`

Co-authored-by: Eli Arbel <46826214+eliarbel@users.noreply.github.com>

* Initial: Add `circuit_to_dag` in rust.
- Add new method `DAGCircuit::from_quantum_circuit` which uses the data from a `QuantumCircuit` instance to build a dag_circuit.
- Expose the method through a `Python` interface with `circuit_to_dag` which goes by the alias of `core_circuit_to_dag` and is called by the original method.
- Add an arbitrary structure `QuantumCircuitData` that successfully extract attributes from the python `QuantumCircuit` instance and makes it easier to access in rust.
   - This structure is for attribute extraction only and is not clonable/copyable.
- Expose a new module `converters` which should store all of the rust-side converters whenever they get brought into rust.
- Other small tweaks and fixes.

* Fix: Move qubit ordering check to python
- Add more accurate estimate of num_edges.

* Fix: Regenerate `BitData` instances dynamically instead of cloning.
- When converting from `QuantumCircuit` to `DAGCircuit`, we were previously copying the instances of `BitData` by cloning. This would result in instances that had extra qubits that went unused. This commit fixes this oversight and reduced the amount of failing times from 160 to 12.

* Fix: Make use of `copy_operations`
- Use `copy_operations` to copy all of the operations obtained from `CircuitData` by calling deepcopy.
- Initialize `._data` manually for instances of `BlueprintCircuit` by calling `._build()`.
- Other small fixes.

* FIx: Adapt to 13033

* Fix: Correctly map qubits and clbits to the `DAGCircuit`.
- Previously, the binding of qubits and clbits into bitdata was done based on the `push_back()` function behavior. This manual mapping was removed in favor of just inserting the qubits/clbits using the `add_qubits()` and `add_clbits()` methods and keeping track of the new indices.
- Remove cloning of interners, use the re-mapped entries instead.
- Remove manual re-mapping of qubits and clbits.
- Remove cloning of BitData, insert qubits directly instead.
- Other small tweaks and fixes.

* Add: `DAGCircuit` from `CircuitData`
- Make `QuantumCircuitData` extraction struct private.
- Rename `DAGCircuit::from_quantum_circuit` into `DAGCircuit::from_circuit` to make more generalized.
- Pass all attributes of `QuantumCircuit` that are passed from python as arguments to the `DAGCircuit::from_circuit` function.
- Add `DAGCircuit::from_circuit_data` as a wrapper to `from_circuit` to create an instance solely from the properties available in `CircuitData`.
    - Use `DAGCircuit::from_circuit` as base for `DAGCircuit::from_circuit_data`.

* Fix: Make `QuantumCircuitData` public.
- `QuantumCircuitData` is an extractor helper built only to extract attributes from a Python-based `Quantumircuit` that are not yet available in rust + the qualities that already are through `CircuitData`.
- Add `Clone` trait `QuantumCircuitData` as all its properties are clonable.
- Make `circuit_to_dag` public in rust in case it needs to be used for a transpiler pass.
- Adapt to renaming of `DAGCircuit::add_from_iter` into `DAGCircuit::extend`.

* Fix: Use `intern!` when extracting attributes from Python.

* Fix: Copy instructions in place instead of copying circuit data.
- Use `QuantumCircuitData` as argument for `DAGCircuit::from_circuit`.
- Create instance of `QuantumCircuitData` in `DAGCircuit::from_circuit_data`.
- Re-add duplicate skip in extend.
- Other tweaks and fixes.

* Fix: Remove second re-mapping of bits
- Remove second re-mapping of bits, perform this mapping at insertion of qubits instead.
- Modify insertion of qubits to re-map the indices and store them after insertion should a custom ordering be provided.
- Remove extra `.and_modify()` for `clbits_last_node` from `DAGCircuit::extend`.
- Remove submodule addition to `circuit` module, submodule is now under `_accelerate.converters`.
- Other tweaks and fixes.

* Update crates/circuit/src/dag_circuit.rs

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>

---------

Co-authored-by: Eli Arbel <46826214+eliarbel@users.noreply.github.com>
Co-authored-by: Matthew Treinish <mtreinish@kortar.org>
---
 crates/circuit/src/converters.rs    |  91 ++++++++++++
 crates/circuit/src/dag_circuit.rs   | 208 ++++++++++++++++++++++++++++
 crates/circuit/src/lib.rs           |   1 +
 crates/pyext/src/lib.rs             |   1 +
 qiskit/__init__.py                  |   1 +
 qiskit/converters/circuit_to_dag.py |  52 ++-----
 6 files changed, 316 insertions(+), 38 deletions(-)
 create mode 100644 crates/circuit/src/converters.rs

diff --git a/crates/circuit/src/converters.rs b/crates/circuit/src/converters.rs
new file mode 100644
index 000000000000..ab9d4bce0475
--- /dev/null
+++ b/crates/circuit/src/converters.rs
@@ -0,0 +1,91 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2023, 2024
+//
+// 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.
+
+use ::pyo3::prelude::*;
+use hashbrown::HashMap;
+use pyo3::{
+    intern,
+    types::{PyDict, PyList},
+};
+
+use crate::{circuit_data::CircuitData, dag_circuit::DAGCircuit};
+
+/// An extractable representation of a QuantumCircuit reserved only for
+/// conversion purposes.
+#[derive(Debug, Clone)]
+pub struct QuantumCircuitData<'py> {
+    pub data: CircuitData,
+    pub name: Option<Bound<'py, PyAny>>,
+    pub calibrations: Option<HashMap<String, Py<PyDict>>>,
+    pub metadata: Option<Bound<'py, PyAny>>,
+    pub qregs: Option<Bound<'py, PyList>>,
+    pub cregs: Option<Bound<'py, PyList>>,
+    pub input_vars: Vec<Bound<'py, PyAny>>,
+    pub captured_vars: Vec<Bound<'py, PyAny>>,
+    pub declared_vars: Vec<Bound<'py, PyAny>>,
+}
+
+impl<'py> FromPyObject<'py> for QuantumCircuitData<'py> {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
+        let py = ob.py();
+        let circuit_data = ob.getattr("_data")?;
+        let data_borrowed = circuit_data.extract::<CircuitData>()?;
+        Ok(QuantumCircuitData {
+            data: data_borrowed,
+            name: ob.getattr(intern!(py, "name")).ok(),
+            calibrations: ob.getattr(intern!(py, "calibrations"))?.extract().ok(),
+            metadata: ob.getattr(intern!(py, "metadata")).ok(),
+            qregs: ob
+                .getattr(intern!(py, "qregs"))
+                .map(|ob| ob.downcast_into())?
+                .ok(),
+            cregs: ob
+                .getattr(intern!(py, "cregs"))
+                .map(|ob| ob.downcast_into())?
+                .ok(),
+            input_vars: ob
+                .call_method0(intern!(py, "iter_input_vars"))?
+                .iter()?
+                .collect::<PyResult<Vec<_>>>()?,
+            captured_vars: ob
+                .call_method0(intern!(py, "iter_captured_vars"))?
+                .iter()?
+                .collect::<PyResult<Vec<_>>>()?,
+            declared_vars: ob
+                .call_method0(intern!(py, "iter_declared_vars"))?
+                .iter()?
+                .collect::<PyResult<Vec<_>>>()?,
+        })
+    }
+}
+
+#[pyfunction(signature = (quantum_circuit, copy_operations = true, qubit_order = None, clbit_order = None))]
+pub fn circuit_to_dag(
+    py: Python,
+    quantum_circuit: QuantumCircuitData,
+    copy_operations: bool,
+    qubit_order: Option<Vec<Bound<PyAny>>>,
+    clbit_order: Option<Vec<Bound<PyAny>>>,
+) -> PyResult<DAGCircuit> {
+    DAGCircuit::from_circuit(
+        py,
+        quantum_circuit,
+        copy_operations,
+        qubit_order,
+        clbit_order,
+    )
+}
+
+pub fn converters(m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(circuit_to_dag, m)?)?;
+    Ok(())
+}
diff --git a/crates/circuit/src/dag_circuit.rs b/crates/circuit/src/dag_circuit.rs
index 81dd8ffd3322..197ad57278a2 100644
--- a/crates/circuit/src/dag_circuit.rs
+++ b/crates/circuit/src/dag_circuit.rs
@@ -15,9 +15,11 @@ use std::hash::{Hash, Hasher};
 use ahash::RandomState;
 
 use crate::bit_data::BitData;
+use crate::circuit_data::CircuitData;
 use crate::circuit_instruction::{
     CircuitInstruction, ExtraInstructionAttributes, OperationFromPython,
 };
+use crate::converters::QuantumCircuitData;
 use crate::dag_node::{DAGInNode, DAGNode, DAGOpNode, DAGOutNode};
 use crate::dot_utils::build_dot;
 use crate::error::DAGCircuitError;
@@ -6572,7 +6574,12 @@ impl DAGCircuit {
                     predecessor_node
                 };
 
+                // Because `DAGCircuit::additional_wires` can return repeated instances of vars,
+                // we need to make sure to skip those to avoid cycles.
                 vars_last_nodes.set_item(var, new_node.index())?;
+                if var_last_node == new_node {
+                    continue;
+                }
                 self.dag
                     .add_edge(var_last_node, new_node, Wire::Var(var.clone_ref(py)));
             }
@@ -6600,6 +6607,207 @@ impl DAGCircuit {
 
         Ok(new_nodes)
     }
+
+    /// Alternative constructor to build an instance of [DAGCircuit] from a `QuantumCircuit`.
+    pub(crate) fn from_circuit(
+        py: Python,
+        qc: QuantumCircuitData,
+        copy_op: bool,
+        qubit_order: Option<Vec<Bound<PyAny>>>,
+        clbit_order: Option<Vec<Bound<PyAny>>>,
+    ) -> PyResult<DAGCircuit> {
+        // Extract necessary attributes
+        let qc_data = qc.data;
+        let num_qubits = qc_data.num_qubits();
+        let num_clbits = qc_data.num_clbits();
+        let num_ops = qc_data.__len__();
+        let num_vars = qc.declared_vars.len() + qc.input_vars.len() + qc.captured_vars.len();
+
+        // Build DAGCircuit with capacity
+        let mut new_dag = DAGCircuit::with_capacity(
+            py,
+            num_qubits,
+            num_clbits,
+            Some(num_vars),
+            Some(num_ops),
+            None,
+        )?;
+
+        // Assign other necessary data
+        new_dag.name = qc.name.map(|ob| ob.unbind());
+
+        // Avoid manually acquiring the GIL.
+        new_dag.global_phase = match qc_data.global_phase() {
+            Param::ParameterExpression(exp) => Param::ParameterExpression(exp.clone_ref(py)),
+            Param::Float(float) => Param::Float(*float),
+            _ => unreachable!("Incorrect parameter assigned for global phase"),
+        };
+
+        if let Some(calibrations) = qc.calibrations {
+            new_dag.calibrations = calibrations;
+        }
+
+        new_dag.metadata = qc.metadata.map(|meta| meta.unbind());
+
+        // Add the qubits depending on order.
+        let qubit_map: Option<Vec<Qubit>> = if let Some(qubit_ordering) = qubit_order {
+            let mut ordered_vec = Vec::from_iter((0..num_qubits as u32).map(Qubit));
+            qubit_ordering
+                .into_iter()
+                .try_for_each(|qubit| -> PyResult<()> {
+                    if new_dag.qubits.find(&qubit).is_some() {
+                        return Err(DAGCircuitError::new_err(format!(
+                            "duplicate qubits {}",
+                            &qubit
+                        )));
+                    }
+                    let qubit_index = qc_data.qubits().find(&qubit).unwrap();
+                    ordered_vec[qubit_index.0 as usize] =
+                        new_dag.add_qubit_unchecked(py, &qubit)?;
+                    Ok(())
+                })?;
+            Some(ordered_vec)
+        } else {
+            qc_data
+                .qubits()
+                .bits()
+                .iter()
+                .try_for_each(|qubit| -> PyResult<_> {
+                    new_dag.add_qubit_unchecked(py, qubit.bind(py))?;
+                    Ok(())
+                })?;
+            None
+        };
+
+        // Add the clbits depending on order.
+        let clbit_map: Option<Vec<Clbit>> = if let Some(clbit_ordering) = clbit_order {
+            let mut ordered_vec = Vec::from_iter((0..num_clbits as u32).map(Clbit));
+            clbit_ordering
+                .into_iter()
+                .try_for_each(|clbit| -> PyResult<()> {
+                    if new_dag.clbits.find(&clbit).is_some() {
+                        return Err(DAGCircuitError::new_err(format!(
+                            "duplicate clbits {}",
+                            &clbit
+                        )));
+                    };
+                    let clbit_index = qc_data.clbits().find(&clbit).unwrap();
+                    ordered_vec[clbit_index.0 as usize] =
+                        new_dag.add_clbit_unchecked(py, &clbit)?;
+                    Ok(())
+                })?;
+            Some(ordered_vec)
+        } else {
+            qc_data
+                .clbits()
+                .bits()
+                .iter()
+                .try_for_each(|clbit| -> PyResult<()> {
+                    new_dag.add_clbit_unchecked(py, clbit.bind(py))?;
+                    Ok(())
+                })?;
+            None
+        };
+
+        // Add all of the new vars.
+        for var in &qc.declared_vars {
+            new_dag.add_var(py, var, DAGVarType::Declare)?;
+        }
+
+        for var in &qc.input_vars {
+            new_dag.add_var(py, var, DAGVarType::Input)?;
+        }
+
+        for var in &qc.captured_vars {
+            new_dag.add_var(py, var, DAGVarType::Capture)?;
+        }
+
+        // Add all the registers
+        if let Some(qregs) = qc.qregs {
+            for qreg in qregs.iter() {
+                new_dag.add_qreg(py, &qreg)?;
+            }
+        }
+
+        if let Some(cregs) = qc.cregs {
+            for creg in cregs.iter() {
+                new_dag.add_creg(py, &creg)?;
+            }
+        }
+
+        // Pre-process and re-intern all indices again.
+        let instructions: Vec<PackedInstruction> = qc_data
+            .iter()
+            .map(|instr| -> PyResult<PackedInstruction> {
+                // Re-map the qubits
+                let new_qargs = if let Some(qubit_mapping) = &qubit_map {
+                    let qargs = qc_data
+                        .get_qargs(instr.qubits)
+                        .iter()
+                        .map(|bit| qubit_mapping[bit.0 as usize])
+                        .collect();
+                    new_dag.qargs_interner.insert_owned(qargs)
+                } else {
+                    new_dag
+                        .qargs_interner
+                        .insert(qc_data.get_qargs(instr.qubits))
+                };
+                // Remap the clbits
+                let new_cargs = if let Some(clbit_mapping) = &clbit_map {
+                    let qargs = qc_data
+                        .get_cargs(instr.clbits)
+                        .iter()
+                        .map(|bit| clbit_mapping[bit.0 as usize])
+                        .collect();
+                    new_dag.cargs_interner.insert_owned(qargs)
+                } else {
+                    new_dag
+                        .cargs_interner
+                        .insert(qc_data.get_cargs(instr.clbits))
+                };
+                // Copy the operations
+
+                Ok(PackedInstruction {
+                    op: if copy_op {
+                        instr.op.py_deepcopy(py, None)?
+                    } else {
+                        instr.op.clone()
+                    },
+                    qubits: new_qargs,
+                    clbits: new_cargs,
+                    params: instr.params.clone(),
+                    extra_attrs: instr.extra_attrs.clone(),
+                    #[cfg(feature = "cache_pygates")]
+                    py_op: OnceCell::new(),
+                })
+            })
+            .collect::<PyResult<Vec<_>>>()?;
+
+        // Finally add all the instructions back
+        new_dag.extend(py, instructions)?;
+
+        Ok(new_dag)
+    }
+
+    /// Builds a [DAGCircuit] based on an instance of [CircuitData].
+    pub fn from_circuit_data(
+        py: Python,
+        circuit_data: CircuitData,
+        copy_op: bool,
+    ) -> PyResult<Self> {
+        let circ = QuantumCircuitData {
+            data: circuit_data,
+            name: None,
+            calibrations: None,
+            metadata: None,
+            qregs: None,
+            cregs: None,
+            input_vars: Vec::new(),
+            captured_vars: Vec::new(),
+            declared_vars: Vec::new(),
+        };
+        Self::from_circuit(py, circ, copy_op, None, None)
+    }
 }
 
 /// Add to global phase. Global phase can only be Float or ParameterExpression so this
diff --git a/crates/circuit/src/lib.rs b/crates/circuit/src/lib.rs
index 5106ba030288..dcff558ade64 100644
--- a/crates/circuit/src/lib.rs
+++ b/crates/circuit/src/lib.rs
@@ -13,6 +13,7 @@
 pub mod bit_data;
 pub mod circuit_data;
 pub mod circuit_instruction;
+pub mod converters;
 pub mod dag_circuit;
 pub mod dag_node;
 mod dot_utils;
diff --git a/crates/pyext/src/lib.rs b/crates/pyext/src/lib.rs
index 43b693a4d6c1..6033c7c47e49 100644
--- a/crates/pyext/src/lib.rs
+++ b/crates/pyext/src/lib.rs
@@ -43,6 +43,7 @@ where
 #[pymodule]
 fn _accelerate(m: &Bound<PyModule>) -> PyResult<()> {
     add_submodule(m, qiskit_circuit::circuit, "circuit")?;
+    add_submodule(m, qiskit_circuit::converters::converters, "converters")?;
     add_submodule(m, qiskit_qasm2::qasm2, "qasm2")?;
     add_submodule(m, qiskit_qasm3::qasm3, "qasm3")?;
     add_submodule(m, circuit_library, "circuit_library")?;
diff --git a/qiskit/__init__.py b/qiskit/__init__.py
index d0811c172d69..41f9d9eba1b9 100644
--- a/qiskit/__init__.py
+++ b/qiskit/__init__.py
@@ -61,6 +61,7 @@
 # and not have to rely on attribute access.  No action needed for top-level extension packages.
 sys.modules["qiskit._accelerate.circuit"] = _accelerate.circuit
 sys.modules["qiskit._accelerate.circuit_library"] = _accelerate.circuit_library
+sys.modules["qiskit._accelerate.converters"] = _accelerate.converters
 sys.modules["qiskit._accelerate.convert_2q_block_matrix"] = _accelerate.convert_2q_block_matrix
 sys.modules["qiskit._accelerate.dense_layout"] = _accelerate.dense_layout
 sys.modules["qiskit._accelerate.error_map"] = _accelerate.error_map
diff --git a/qiskit/converters/circuit_to_dag.py b/qiskit/converters/circuit_to_dag.py
index a330b8cbd682..5be9a721bafa 100644
--- a/qiskit/converters/circuit_to_dag.py
+++ b/qiskit/converters/circuit_to_dag.py
@@ -12,8 +12,8 @@
 
 """Helper function for converting a circuit to a dag"""
 
-from qiskit.dagcircuit.dagcircuit import DAGCircuit
-from qiskit.dagcircuit.dagnode import DAGOpNode
+from qiskit.circuit.library.blueprintcircuit import BlueprintCircuit
+from qiskit._accelerate.converters import circuit_to_dag as core_circuit_to_dag
 
 
 def circuit_to_dag(circuit, copy_operations=True, *, qubit_order=None, clbit_order=None):
@@ -56,46 +56,22 @@ def circuit_to_dag(circuit, copy_operations=True, *, qubit_order=None, clbit_ord
             circ.rz(0.5, q[1]).c_if(c, 2)
             dag = circuit_to_dag(circ)
     """
-    dagcircuit = DAGCircuit()
-    dagcircuit.name = circuit.name
-    dagcircuit.global_phase = circuit.global_phase
-    dagcircuit.calibrations = circuit.calibrations
-    dagcircuit.metadata = circuit.metadata
-
-    if qubit_order is None:
-        qubits = circuit.qubits
-    elif len(qubit_order) != circuit.num_qubits or set(qubit_order) != set(circuit.qubits):
+    # If we have an instance of BluePrintCircuit, make sure it is built by calling ._build()
+    if isinstance(circuit, BlueprintCircuit):
+        if not circuit._is_built:
+            circuit._build()
+
+    if qubit_order is not None and (
+        len(qubit_order) != circuit.num_qubits or set(qubit_order) != set(circuit.qubits)
+    ):
         raise ValueError("'qubit_order' does not contain exactly the same qubits as the circuit")
-    else:
-        qubits = qubit_order
 
-    if clbit_order is None:
-        clbits = circuit.clbits
-    elif len(clbit_order) != circuit.num_clbits or set(clbit_order) != set(circuit.clbits):
+    if clbit_order is not None and (
+        len(clbit_order) != circuit.num_clbits or set(clbit_order) != set(circuit.clbits)
+    ):
         raise ValueError("'clbit_order' does not contain exactly the same clbits as the circuit")
-    else:
-        clbits = clbit_order
-
-    dagcircuit.add_qubits(qubits)
-    dagcircuit.add_clbits(clbits)
-
-    for var in circuit.iter_input_vars():
-        dagcircuit.add_input_var(var)
-    for var in circuit.iter_captured_vars():
-        dagcircuit.add_captured_var(var)
-    for var in circuit.iter_declared_vars():
-        dagcircuit.add_declared_var(var)
-
-    for register in circuit.qregs:
-        dagcircuit.add_qreg(register)
-
-    for register in circuit.cregs:
-        dagcircuit.add_creg(register)
 
-    for instruction in circuit.data:
-        dagcircuit._apply_op_node_back(
-            DAGOpNode.from_instruction(instruction, deepcopy=copy_operations)
-        )
+    dagcircuit = core_circuit_to_dag(circuit, copy_operations, qubit_order, clbit_order)
 
     dagcircuit.duration = circuit.duration
     dagcircuit.unit = circuit.unit

From dd145b54be9d583d3857edfbd81e910600249adf Mon Sep 17 00:00:00 2001
From: Matthew Treinish <mtreinish@kortar.org>
Date: Tue, 10 Sep 2024 19:53:20 -0400
Subject: [PATCH 68/85] Raise minimum python version to 3.9 (#12910)

* Raise minimum python version to 3.9

Qiskit 1.2.0 was the final minor version release of qiskit with Python
3.8 support. As Python 3.8 is going EoL before the next Qiskit minor
release 1.3.0 we can drop support for running with 3.8 on the main
branch now. This commit makes that change and updates everything using
python 3.8 currently to use our new minimum instead.

* Pin dependency versions when installing historical versions

Now that we're running Python 3.9 as the base version we are
encountering compatibility issues with some of our dependencies because
3.9 supports newer versions of things like numpy than older Qiskit
releases were compatible with. The only way to work around this is to
pin the versions when installing historical versions. To start this sets
a single constraints version since we can get away with using the same
version for everything. In the future though it is possible that we'll
need separate files for different historical releases.

* Update reference images

* Drop 3.8 support in asv too

* Remove deprecation warning for 3.8
---
 .github/workflows/coverage.yml                |   2 +-
 .github/workflows/randomized_tests.yml        |   2 +-
 .github/workflows/tests.yml                   |   2 +-
 .github/workflows/wheels.yml                  |  31 +-----------------
 Cargo.toml                                    |   2 +-
 asv.conf.json                                 |   2 +-
 azure-pipelines.yml                           |   4 +--
 pyproject.toml                                |   9 +++--
 qiskit/__init__.py                            |   8 -----
 .../notes/py3.9-min-now-c9781484a0eb288e.yaml |   6 ++++
 .../circuit/test_circuit_load_from_qpy.py     |  12 ++++---
 .../circuit/test_control_flow_builders.py     |   9 +++--
 test/qpy_compat/process_version.sh            |   4 +--
 test/qpy_compat/qpy_test_constraints.txt      |   2 ++
 test/qpy_compat/run_tests.sh                  |   2 +-
 .../graph/references/bloch_multivector.png    | Bin 72475 -> 75579 bytes
 ...bloch_multivector_figsize_improvements.png | Bin 70588 -> 73633 bytes
 .../mpl/graph/references/state_city.png       | Bin 108666 -> 107036 bytes
 tox.ini                                       |   4 +--
 19 files changed, 39 insertions(+), 62 deletions(-)
 create mode 100644 releasenotes/notes/py3.9-min-now-c9781484a0eb288e.yaml
 create mode 100644 test/qpy_compat/qpy_test_constraints.txt

diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml
index 95a0bda5d421..625ea9bc1f50 100644
--- a/.github/workflows/coverage.yml
+++ b/.github/workflows/coverage.yml
@@ -22,7 +22,7 @@ jobs:
       - uses: actions/setup-python@v5
         name: Install Python
         with:
-          python-version: '3.8'
+          python-version: '3.11'
 
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@stable
diff --git a/.github/workflows/randomized_tests.yml b/.github/workflows/randomized_tests.yml
index f807656a84ce..1cc39893c5ec 100644
--- a/.github/workflows/randomized_tests.yml
+++ b/.github/workflows/randomized_tests.yml
@@ -13,7 +13,7 @@ jobs:
       - uses: actions/setup-python@v5
         name: Install Python
         with:
-          python-version: '3.8'
+          python-version: '3.11'
       - name: Install dependencies
         run: |
           python -m pip install -U pip setuptools wheel
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 20e40dec9824..20c40dc38321 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -18,7 +18,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        # Normally we test min and max version but we can't run python 3.8 or
+        # Normally we test min and max version but we can't run python
         # 3.9 on arm64 until actions/setup-python#808 is resolved
         python-version: ["3.10", "3.12"]
     steps:
diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml
index d7c2b8c3f783..3314bae05d5b 100644
--- a/.github/workflows/wheels.yml
+++ b/.github/workflows/wheels.yml
@@ -41,35 +41,6 @@ jobs:
         with:
           path: ./wheelhouse/*.whl
           name: wheels-${{ matrix.os }}
-  build_wheels_macos_arm_py38:
-    name: Build wheels on macOS arm
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [macos-12]
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        name: Install Python
-        with:
-          python-version: '3.10'
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          components: llvm-tools-preview
-      - name: Build wheels
-        uses: pypa/cibuildwheel@v2.19.2
-        env:
-          CIBW_BEFORE_ALL: rustup target add aarch64-apple-darwin
-          CIBW_BUILD: cp38-macosx_universal2 cp38-macosx_arm64
-          CIBW_ARCHS_MACOS: arm64 universal2
-          CIBW_ENVIRONMENT: >-
-            CARGO_BUILD_TARGET="aarch64-apple-darwin"
-            PYO3_CROSS_LIB_DIR="/Library/Frameworks/Python.framework/Versions/$(python -c 'import sys; print(str(sys.version_info[0])+"."+str(sys.version_info[1]))')/lib/python$(python -c 'import sys; print(str(sys.version_info[0])+"."+str(sys.version_info[1]))')"
-      - uses: actions/upload-artifact@v4
-        with:
-          path: ./wheelhouse/*.whl
-          name: wheels-${{ matrix.os }}-arm
   build_wheels_32bit:
     name: Build wheels 32bit
     runs-on: ${{ matrix.os }}
@@ -100,7 +71,7 @@ jobs:
     environment: release
     permissions:
       id-token: write
-    needs: ["build_wheels", "build_wheels_32bit", "build_wheels_macos_arm_py38"]
+    needs: ["build_wheels", "build_wheels_32bit"]
     steps:
       - uses: actions/download-artifact@v4
         with:
diff --git a/Cargo.toml b/Cargo.toml
index 2f5fd8ce077b..15f34603c61e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -34,7 +34,7 @@ rayon = "1.10"
 # distributions).  We only activate that feature when building the C extension module; we still need
 # it disabled for Rust-only tests to avoid linker errors with it not being loaded.  See
 # https://pyo3.rs/main/features#extension-module for more.
-pyo3 = { version = "0.21.2", features = ["abi3-py38"] }
+pyo3 = { version = "0.21.2", features = ["abi3-py39"] }
 
 # These are our own crates.
 qiskit-accelerate = { path = "crates/accelerate" }
diff --git a/asv.conf.json b/asv.conf.json
index 70dd3b760e2c..a75bc0c59c3a 100644
--- a/asv.conf.json
+++ b/asv.conf.json
@@ -17,7 +17,7 @@
     "dvcs": "git",
     "environment_type": "virtualenv",
     "show_commit_url": "http://github.com/Qiskit/qiskit/commit/",
-    "pythons": ["3.8", "3.9", "3.10", "3.11", "3.12"],
+    "pythons": ["3.9", "3.10", "3.11", "3.12"],
     "benchmark_dir": "test/benchmarks",
     "env_dir": ".asv/env",
     "results_dir": ".asv/results"
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index c3154abf412c..49df19808498 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -37,12 +37,12 @@ parameters:
   - name: "supportedPythonVersions"
     displayName: "All supported versions of Python"
     type: object
-    default: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+    default: ["3.9", "3.10", "3.11", "3.12"]
 
   - name: "minimumPythonVersion"
     displayName: "Minimum supported version of Python"
     type: string
-    default: "3.8"
+    default: "3.9"
 
   - name: "maximumPythonVersion"
     displayName: "Maximum supported version of Python"
diff --git a/pyproject.toml b/pyproject.toml
index 9a16fc6e0ac3..689bf473e2f7 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "qiskit"
 description = "An open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives."
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 license = {text = "Apache 2.0"}
 authors = [
     { name = "Qiskit Development Team", email = "qiskit@us.ibm.com" },
@@ -27,7 +27,6 @@ classifiers = [
     "Operating System :: Microsoft :: Windows",
     "Operating System :: POSIX :: Linux",
     "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
@@ -140,12 +139,12 @@ include = ["qiskit", "qiskit.*"]
 
 [tool.black]
 line-length = 100
-target-version = ['py38', 'py39', 'py310', 'py311']
+target-version = ['py39', 'py310', 'py311']
 
 [tool.cibuildwheel]
 manylinux-x86_64-image = "manylinux2014"
 manylinux-i686-image = "manylinux2014"
-skip = "pp* cp36-* cp37-* *musllinux* *win32 *i686 cp38-macosx_arm64"
+skip = "pp* cp36-* cp37-* cp38-* *musllinux* *win32 *i686 cp38-macosx_arm64"
 test-skip = "*win32 *linux_i686"
 test-command = "python {project}/examples/python/stochastic_swap.py"
 # We need to use pre-built versions of Numpy and Scipy in the tests; they have a
@@ -197,7 +196,7 @@ extension-pkg-allow-list = [
     "tweedledum",
 ]
 load-plugins = ["pylint.extensions.docparams", "pylint.extensions.docstyle"]
-py-version = "3.8"  # update it when bumping minimum supported python version
+py-version = "3.9"  # update it when bumping minimum supported python version
 
 [tool.pylint.basic]
 good-names = ["a", "b", "i", "j", "k", "d", "n", "m", "ex", "v", "w", "x", "y", "z", "Run", "_", "logger", "q", "c", "r", "qr", "cr", "qc", "nd", "pi", "op", "b", "ar", "br", "p", "cp", "ax", "dt", "__unittest", "iSwapGate", "mu"]
diff --git a/qiskit/__init__.py b/qiskit/__init__.py
index 41f9d9eba1b9..25137d7a5918 100644
--- a/qiskit/__init__.py
+++ b/qiskit/__init__.py
@@ -43,14 +43,6 @@
             " Qiskit unfortunately cannot enforce this requirement during environment resolution."
             " See https://qisk.it/packaging-1-0 for more detail."
         )
-if sys.version_info < (3, 9):
-    warnings.warn(
-        "Using Qiskit with Python 3.8 is deprecated as of the 1.1.0 release. "
-        "Support for running Qiskit with Python 3.8 will be removed in the "
-        "1.3.0 release, which coincides with when Python 3.8 goes end of life.",
-        DeprecationWarning,
-    )
-
 
 from . import _accelerate
 import qiskit._numpy_compat
diff --git a/releasenotes/notes/py3.9-min-now-c9781484a0eb288e.yaml b/releasenotes/notes/py3.9-min-now-c9781484a0eb288e.yaml
new file mode 100644
index 000000000000..a58dc69f9e4a
--- /dev/null
+++ b/releasenotes/notes/py3.9-min-now-c9781484a0eb288e.yaml
@@ -0,0 +1,6 @@
+---
+upgrade:
+  - |
+    The minimum supported version of Python is now 3.9, this has been raised
+    from the previous minimum support version of 3.8. This change was necessary
+    because the upstream cPython project no longer supports Python 3.8.
diff --git a/test/python/circuit/test_circuit_load_from_qpy.py b/test/python/circuit/test_circuit_load_from_qpy.py
index 04e71a0dd4d7..db8663ace558 100644
--- a/test/python/circuit/test_circuit_load_from_qpy.py
+++ b/test/python/circuit/test_circuit_load_from_qpy.py
@@ -1948,8 +1948,11 @@ def test_pre_v12_rejects_standalone_var(self, version):
         """Test that dumping to older QPY versions rejects standalone vars."""
         a = expr.Var.new("a", types.Bool())
         qc = QuantumCircuit(inputs=[a])
-        with io.BytesIO() as fptr, self.assertRaisesRegex(
-            UnsupportedFeatureForVersion, "version 12 is required.*realtime variables"
+        with (
+            io.BytesIO() as fptr,
+            self.assertRaisesRegex(
+                UnsupportedFeatureForVersion, "version 12 is required.*realtime variables"
+            ),
         ):
             dump(qc, fptr, version=version)
 
@@ -1959,8 +1962,9 @@ def test_pre_v12_rejects_index(self, version):
         # Be sure to use a register, since standalone vars would be rejected for other reasons.
         qc = QuantumCircuit(ClassicalRegister(2, "cr"))
         qc.store(expr.index(qc.cregs[0], 0), False)
-        with io.BytesIO() as fptr, self.assertRaisesRegex(
-            UnsupportedFeatureForVersion, "version 12 is required.*Index"
+        with (
+            io.BytesIO() as fptr,
+            self.assertRaisesRegex(UnsupportedFeatureForVersion, "version 12 is required.*Index"),
         ):
             dump(qc, fptr, version=version)
 
diff --git a/test/python/circuit/test_control_flow_builders.py b/test/python/circuit/test_control_flow_builders.py
index e41b5c1f9f31..7a3a0873ae77 100644
--- a/test/python/circuit/test_control_flow_builders.py
+++ b/test/python/circuit/test_control_flow_builders.py
@@ -3464,9 +3464,12 @@ def test_switch_rejects_entering_case_after_close(self):
     def test_switch_rejects_reentering_case(self):
         """It shouldn't be possible to enter a case within another case."""
         circuit = QuantumCircuit(1, 1)
-        with circuit.switch(0) as case, case(0), self.assertRaisesRegex(
-            CircuitError, r"Cannot enter more than one case at once"
-        ), case(1):
+        with (
+            circuit.switch(0) as case,
+            case(0),
+            self.assertRaisesRegex(CircuitError, r"Cannot enter more than one case at once"),
+            case(1),
+        ):
             pass
 
     @ddt.data("1", 1.0, None, (1, 2))
diff --git a/test/qpy_compat/process_version.sh b/test/qpy_compat/process_version.sh
index 56743c613316..3fc34557b69e 100755
--- a/test/qpy_compat/process_version.sh
+++ b/test/qpy_compat/process_version.sh
@@ -45,9 +45,9 @@ if [[ ! -d qpy_$version ]] ; then
     echo "Building venv for qiskit-terra $version"
     python -m venv $version
     if [[ ${parts[0]} -eq 0 ]] ; then
-        ./$version/bin/pip install "qiskit-terra==$version"
+        ./$version/bin/pip install -c qpy_test_constraints.txt "qiskit-terra==$version"
     else
-        ./$version/bin/pip install "qiskit==$version"
+        ./$version/bin/pip install -c qpy_test_constraints.txt "qiskit==$version"
     fi
     mkdir qpy_$version
     pushd qpy_$version
diff --git a/test/qpy_compat/qpy_test_constraints.txt b/test/qpy_compat/qpy_test_constraints.txt
new file mode 100644
index 000000000000..03f798b3c01a
--- /dev/null
+++ b/test/qpy_compat/qpy_test_constraints.txt
@@ -0,0 +1,2 @@
+numpy===1.24.4
+scipy===1.10.1
diff --git a/test/qpy_compat/run_tests.sh b/test/qpy_compat/run_tests.sh
index 4fc6bc5b91fd..3810773ec0f3 100755
--- a/test/qpy_compat/run_tests.sh
+++ b/test/qpy_compat/run_tests.sh
@@ -20,7 +20,7 @@ export PYTHONHASHSEED=$(python -S -c "import random; print(random.randint(1, 429
 echo "PYTHONHASHSEED=$PYTHONHASHSEED"
 
 python -m venv qiskit_venv
-qiskit_venv/bin/pip install ../..
+qiskit_venv/bin/pip install -c ../../constraints.txt ../..
 
 parallel bash ./process_version.sh ::: `git tag --sort=-creatordate`
 
diff --git a/test/visual/mpl/graph/references/bloch_multivector.png b/test/visual/mpl/graph/references/bloch_multivector.png
index 896e513ef36849c1bf2e483f725f160286449bc9..e3036bc2ccb918533b669e8f748f3af8ca68a976 100644
GIT binary patch
literal 75579
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%0Ac7eZvl86StXLN*ja4%U
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

literal 72475
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
P1O8~J=qOhyT7~`}YPOq@

diff --git a/test/visual/mpl/graph/references/bloch_multivector_figsize_improvements.png b/test/visual/mpl/graph/references/bloch_multivector_figsize_improvements.png
index 5f5ba75d9428d1940aa8f3157c4aa819e3ef9841..c5a082e8039ac95dccbc6267a837c57cb562e87e 100644
GIT binary patch
literal 73633
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

literal 70588
zcmaI7by$>7{56b-hzL>(k`fXtAR#GTOV<KRNvE`QNJuwGH^?F_i*$pOG)TE1DAFJx
z(hcwM{aw%Vym4LcA1b)_&dfdY$#c#`s;kQ3<5J>cU|`@Y$jfM8VB8G>KlkHcgTFtE
za8`kTUb?|_-87x7+&oQPEHP9}-QL(cx!K#8(Ro<9xY{^5@^A=n@Uhdqc5{2<D#Xd@
z@V_76aB{Kc+{?|?1A{zxBd_O*fk9w;`{z!Hc(Dz}9SjTw8A&a#?CmSP7z>+B^n;sG
z+dhwj>3MTw9-eBKg$C5{9}dbQBB?xbd}7ML%s@3d`oQ$Sru1<P0atD_8^&+El%4O2
zriU3~Kb&oZ{Y8Q2%cAC=zTi0?c`7pBt>fBov_0hM{L6KI{-+4T3pRAb2}>wL*Zg+2
z`Py;ziC_Iq0i!}9U4lF#@xY_&>xG+(%iw^21nF5>%l!#Y7Y<j!2az%iXSnJen-Aar
z&oBQyED-F5!*u)6?QfAQ^e~~2|NWcH{(EG=<m1~>6P;L`+K$LDVr7@9+8+JS<Hj^m
zkd*(v_TRS?!%6gBuqIpv&9{1!z~F*!kGFHjyf1bd;E+&{ma96$G%){?d`qhQ6OoUG
zN{j^wkMd>q`TqT|tE{T6m1#4&|J(RxE5L8T(#xsiihoS>ggR6zkc36`U**kF$Mqi$
zErx`70plrDT59U)!+=H3fBjG6Ka{ZsY&l(3R31w)5fAtsz;@1Wt^#h1uY2-NNt9Jo
z;N{a^N7FiIV>f5w0lhkG3BE7o!_^tiD7jRUGBPM2urq_oEU-yxH=E)k1pfc-j^>IE
zEu6m!i0;_exsEch0B?Q=%qco%ZfhHLvlnnl>wUgi+<`1ll4mpy;j~4IpAD#;k_0TN
z{cGvCXz@K9m%IFZU;OvjWrlcn29I?+k}XBPUF4%Q)VqWN5BsvW<MeT<7VGfn=zje5
zxcE{<!>=D?RXUK+fRo+ppY>=y%2>mUW~DTaJ+LpPdSq%Mdsw@z2ddXKi^Rzd3;tQg
zH%G?Blbau)xKYS|CpXs%wBCLlXIUKs;{|eOayJ{a&VQz!U4LCTrMgVJSq&HvKV!LB
zQ98$BOuQfO)M7~c(j_F|T<zvrz#ivyugF9C1o^+C4L?x<%L4wv9T%QA9GvZ^3@mE7
zD*@MeH`c1TA_D=Z1UHNSjZpb$lTh)A?e*xwnQ-gDsPN@Qz|HR2)xwS6FaHY%vFp=i
zPTx;A#~oKrFJ0I0D%;Ol1J=eaDfBD8qt@Gwf7o4qb-Ki^(~m7IWJ(2xxO?4l<G8}D
zmM1ns5OCV<5Px;M+LwOkhmV_OBUem+&pD!jO&%N=)@%vJZ65i=#K#BZ+a=4ltKRPC
z>&=sk%b|cX&a?2Ff3*8-9s6t|XDdmUSpf%5INkpq((F22#&&e(UAP9sX%?&QbzE28
zupRm2fN$KaqSiBt6xxjB;1DY-tMrVFe2vl=k+uE(7b8}#bLJyfNsbNC%Yw!mLQIMG
zGj@Z3y(W(Jd5)uQ7R4{a4=?<#%WwX4oJ*mh3BEb~FGCW;Q@7BS%NJst9hWZGGpDD5
z@nYv2kA;4fSGH%~yh6Jhc`e@KFls%0Xk0AA&=hd%00d7K_*$-a7OowxJH=1$|F@YL
zxw+R9allLww`SUOKMMKT)xeq%%Xp~C+R92-PjB{kW^fP}?4eoJX`Ml^%s$<|%8xqW
zS+=MAGe<XP;M6WtfbE|CcYHcS;WGOUu+$jEC;D-;;&G<rttY?Uo|yxaH)wLPoI5Bg
zD$>>0AG`@T`h&2a`{my1x!@;o<4GQNYslF`?zSsUDwB*+$hStz;7tbO{SOPkF?G^j
zcGhnc$uP_=wV3>OM0<u+TLBkNH_tn+w>m~Ut{QGq#jlEQ4*l9>8P53Wcy2dHv9K%P
zVBu2WGN<FfGd(@s#K$M|W-;KDR(*QMInnrf)p#xMswUtom`D)<yF3Ao9B)eA5_d9o
zb0)sNGLQt;6BV$pcKrY>|8lkCGEFY`0z@}(8emzpdxw*1nye|%6vdX@6ZG{D<K_QG
zTexZoNCVH_ya+gy3+TCx4hxrkH>b26*#wdd-d|2RX87I{eEoZJ@u{N1`FLATd2(g1
zkM^cl3?p*o&I)+Hj;pzj5#w{EfXIMz;5gufUknWmVL+l`rOfPS#~=_8aJLz8o>ks#
z-3UEPQB<gzRldIUJ%wMs2O}#^*CQPn;?~a2+-K9qSJNL2I9PytDf^#z1_+d*w+3#m
zJ8pIr5*Y{P=M69!Zzs!XJ)BUAw8<P;ju+3p9H+g4`^V7Uoc29<Z|~^17JpUOag0uk
zjEuyRzy7sw@fMs-e8A=MN``f=g7Tzt9F1^lo(@Ao%o<qx7nFE70qwPmI1YH3CE!m^
z?PqK9E!Ro`o1A`Uv|%#)Oa+Vsab|WP^sj?hv;+oO6!2dbXx~%<q1~8x0tFm^zy?h`
zkQTg6pZvcwM`Abx#Df2l%54f5kd9)fNcq2in(_bp@c%dI44{WQ&UJ30K<M+EOao!5
zUFLtB1gwDI;RG119rOB3{AQi{r3=<jwb$8dn)l7s$w6Klu;|NZ5YE~={|m}kw~Gx9
zueFPm0l91-t?QLjTguJF&3VT)=k@Wz_1tA!$H~d*>2mySBtJ_67FFHcjQi!*T2dFz
zau&|QP`9au^Z&fMBM3JMz5|!b0hjS-<pD>P`&+=yML@i}Tywf+F4Tww|94G_0U}UG
z7jVz@(VUC0%Kzse3Q^#l6FG?%PR=$8;!hU|0@B5c%2>rO7YRVb<HZ2E4p@hA3S2I7
zMK}noex*|yICgdDe_u;DI&w!sk+b%WZ(C>Wt6N*MZ;Vs(<rx=f{`V#&KL2l(cQ1cb
zUQzCL+=y*$Z7m!Yg51sd;D2q&K=-@<8E#-efmg-c($aEnnT?HYczAf_CNC?iVEpyB
z*Szg(Y~Y;p9{;Z|MOr+(J!)fyBAflogRz4G+AC-Pdz|@yPWPw05?JKu?&YJ7W4n$p
z)Yd|er6P!xf&cF}$mqCgxZ%H<1L<M!)+H8~dZRBvUPs?%#q-J=pX=<~&0ie5o)y2q
zH!1`nP2~R+3(sE6)8C%JtpVu0dbJ#Io_EcXnwI9hmSKH*o4i+Jw_IIa4cdJ(#E*)v
zrv!WpLFVvJ@OYje;&nTWMlz_6oX!~-6T<_ID#MorFTXook#*c$bd244^=4K(W2DUf
z!zIB-ZAS46=M@V}1lPX_PTLkP+MLc4fq`>I>|VGD(Ok#hEZ_VlxcNtL_H*It=j~^S
zm5^Iw|0@ZBg_x$_;J=q4f<uVz-GNh+oQgS<6G!za5HCR)h$>I~X!{P-A)(^_>ooqG
zN9c?eAJT3vF6E>kOVdnd)UNp)f2?e<OH&LIy0D#<CjUfzNst+@d%ix2kzRoqNk<pQ
zfaGGt37Y!byU^{C!}uU~*If7!PK*E5v`&-rDsD5%Jd?S|68@RJ3yMT<!7H>&r)_Vo
zxH4iGRdXa1w|wZlrwa)y6^-s#hBBxUCkl?<JnDKM=#T^k*-6o9^xtFf$(QKl<;K0I
zJj4)Zetsp^YnI^C7FT4m@UJCJzFqJI@PzHat!A(l=WS2gmw)>_X<sKg^>6mVkRd87
zGR5svg+mCLQz*0{VTagv6B#81Vx~%!iKBWMc4G0hwYACduxC(NPXyu=Fs8Xm(6-c~
z&OvD7fE?Spb9_Hy;JLwIpIZ!l+Mb{smRlTc(Pl~M7z)(ENOdkeyl#m}-b5M?nm+C;
zqj;#oH+RtmU9#uV{vBic6U1%)w0-rO;Up9I#bp}h+Oq*0gq0oF=O~KTw?za=7(F;y
z)#6~gIWJW7?gdu68U#ziHUOi@)Pxed?9J~NbJ~d^<Y0MNrs+T0-au5k>2RgVcIWfa
zJ1;&vNI7@(f8Tbg8$2Awt86=_1W`3LkaoZm_trI}Lrmq1Cr#bGGbB6W*PDCHOuuQ7
zBJA-B1XTs%6@rju(07=+siBs78_jW;AE0>Hcd5}ZG;diQrJbGK@Yq;QeX}BY*pwY#
z)ar{O8zdEWGm6CP32J?@k)uL8nk(+5*FQSW_I=!oligx1R)t=k$Q7|jnJ`BO_Y}vL
z*xlw3$#<Evb!A8>E}Wd0>47tKF@Hr-vt4Tc(qp`*q92gpkgoh`@4cSd0z135wytNW
z*Xe3FxcXvRAAgeTTZlPD2t8_Rsfhz5R>9mpx0(UhG4Zj;B$j7sLz`{Vj*Lu+Z;AW3
z>m6#En-z<vyADL8#-xe(bFL!0-pdPm;Qm*Pnvi3s_MbnC!i<t4533cX!LY5PY~SVa
zJYXJDQo=j;`(&0N+ZJb<xk*d3awNi8x1|~$=%8uG>vikGzev>7OSQOaTtP_FxGnBB
z_CyHK?i7a?wcpX3b#sgi`^6O4sit72=A!&fpXNxd<oTC)GMfs7FbPTrc6~CYAxv2Q
zv~6KVuvr4gA<oO^?plV{wmz9p!wEDwQq&<#oSd-*(C4DD%dPWn?(QimDWqM{rG&mG
z%l{U;rzr9N90@HiFO$#8A{Y`d2(j*<w#*2y?NOCAO;ri0L9#?)rt1CndXpL~%7}43
ze1tt&Fq8oY(>K9T{#}r%`m+>ut&|auEH1n%_UO5TgKY7DTypZf^xyr9-DkruLZ?s#
zg3OR(nqF>6!f&>9py=vyHhe_;vTHz&wot!()x(gTtfMqujp0n2IO;>xvS972=ltK%
zlc}+Svgq1cd};KgM7-&T@;}<&<Peca98R2nq68tqMRt^yL>4<oK8?BIrsTB(0=I>?
zBO%xK*KhuPxdW=ZeY!W<j5f30)axgy(5M;v2EAt2aH9^jn%R{-mfR0w{IYfWmcG6Q
z^}+J(DWK-uS0@gmk6Zq>dqQ#O<EH;yzk&?4E1js$rGguZ*{mx=45KIVldU@S3`0U~
z7&Rs(k`ptL;r%aE?9rC)4zcArC_)&KT>O(ljS6HLYn|dfL-e>Cjr8P%dBi6f1|QlN
z#gneoqyFd5?6$V3h1?=$XZ1cQhPpH<w~d>CWgN38Jh82g30xLD6ryR)$^xfPA@~R*
ztf-K}*VInW`!$1NFNj)7?WC}QoE{kqeEi9tDR;%x(4A)c`Z<FZpA@6YzI^F$u=5hr
zyo0@FnR|~P6|-JLm#Cc+KVV8i7VqCl<1jS)`~7+52y^%&8l)D7W|>yWgTBw>uRoNz
zC?>BgGAa;L_jT4gU|)&lXh)C4;y1S${V>WegFI(*#|j^80ihEPS%NA$5bP^|;24B0
z3##VGs}yK)EH`tsb-vq5<DC34|M8{h$acG5Nv14Z3&W-?6FWgBRFdpl>@qn_i}0T0
zmyuTujb59?ppZB3i`PVHL3LQQZ27+S^-<8$rul^@I^lzoM?}jjSFT}hgeUN)DvOhZ
z&K*N^6^P7}Sp7-^FU;s!iF%#e6Nd4i^oH*)>ArYSBL%Iv$UnEX#?WFZ^HXLEdJ_*-
z|MR6qz)KLU5cY=%_&$`G0a*&gb*3h<%+g9|Iz6lzYjjz~1qWtnWrZz{R}}>tOu;Qw
z3<c-%=cw5YkBI;u80?P6?99xEnkvbTxn6fe2tA}=Qz-NkFCJ0Pz_v8prDgQ`*LThm
zXw&E6FU~m2<Y;HmsdRc!m#w~t&lOQ9)SxF!xwonj=~5b!c`rId)cPhaDMTJe%W~CD
z!1340a=e%s=&niPMS|8ZAh`FU%t&5}ijMU3g#0%@95TLpVpFFNtQ$lE!Fv3Ub`_;t
z8$}A^)%Dvx{bEbXP}YZQRtS;VJVyFMKl=r>i->}V={i22oJU2b|M~}#Vq#-gx84j?
zmuR!j4Z=wgBRe7r#9cI<OLfx-fB$n{?ffrEYT~iG7q5#HN;UFzS-JW6dJhk4?e8S`
zF84cqSjqo#Afm0Kqi1MX_|q1o_ArztJLC&*<TCjrFGV@J3hXUn9RIEgVv@=?@jX<L
z@@i<Xql?fO2kwRR{&~Mv@as2TU`}jGN+AkT724+2vy3>Hz@dszBr-%s<j9D`S_d=U
zt~*n__=$|}<oI_DC%yI~S)l36>tYu%emp#&LgU&vn$dk#fZkaWdUPZkyt!$km&xG$
zfr6uDetw4TjiItiH<t=!9cADyr~>M2Q(T&|<&F_5N(kxji12M8Jn0}V#(#bW=w3Bq
zV#B^~?ydfLtHPfDkP(W7Qm$5E>K245-SR`@K^Wa9lQBKtUM3EsNJC|kb2gjfP+Qb5
zeba+%T+R<|ii(S0dTf(lb-w$%#@wcQU+0j9KTD+y*(Jf?O&E!c@MsyCm>{Ow+G-5G
zlZiCRWRA5>;llYQbLLT}KeD4gd1UaLsisBnRZXbv8*<obZur&(mZXFkdAf7V?!~9)
zoRhAG#0X0>A4=F{L;+4WZ=@fsF}1m1bYcbi!G}^?%0}2sT@m+7zTPaSwq9ZJYwm*v
z$G!Q7oF)X=hoEf8dDOl>zUh{pn_D#gx<4j=g-Ti|B=LSGG)mXNz{1;`qObmeXnYU~
zI6deTA<85R2kM9vjnWWHy*VS=Xm*oS7+x3Q!igp~1#IA^9`_zNB~!xRXJU%fuCC_6
z8l^IXSk&n`h0q==>OOiLX$Y*77cVL`g#+rW3}r}gh9vZGkE@4}pqYpYIqnlYu>hIo
zMEvv}?e)L#7(Pl~N_?T5M-|hEAi6Kk)L*}T1%2=bb*Qg&$DPQPA(l9EP$4zCu0Oi+
z&zm{m(n|4Z%bly*Z7yk!vmsArOL2(PE8<U|b%SO%GAitk<X~=uNy17V`n1Ovm9ft^
zr{MN(2!#_+gAqT*A$Lh4ltVz2Hc^1PydBL}xu?-W*48!aZqux4ZXdG@fVJ7P17%g!
z3393eqlyVCycq+-kra}xBOwwJl4Qlg%9CJF@ku2zg0x!o`LjgvB>k~pEn_~s98Tmx
zb5HU|cd^Y>`Lx5GvBim9I-H3k{g~8#IK-{{gDttYxTz#sPv3wslHrkxT1|VCLV>~8
z7bCUS<0lWg-Xm=^$f=~KdCl^1p1_DqsS6@*?uNia*1b!UN^HoRN0Zb<d;4euh7S+j
z%I>IFydcMW-7wb}msC!xrlK++fm)%GyoEI6mjtbxofCR{VIpW)Bm*9z5MBXZMv10_
zF@JK07^G~JW~o+v+b;r4>U`Ps(xhIq?h>ftlUX!xEHrLUG+t0a*VuUd^6X%0%RTPN
z%dT)*zn*B$)_10vUb*)r2*b`Us})OSDzw4&6kRDUt!F$XkG_tioBND=N%#BeWTDuA
z<6w}j5*T?I@^@r}IaabQAAple&|6csd>M%MzM#@FT>W10YNlR=I4r$Pu~5s**FMIj
z6e~)q1Ks@)69UVJSFTs8B!<x8d^QvyMfPuJx{+i=%59oWVJQS{dH29&Di_u#)x;zP
z@ZxBNzp~`{50+Q91{K+Op_HVWiKu7zxou`&SLhcSRjeV^s-VxJySeJ@&`dbp4piTv
z3W5jYa$b^OINSEH3pJiqXyHin3)5WEeb6f9nznzz&oA3%l(uS>xGS>bk=4}nviT=R
z2tBrXEju$a^TfWLN_W+cn}}xON7tKb{|iR?2;@}Nz6gUU+S@p<q<)~sN*&=lrgXPa
z@(W9zuhegEk?S6kjposd-HtKWF|lZrjm<yixXoF9c%phWyKM^Ykv{%VwFV3CtMbq{
z$+TFf?P}1!k`#|QjBdT;wh8z;L!MbiEJu`MM1XeYQet8*E=o_&{%BOWUcp8@fDSZ(
zF%nS6Ex*~EU~0~JqzEy!r3ALRiC?cSL8O|pbs@tbWz3PLDW^Q&e|KT*ZFqG=hYdNj
zEQ(%HfRqjn$?n8JpTOT03VSyCp1lZv^kgLgR9|yDNQ^pLQkB~<4x@G|_&NIa!Q4-d
z97h4e*JTJd!?A*BiC-ABk1Tm1u*Iq6cvk=tIsR%@aJ9mgK2%guR-M>7+CWuK{+u!K
zxbZKtwju{9JWFoCGm#6g3Csif@UyV0U$42eD>d244k$k8J@ZUt)PlWdfl!DooZOjs
zVqzK|R+JyL&mj%PO=1+x1??#`s%veHd3`jm7+$_NTr&pdn7EKF4Y49W`>KL=*U!po
zL`9>@4$u9-nWea7_*A4?k?_UJ*jw=AXK=+u%A~%)!F+P_>%<FyBuy@7FXZBB)pmaH
zQqWSFo6Na28#eFoYmPAUTpSOuVhnhu3dS{gA22sKEyzBQcKe{g!Nd1b;hE+vX%|=A
zdIIAEQus9u4DN`|_@|kAH5Me){Q9Qf$K7v1Em+~*a&z|83JI^u@{#d56E7^^Y3_BI
zVySKqB+wl3>7su5Ln&)L;YYSq#VNZw5zWfTw-Fp6#SHL!pvE>O-v{ZrcFtimPkan`
zeJIKX<bROFP?l9qO#>ra=*`->ZQ(Z(+IQsJwO2;f_a&-YTZe&xM~D*8q-SSaxR_z8
z$ZS^6zEep2-OTZxgZg+BFPqT&8Q!xf$!0H0iY_iZ05I4zMIgWF8?WydDrNhw5as$V
zJ@}EM`l}ID!kVHO8t72`;uz#*{gDf-i(pCCnDO1oO%Krf05AR|6(|v*Ch>>-PbPLK
z<^%PLX<Y+d6Mz5QO)H*QW$ZhdMQ|>aCB=JV2aSGPWWh!RyT2uivQ(P9lYNUp&;lsy
zy<)VIQa>fWRZ;PHPwSWnb|q9$3a*8A527>SB45dp!5{^JS=EH>bl@*O9AY}>@k96%
zbf$j9I?qoQB<3_@{|x_*yl9ONP_02rd&J1wMAkxLME(=|Ieyf-!<@u-TRz3qlwSfp
ze4Axa9D}1IAG9l74>#bzMhEh{!vkw=B@hVZ$&dP_pbuml8WIe?le;yMosn>BqquYR
zw>J87L}f~_NS~EkSU3x%W|lMZ#!$d>)C~SJDdn}44?#bsbdl*t)sLr5Qj}QL4#Ezb
z>X0tF-`mA`W~8{Sdta$aUz9)}#xIkX>-MmcO~wRJ151B~D>p^b$uQ=w=Ru7(`O&Dn
zkQ7%Tk)RPBGWe#GSMyFY<KiCZz6yA(LDQW)WGOW_TG^ys&i&cp2Nl)KmDu0KZeDAv
zl4)DxT~673bp{%#fxCgb7xT^T(J6&Y#0$k*(Ay>_Dz%Pjf<ZnJOU-`blCFOpL#hnd
zDwA0||Go8k^^-0cd8NBEalvegVhDt#$(*mpUuwCyC#$6_dBfA#;bWi}28HRz1r{94
z^Lmv+Eu=>2$1ALQl}dE?fuDU}{^S;%HDzMB2(>Q7qi2&P#aeK)a?;*6x7!MUgej_6
ztqta=H!m#f1iw~)s@3Uq2gXJ%>~D}-Am4rzV%op7#PIOp!yc59B;w_p-xzg@mT898
zW4m+wx$AKDl==sK>1N3>^g+T87&OxrCfIOuw~7kqDUiOdzP{OMM!wvSQw9<8y$i4*
zhDdV}c)j*#cF--^76vUhA6{G?<}NlL-oG0|f2Vv~L~j8p^@lFkXPf&rHre^*NXy0j
zj?}Z$qhrIBW}p1H09x@K%3!1Tr+x8GY<?iK$6APfX>k12<4LV-Vr3OJFfiad@}uZ4
zO&=JO8r=&SMTD7>LweqwwkpyoNJI?LedRy8AAISaS+uu!pZ3EuT&LDO?0ZAVxlO`{
zu%$yw1%HmYdS?*=L-aH4@~JXJ5ZA}a&5xZ0bS9P#_$reCeP}X|XnZoGK_cdI2-QIu
zS=u-!fP^MgXP2-!JeqZ{X3c5d<lC0>X+P0dX6E+Ph1iuvz(<1Y^wTjdOTcMjVP58e
zG-WLI{gWLfrhNMN9_#49E$>eimCNC#tkRrF*P<ErzqV^+cO93NeSXzz4tT-xO)|aO
z$K+^zC0u<nfk*N0FcBvV<V2Z9A=Nq3HjggeGve6`=O~nH0p}VlBt~sb?09S*UjV?u
z=Ss|d+`PnAU+e&9FBfD)kcw7*OqaKwt!4E@1?@I_A(eZ%RJJ=YK;8eTD@Pd5M^x2s
z_iggvYUQEl(*$3*0ebaoER~ypfI^Q~xb*!;AE>ZdZ7ON(pLw3QtJ#^~?Q@^}WrXPc
z<~}S%|NP_${lo`W+$utUiU@X5`)63!D=gxj)$B%oN7HUe%=`|sZA@}-P_%BYjXQs)
z3D;=Kj*=yf)=h<xhXGiJf6hS!Z8=^K$VJfZ<VO>0z~B)?vyX<BHWs^we>QeLjTey`
zsQwrF8d0PzLP&fWxLecSJosT@y{eD4Sd9Oe^h%pC(Kv<+FC#0<+|@6~gzJNa9`$@f
zJeVjhGH_m-WbYCH9PJJTtcpg7HtAOF{!W_v2#A(^&6RV^^B3NFe5&KsUMGh(BIwl$
z+DnX~>iVz3RemGd80G5ycezo^>g*7xK3S0|*Gq26sn_3jj$V5THMWoK|6zp<nfdxs
z^OT#ASKFx|yg^zPe7lBs%YB+33AOJQ7gkEXvmqCZOFAa)<EE-03--@TiWmLrR&(Zl
z8O2EOOv6-aKc{GN^Uc9m{CU;;chfU6m)?^z2ybICzgxd>lc_W!3@eFB6w*HuT2-_}
z7je5bCo@VujqN|V@I!J9D@l<4UKhW4Ic=K)qU}pk2Y9j;uUSR>9xZBbzVCy7eI~6A
zV!HOel)S~s#g)VQluA<7o-;sKG%Ph>`CwXW@0UA%goP}#cs+s&UWY3R`czbat3hI>
zTEZ)}C%>LZ1)5dKllK9j&V26ht*F@5srmWOzdGj^fak!ecW}M>gUD75?>R`%O#l5Y
z@NVfF;uSqCd8KD9KRJFH5y)ALRqy&2>W>J-Qg}D9luD;#wE5>r;E1I}!J<-oH$4}a
z6o`!imSaUU-{1G~h~TlzY6tCKS{hibK`nC@kA68iBPXZOfW!PXW&QH!#zy%D^xb-y
z@+C$ZN5B09xi@}!XLAj38H_URQosO!e1s%3g>Vxh9_9f){QM6q@jwIq!by|=mC#iz
zKIWVia{Twd&frqq&${I``+w>1Hcxy&O@YnOqC+~{WLu|Lr7l6^f*o#+S#DOpA(5>4
zH2F(;3a<5NuBEGM658k%?#;xVh^WU?K{Pl-)uhI2RHdg@vEqWZlFM#c9RfiV>Q}s&
zwAZMd<_a+x$th&w7tYbL6x8HYB}OtX{>zspFB+IG*P&P7!Vk7>8rH3l9k131HB)&?
zxVqK8?!0;F?YPi<lyVctNWck@6kltbhPnC7tfwx9ZZK0H+o-)gXD!3Ar?Jk7E3W?7
z!IHmL97u5izr2p?FKivUll;qFG~TG;VN~Mr!-&pZ@vGS}FcI4L?ehg3R)ru}pGPMG
z3)12>gNKwG9qy0TX>XkU?NugAl7~t@+U8$%np_b2O!QmS%npMosB3^H{Q05ZPG?Cq
zzBY^ps2;G}t}MFrJ1;+Jv)U{qZgAovBLH&s1tjA|%!<0Y%0D`c3BHc@b8BDg?66Qu
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

diff --git a/test/visual/mpl/graph/references/state_city.png b/test/visual/mpl/graph/references/state_city.png
index a9af6d8b87f260de8510bdc08706a7eae01e8388..ecbdb3c3d2bca809ea91576badc66f7a17b0079d 100644
GIT binary patch
literal 107036
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
GtN#yV2F`{6

literal 108666
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
C+Dc3S

diff --git a/tox.ini b/tox.ini
index 89dc84d1758a..a0c5665695d2 100644
--- a/tox.ini
+++ b/tox.ini
@@ -1,6 +1,6 @@
 [tox]
 minversion = 4.0
-envlist = py38, py39, py310, py311, py312, lint-incr
+envlist = py39, py310, py311, py312, lint-incr
 isolated_build = true
 
 [testenv]
@@ -15,7 +15,7 @@ setenv =
   QISKIT_SUPRESS_PACKAGING_WARNINGS=Y
   QISKIT_TEST_CAPTURE_STREAMS=1
   QISKIT_PARALLEL=FALSE
-passenv = 
+passenv =
   RUSTUP_TOOLCHAIN
   RAYON_NUM_THREADS
   OMP_NUM_THREADS

From f2ca9205e351cfe754b0050c5c0c3e189be6178a Mon Sep 17 00:00:00 2001
From: Julien Gacon <jules.gacon@googlemail.com>
Date: Wed, 11 Sep 2024 13:55:41 +0200
Subject: [PATCH 69/85] Fix an edge case in Sabre's release valve (#13114)

* Fix edge case in Sabre release valve

If a Sabre trial does not find a set of Swaps to route nodes, the "release valve" adds Swaps to route the two-qubit gate in between the the closest two qubits. In rare cases, this leads to _more_ than one gate being routable, which was not handled correctly previously.

Co-authored-by: Jake Lishman <jake.lishman@ibm.com>

* add reno and test

* Use sensible syntax

Co-authored-by: Kevin Hartman <kevin@hart.mn>

* Use sensible grammar

Co-authored-by: Kevin Hartman <kevin@hart.mn>

* clippy

* Check if the new test breaks CI

* Revert "Check if the new test breaks CI"

This reverts commit 01bcdc7ca225220e7f5a319e2ef52f626251610a.

---------

Co-authored-by: Jake Lishman <jake.lishman@ibm.com>
Co-authored-by: Kevin Hartman <kevin@hart.mn>
---
 crates/accelerate/src/sabre/layer.rs          |  5 ++-
 crates/accelerate/src/sabre/route.rs          | 34 ++++++++++++++++---
 ...x-sabre-releasevalve-7f9af9bfc0482e04.yaml |  7 ++++
 test/python/transpiler/test_sabre_layout.py   | 25 ++++++++++++--
 4 files changed, 63 insertions(+), 8 deletions(-)
 create mode 100644 releasenotes/notes/fix-sabre-releasevalve-7f9af9bfc0482e04.yaml

diff --git a/crates/accelerate/src/sabre/layer.rs b/crates/accelerate/src/sabre/layer.rs
index 899321a96681..dec8253ad282 100644
--- a/crates/accelerate/src/sabre/layer.rs
+++ b/crates/accelerate/src/sabre/layer.rs
@@ -70,7 +70,10 @@ impl FrontLayer {
     pub fn remove(&mut self, index: &NodeIndex) {
         // The actual order in the indexmap doesn't matter as long as it's reproducible.
         // Swap-remove is more efficient than a full shift-remove.
-        let [a, b] = self.nodes.swap_remove(index).unwrap();
+        let [a, b] = self
+            .nodes
+            .swap_remove(index)
+            .expect("Tried removing index that does not exist.");
         self.qubits[a.index()] = None;
         self.qubits[b.index()] = None;
     }
diff --git a/crates/accelerate/src/sabre/route.rs b/crates/accelerate/src/sabre/route.rs
index bef6d501b4aa..0fd594993943 100644
--- a/crates/accelerate/src/sabre/route.rs
+++ b/crates/accelerate/src/sabre/route.rs
@@ -27,6 +27,7 @@ use rustworkx_core::petgraph::prelude::*;
 use rustworkx_core::petgraph::visit::EdgeRef;
 use rustworkx_core::shortest_path::dijkstra;
 use rustworkx_core::token_swapper::token_swapper;
+use smallvec::{smallvec, SmallVec};
 
 use crate::getenv_use_multiple_threads;
 use crate::nlayout::{NLayout, PhysicalQubit};
@@ -286,7 +287,7 @@ impl<'a, 'b> RoutingState<'a, 'b> {
     fn force_enable_closest_node(
         &mut self,
         current_swaps: &mut Vec<[PhysicalQubit; 2]>,
-    ) -> NodeIndex {
+    ) -> SmallVec<[NodeIndex; 2]> {
         let (&closest_node, &qubits) = {
             let dist = &self.target.distance;
             self.front_layer
@@ -328,7 +329,32 @@ impl<'a, 'b> RoutingState<'a, 'b> {
             current_swaps.push([shortest_path[end], shortest_path[end - 1]]);
         }
         current_swaps.iter().for_each(|&swap| self.apply_swap(swap));
-        closest_node
+
+        // If we apply a single swap it could be that we route 2 nodes; that is a setup like
+        //  A - B - A - B
+        // and we swap the middle two qubits. This cannot happen if we apply 2 or more swaps.
+        if current_swaps.len() > 1 {
+            smallvec![closest_node]
+        } else {
+            // check if the closest node has neighbors that are now routable -- for that we get
+            // the other physical qubit that was swapped and check whether the node on it
+            // is now routable
+            let mut possible_other_qubit = current_swaps[0]
+                .iter()
+                // check if other nodes are in the front layer that are connected by this swap
+                .filter_map(|&swap_qubit| self.front_layer.qubits()[swap_qubit.index()])
+                // remove the closest_node, which we know we already routed
+                .filter(|(node_index, _other_qubit)| *node_index != closest_node)
+                .map(|(_node_index, other_qubit)| other_qubit);
+
+            // if there is indeed another candidate, check if that gate is routable
+            if let Some(other_qubit) = possible_other_qubit.next() {
+                if let Some(also_routed) = self.routable_node_on_qubit(other_qubit) {
+                    return smallvec![closest_node, also_routed];
+                }
+            }
+            smallvec![closest_node]
+        }
     }
 
     /// Return the swap of two virtual qubits that produces the best score of all possible swaps.
@@ -573,14 +599,14 @@ pub fn swap_map_trial(
         }
         if routable_nodes.is_empty() {
             // If we exceeded the max number of heuristic-chosen swaps without making progress,
-            // unwind to the last progress point and greedily swap to bring a ndoe together.
+            // unwind to the last progress point and greedily swap to bring a node together.
             // Efficiency doesn't matter much; this path never gets taken unless we're unlucky.
             current_swaps
                 .drain(..)
                 .rev()
                 .for_each(|swap| state.apply_swap(swap));
             let force_routed = state.force_enable_closest_node(&mut current_swaps);
-            routable_nodes.push(force_routed);
+            routable_nodes.extend(force_routed);
         }
         state.update_route(&routable_nodes, current_swaps);
         if state.heuristic.decay.is_some() {
diff --git a/releasenotes/notes/fix-sabre-releasevalve-7f9af9bfc0482e04.yaml b/releasenotes/notes/fix-sabre-releasevalve-7f9af9bfc0482e04.yaml
new file mode 100644
index 000000000000..17432259be29
--- /dev/null
+++ b/releasenotes/notes/fix-sabre-releasevalve-7f9af9bfc0482e04.yaml
@@ -0,0 +1,7 @@
+---
+fixes:
+  - |
+    Fixed an edge case in :class:`.SabreLayout`, where in rare cases on large
+    devices and challenging circuits, the routing would fail. This was due to the 
+    release valve making more than one two-qubit gate routable, where only one was expected.
+    Fixed `#13081 <https://github.com/Qiskit/qiskit/issues/13081>`__.
\ No newline at end of file
diff --git a/test/python/transpiler/test_sabre_layout.py b/test/python/transpiler/test_sabre_layout.py
index a5ebef43540f..7565ee17655f 100644
--- a/test/python/transpiler/test_sabre_layout.py
+++ b/test/python/transpiler/test_sabre_layout.py
@@ -18,16 +18,16 @@
 
 from qiskit import QuantumRegister, QuantumCircuit
 from qiskit.circuit.classical import expr, types
-from qiskit.circuit.library import EfficientSU2
+from qiskit.circuit.library import EfficientSU2, QuantumVolume
 from qiskit.transpiler import CouplingMap, AnalysisPass, PassManager
-from qiskit.transpiler.passes import SabreLayout, DenseLayout, StochasticSwap
+from qiskit.transpiler.passes import SabreLayout, DenseLayout, StochasticSwap, Unroll3qOrMore
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.converters import circuit_to_dag
 from qiskit.compiler.transpiler import transpile
 from qiskit.providers.fake_provider import GenericBackendV2
 from qiskit.transpiler.passes.layout.sabre_pre_layout import SabrePreLayout
 from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
-from test import QiskitTestCase  # pylint: disable=wrong-import-order
+from test import QiskitTestCase, slow_test  # pylint: disable=wrong-import-order
 
 from ..legacy_cmaps import ALMADEN_CMAP, MUMBAI_CMAP
 
@@ -315,6 +315,25 @@ def test_support_var_with_explicit_routing_pass(self):
         layout = pass_.property_set["layout"]
         self.assertEqual([layout[q] for q in qc.qubits], [2, 3, 4, 1, 5])
 
+    @slow_test
+    def test_release_valve_routes_multiple(self):
+        """Test Sabre works if the release valve routes more than 1 operation.
+
+        Regression test of #13081.
+        """
+        qv = QuantumVolume(500, seed=42)
+        qv.measure_all()
+        qc = Unroll3qOrMore()(qv)
+
+        cmap = CouplingMap.from_heavy_hex(21)
+        pm = PassManager(
+            [
+                SabreLayout(cmap, swap_trials=20, layout_trials=20, max_iterations=4, seed=100),
+            ]
+        )
+        _ = pm.run(qc)
+        self.assertIsNotNone(pm.property_set.get("layout"))
+
 
 class DensePartialSabreTrial(AnalysisPass):
     """Pass to run dense layout as a sabre trial."""

From 117974066f69de67c1e05408ec5febafd267c8c4 Mon Sep 17 00:00:00 2001
From: Matthew Treinish <mtreinish@kortar.org>
Date: Wed, 11 Sep 2024 08:39:44 -0400
Subject: [PATCH 70/85] Prepare 1.3.0b1 release (#13125)

* Prepare 1.3.0b1 release

This commit changes the version strings from 1.3.0 to 1.3.0b1 in
preparation for tagging the 1.3.0b1 pre-release. After we publish the
1.3.0b1 tag we should switch the version number back to 1.3.0 to
continue developing the 1.3.0 release series as we approach the actual
release.

* Also skip 3.8 builds on 32 bit platforms

In the recently merged #12910 the minimum Python version was raised to
3.9. As part of this the cibuildwheel config was updated to skip 38
uilds since they wont work anymore. However that PR missed that there
was an additional skip config in for the 32 bit builds in the job
definition. This commit adds the missing skip so the 32bit wheel builds
will work as well.
---
 .github/workflows/wheels.yml | 2 +-
 docs/conf.py                 | 2 +-
 qiskit/VERSION.txt           | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml
index 3314bae05d5b..d3cb464bf8cc 100644
--- a/.github/workflows/wheels.yml
+++ b/.github/workflows/wheels.yml
@@ -60,7 +60,7 @@ jobs:
       - name: Build wheels
         uses: pypa/cibuildwheel@v2.19.2
         env:
-          CIBW_SKIP: 'pp* cp36-* cp37-* *musllinux* *amd64 *x86_64'
+          CIBW_SKIP: 'pp* cp36-* cp37-* cp38-* *musllinux* *amd64 *x86_64'
       - uses: actions/upload-artifact@v4
         with:
           path: ./wheelhouse/*.whl
diff --git a/docs/conf.py b/docs/conf.py
index 1ebd77749b41..277276df42a4 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -32,7 +32,7 @@
 # The short X.Y version
 version = "1.3"
 # The full version, including alpha/beta/rc tags
-release = "1.3.0"
+release = "1.3.0b1"
 
 language = "en"
 
diff --git a/qiskit/VERSION.txt b/qiskit/VERSION.txt
index f0bb29e76388..94bfba8ed4ed 100644
--- a/qiskit/VERSION.txt
+++ b/qiskit/VERSION.txt
@@ -1 +1 @@
-1.3.0
+1.3.0b1

From c5e9f8ae9eff14a62604c933cd288a8ca57226f8 Mon Sep 17 00:00:00 2001
From: Eric Arellano <14852634+Eric-Arellano@users.noreply.github.com>
Date: Wed, 11 Sep 2024 09:37:41 -0400
Subject: [PATCH 71/85] Remove Pulse library URL renaming in docs (#13107)

---
 docs/conf.py | 17 -----------------
 1 file changed, 17 deletions(-)

diff --git a/docs/conf.py b/docs/conf.py
index 277276df42a4..493dd58de83c 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -114,23 +114,6 @@
 autosummary_generate = True
 autosummary_generate_overwrite = False
 
-# The pulse library contains some names that differ only in capitalization, during the changeover
-# surrounding SymbolPulse.  Since these resolve to autosummary filenames that also differ only in
-# capitalization, this causes problems when the documentation is built on an OS/filesystem that is
-# enforcing case-insensitive semantics.  This setting defines some custom names to prevent the clash
-# from happening.
-autosummary_filename_map = {
-    "qiskit.pulse.library.Constant": "qiskit.pulse.library.Constant_class.rst",
-    "qiskit.pulse.library.Sawtooth": "qiskit.pulse.library.Sawtooth_class.rst",
-    "qiskit.pulse.library.Triangle": "qiskit.pulse.library.Triangle_class.rst",
-    "qiskit.pulse.library.Cos": "qiskit.pulse.library.Cos_class.rst",
-    "qiskit.pulse.library.Sin": "qiskit.pulse.library.Sin_class.rst",
-    "qiskit.pulse.library.Gaussian": "qiskit.pulse.library.Gaussian_class.rst",
-    "qiskit.pulse.library.Drag": "qiskit.pulse.library.Drag_class.rst",
-    "qiskit.pulse.library.Square": "qiskit.pulse.library.Square_fun.rst",
-    "qiskit.pulse.library.Sech": "qiskit.pulse.library.Sech_fun.rst",
-}
-
 # We only use Google-style docstrings, and allowing Napoleon to parse Numpy-style docstrings both
 # slows down the build (a little) and can sometimes result in _regular_ section headings in
 # module-level documentation being converted into surprising things.

From 81063a79a3144eeb43bb5eaab54b46574176835c Mon Sep 17 00:00:00 2001
From: Alexander Ivrii <alexi@il.ibm.com>
Date: Wed, 11 Sep 2024 18:51:47 +0300
Subject: [PATCH 72/85] improved fast-path detection in HLS (#13070)

* improved fast-path detection in HLS

* apply Jake's code review comments

* making the comment even more clearer
---
 .../passes/synthesis/high_level_synthesis.py  | 39 +++++++++++++------
 1 file changed, 28 insertions(+), 11 deletions(-)

diff --git a/qiskit/transpiler/passes/synthesis/high_level_synthesis.py b/qiskit/transpiler/passes/synthesis/high_level_synthesis.py
index 73a402dc202f..31036de69645 100644
--- a/qiskit/transpiler/passes/synthesis/high_level_synthesis.py
+++ b/qiskit/transpiler/passes/synthesis/high_level_synthesis.py
@@ -280,6 +280,15 @@ def run(self, dag: DAGCircuit) -> DAGCircuit:
         return self._run(dag, tracker)
 
     def _run(self, dag: DAGCircuit, tracker: QubitTracker) -> DAGCircuit:
+        # Check if HighLevelSynthesis can be skipped.
+        for node in dag.op_nodes():
+            qubits = tuple(dag.find_bit(q).index for q in node.qargs)
+            if not self._definitely_skip_node(node, qubits, dag):
+                break
+        else:
+            # The for-loop terminates without reaching the break statement
+            return dag
+
         # Start by analyzing the nodes in the DAG. This for-loop is a first version of a potentially
         # more elaborate approach to find good operation/ancilla allocations. It greedily iterates
         # over the nodes, checking whether we can synthesize them, while keeping track of the
@@ -293,12 +302,7 @@ def _run(self, dag: DAGCircuit, tracker: QubitTracker) -> DAGCircuit:
             used_qubits = None
 
             # check if synthesis for the operation can be skipped
-            if (
-                dag.has_calibration_for(node)
-                or len(node.qargs) < self._min_qubits
-                or node.is_directive()
-                or self._definitely_skip_node(node, qubits)
-            ):
+            if self._definitely_skip_node(node, qubits, dag):
                 pass
 
             # next check control flow
@@ -312,7 +316,7 @@ def _run(self, dag: DAGCircuit, tracker: QubitTracker) -> DAGCircuit:
             # now we are free to synthesize
             else:
                 # this returns the synthesized operation and the qubits it acts on -- note that this
-                # may be different than the original qubits, since we may use auxiliary qubits
+                # may be different from the original qubits, since we may use auxiliary qubits
                 synthesized, used_qubits = self._synthesize_operation(node.op, qubits, tracker)
 
             # if the synthesis changed the operation (i.e. it is not None), store the result
@@ -335,7 +339,7 @@ def _run(self, dag: DAGCircuit, tracker: QubitTracker) -> DAGCircuit:
         if len(synthesized_nodes) == 0:
             return dag
 
-        # Otherwise we will rebuild with the new operations. Note that we could also
+        # Otherwise, we will rebuild with the new operations. Note that we could also
         # check if no operation changed in size and substitute in-place, but rebuilding is
         # generally as fast or faster, unless very few operations are changed.
         out = dag.copy_empty_like()
@@ -631,19 +635,32 @@ def _apply_annotations(
 
         return synthesized
 
-    def _definitely_skip_node(self, node: DAGOpNode, qubits: tuple[int] | None) -> bool:
+    def _definitely_skip_node(
+        self, node: DAGOpNode, qubits: tuple[int] | None, dag: DAGCircuit
+    ) -> bool:
         """Fast-path determination of whether a node can certainly be skipped (i.e. nothing will
         attempt to synthesise it) without accessing its Python-space `Operation`.
 
         This is tightly coupled to `_recursively_handle_op`; it exists as a temporary measure to
         avoid Python-space `Operation` creation from a `DAGOpNode` if we wouldn't do anything to the
         node (which is _most_ nodes)."""
+
+        if (
+            dag.has_calibration_for(node)
+            or len(node.qargs) < self._min_qubits
+            or node.is_directive()
+        ):
+            return True
+
         return (
             # The fast path is just for Rust-space standard gates (which excludes
             # `AnnotatedOperation`).
             node.is_standard_gate()
-            # If it's a controlled gate, we might choose to do funny things to it.
-            and not node.is_controlled_gate()
+            # We don't have the fast-path for controlled gates over 3 or more qubits.
+            # However, we most probably want the fast-path for controlled 2-qubit gates
+            # (such as CX, CZ, CY, CH, CRX, and so on), so "_definitely_skip_node" should
+            # not immediately return False when encountering a controlled gate over 2 qubits.
+            and not (node.is_controlled_gate() and node.num_qubits >= 3)
             # If there are plugins to try, they need to be tried.
             and not self._methods_to_try(node.name)
             # If all the above constraints hold, and it's already supported or the basis translator

From 7e0e0e73c8077ce253f357b663359f287f335852 Mon Sep 17 00:00:00 2001
From: Matthew Treinish <mtreinish@kortar.org>
Date: Wed, 11 Sep 2024 17:04:17 -0400
Subject: [PATCH 73/85] Fix ABI3 issues identified during 1.3.0b1 release
 attempt (#13136)

We recently tried to publish the 1.3.0b1 release unsucessfully. During
the wheel build jobs abi3audit was failing because it correctly
identified a couple of abi violations in the builds. The first was we
were tagging the package incorrectly as being with a minimum level of
Python 3.8 instead of the correct minimum of 3.9. This commit updates
the setup.py tag to match the package metadata with the binary.

The second issue is we were creating `PyInit_*` symbols for submodules
which goes against the abi3 naming recomendations and abi3 audit flags
it as a violation. We had this issue previously in 1.2.0 but was fixed
for that release. However since 1.2.0 and now several stray usages of
`#[pymodule]` on submodules slipped in during development. This commit
fixes those so the bad symbol names won't be created anymore.

Once this commit merges we should tag the new commit as 1.3.0b1.

Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>
---
 crates/accelerate/src/circuit_library/mod.rs                  | 1 -
 crates/accelerate/src/commutation_analysis.rs                 | 3 +--
 crates/accelerate/src/commutation_cancellation.rs             | 3 +--
 crates/accelerate/src/commutation_checker.rs                  | 1 -
 crates/accelerate/src/gate_direction.rs                       | 1 -
 crates/accelerate/src/remove_diagonal_gates_before_measure.rs | 1 -
 setup.py                                                      | 2 +-
 7 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/crates/accelerate/src/circuit_library/mod.rs b/crates/accelerate/src/circuit_library/mod.rs
index d0444c484dc8..9df16a04fc6c 100644
--- a/crates/accelerate/src/circuit_library/mod.rs
+++ b/crates/accelerate/src/circuit_library/mod.rs
@@ -14,7 +14,6 @@ use pyo3::prelude::*;
 
 mod entanglement;
 
-#[pymodule]
 pub fn circuit_library(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(entanglement::get_entangler_map))?;
     Ok(())
diff --git a/crates/accelerate/src/commutation_analysis.rs b/crates/accelerate/src/commutation_analysis.rs
index 2da8cfce931e..0a9a2304df54 100644
--- a/crates/accelerate/src/commutation_analysis.rs
+++ b/crates/accelerate/src/commutation_analysis.rs
@@ -12,7 +12,7 @@
 
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::PyModule;
-use pyo3::{pyfunction, pymodule, wrap_pyfunction, Bound, PyResult, Python};
+use pyo3::{pyfunction, wrap_pyfunction, Bound, PyResult, Python};
 use qiskit_circuit::Qubit;
 
 use crate::commutation_checker::CommutationChecker;
@@ -185,7 +185,6 @@ pub(crate) fn analyze_commutations(
     Ok(out_dict.unbind())
 }
 
-#[pymodule]
 pub fn commutation_analysis(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(analyze_commutations))?;
     Ok(())
diff --git a/crates/accelerate/src/commutation_cancellation.rs b/crates/accelerate/src/commutation_cancellation.rs
index dc2d4436d83a..7ae7d3d7ce1a 100644
--- a/crates/accelerate/src/commutation_cancellation.rs
+++ b/crates/accelerate/src/commutation_cancellation.rs
@@ -15,7 +15,7 @@ use std::f64::consts::PI;
 use hashbrown::{HashMap, HashSet};
 use pyo3::exceptions::PyRuntimeError;
 use pyo3::prelude::*;
-use pyo3::{pyfunction, pymodule, wrap_pyfunction, Bound, PyResult, Python};
+use pyo3::{pyfunction, wrap_pyfunction, Bound, PyResult, Python};
 use rustworkx_core::petgraph::stable_graph::NodeIndex;
 use smallvec::{smallvec, SmallVec};
 
@@ -273,7 +273,6 @@ pub(crate) fn cancel_commutations(
     Ok(())
 }
 
-#[pymodule]
 pub fn commutation_cancellation(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(cancel_commutations))?;
     Ok(())
diff --git a/crates/accelerate/src/commutation_checker.rs b/crates/accelerate/src/commutation_checker.rs
index b00d7c624c92..c7fbd03a2afe 100644
--- a/crates/accelerate/src/commutation_checker.rs
+++ b/crates/accelerate/src/commutation_checker.rs
@@ -767,7 +767,6 @@ fn hashable_params(params: &[Param]) -> PyResult<SmallVec<[ParameterKey; 3]>> {
         .collect()
 }
 
-#[pymodule]
 pub fn commutation_checker(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_class::<CommutationLibrary>()?;
     m.add_class::<CommutationChecker>()?;
diff --git a/crates/accelerate/src/gate_direction.rs b/crates/accelerate/src/gate_direction.rs
index aee5ca097322..e7fef8456238 100644
--- a/crates/accelerate/src/gate_direction.rs
+++ b/crates/accelerate/src/gate_direction.rs
@@ -142,7 +142,6 @@ where
     Ok(true)
 }
 
-#[pymodule]
 pub fn gate_direction(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(py_check_with_coupling_map))?;
     m.add_wrapped(wrap_pyfunction!(py_check_with_target))?;
diff --git a/crates/accelerate/src/remove_diagonal_gates_before_measure.rs b/crates/accelerate/src/remove_diagonal_gates_before_measure.rs
index cf2c738f131a..e510d73666cc 100644
--- a/crates/accelerate/src/remove_diagonal_gates_before_measure.rs
+++ b/crates/accelerate/src/remove_diagonal_gates_before_measure.rs
@@ -102,7 +102,6 @@ fn run_remove_diagonal_before_measure(dag: &mut DAGCircuit) -> PyResult<()> {
     Ok(())
 }
 
-#[pymodule]
 pub fn remove_diagonal_gates_before_measure(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(run_remove_diagonal_before_measure))?;
     Ok(())
diff --git a/setup.py b/setup.py
index 61168050547c..ad6d1f8ead86 100644
--- a/setup.py
+++ b/setup.py
@@ -51,5 +51,5 @@
             features=features,
         )
     ],
-    options={"bdist_wheel": {"py_limited_api": "cp38"}},
+    options={"bdist_wheel": {"py_limited_api": "cp39"}},
 )

From 03575e66dfcdc5e7283dfcb17f81347d74d3a3aa Mon Sep 17 00:00:00 2001
From: Kevin Hartman <kevin@hart.mn>
Date: Wed, 11 Sep 2024 18:32:49 -0400
Subject: [PATCH 74/85] Make `DAGCircuit` fields `dag`, `qubits`, and `clbits`
 private. (#13117)

* Make DAGCircuit fields 'dag', 'qubits', and 'clbits' private.

Immutable getters are added to provide the same access we were using
without the risk of data incoherence.

* Update commutation_cancellation.rs.
---
 crates/accelerate/src/check_map.rs            |  2 +-
 crates/accelerate/src/commutation_analysis.rs |  6 +--
 .../src/commutation_cancellation.rs           |  6 +--
 .../src/euler_one_qubit_decomposer.rs         |  6 +--
 crates/accelerate/src/gate_direction.rs       |  2 +-
 crates/accelerate/src/inverse_cancellation.rs |  8 +--
 .../remove_diagonal_gates_before_measure.rs   |  8 +--
 crates/accelerate/src/split_2q_unitaries.rs   |  2 +-
 crates/circuit/src/dag_circuit.rs             | 50 ++++++++++++++++---
 crates/circuit/src/dot_utils.rs               |  6 +--
 10 files changed, 66 insertions(+), 30 deletions(-)

diff --git a/crates/accelerate/src/check_map.rs b/crates/accelerate/src/check_map.rs
index 8ebf50cd372d..da0592093817 100644
--- a/crates/accelerate/src/check_map.rs
+++ b/crates/accelerate/src/check_map.rs
@@ -40,7 +40,7 @@ fn recurse<'py>(
         }
     };
     for node in dag.op_nodes(false) {
-        if let NodeType::Operation(inst) = &dag.dag[node] {
+        if let NodeType::Operation(inst) = &dag.dag()[node] {
             let qubits = dag.get_qargs(inst.qubits);
             if inst.op.control_flow() {
                 if let OperationRef::Instruction(py_inst) = inst.op.view() {
diff --git a/crates/accelerate/src/commutation_analysis.rs b/crates/accelerate/src/commutation_analysis.rs
index 0a9a2304df54..e8b47658b9f4 100644
--- a/crates/accelerate/src/commutation_analysis.rs
+++ b/crates/accelerate/src/commutation_analysis.rs
@@ -80,7 +80,7 @@ pub(crate) fn analyze_commutations_inner(
                     // if the node is an input/output node, they do not commute, so we only
                     // continue if the nodes are operation nodes
                     if let (NodeType::Operation(packed_inst0), NodeType::Operation(packed_inst1)) =
-                        (&dag.dag[current_gate_idx], &dag.dag[*prev_gate_idx])
+                        (&dag.dag()[current_gate_idx], &dag.dag()[*prev_gate_idx])
                     {
                         let op1 = packed_inst0.op.view();
                         let op2 = packed_inst1.op.view();
@@ -153,7 +153,7 @@ pub(crate) fn analyze_commutations(
         // we know all wires are of type Wire::Qubit, since in analyze_commutations_inner
         // we only iterater over the qubits
         let py_wire = match wire {
-            Wire::Qubit(q) => dag.qubits.get(q).unwrap().to_object(py),
+            Wire::Qubit(q) => dag.qubits().get(q).unwrap().to_object(py),
             _ => return Err(PyValueError::new_err("Unexpected wire type.")),
         };
 
@@ -176,7 +176,7 @@ pub(crate) fn analyze_commutations(
     // Then we add the {(node, wire): index} dictionary
     for ((node_index, wire), index) in node_indices {
         let py_wire = match wire {
-            Wire::Qubit(q) => dag.qubits.get(q).unwrap().to_object(py),
+            Wire::Qubit(q) => dag.qubits().get(q).unwrap().to_object(py),
             _ => return Err(PyValueError::new_err("Unexpected wire type.")),
         };
         out_dict.set_item((dag.get_node(py, node_index)?, py_wire), index)?;
diff --git a/crates/accelerate/src/commutation_cancellation.rs b/crates/accelerate/src/commutation_cancellation.rs
index 7ae7d3d7ce1a..8e4e9281e103 100644
--- a/crates/accelerate/src/commutation_cancellation.rs
+++ b/crates/accelerate/src/commutation_cancellation.rs
@@ -105,14 +105,14 @@ pub(crate) fn cancel_commutations(
         if let Some(wire_commutation_set) = commutation_set.get(&Wire::Qubit(wire)) {
             for (com_set_idx, com_set) in wire_commutation_set.iter().enumerate() {
                 if let Some(&nd) = com_set.first() {
-                    if !matches!(dag.dag[nd], NodeType::Operation(_)) {
+                    if !matches!(dag.dag()[nd], NodeType::Operation(_)) {
                         continue;
                     }
                 } else {
                     continue;
                 }
                 for node in com_set.iter() {
-                    let instr = match &dag.dag[*node] {
+                    let instr = match &dag.dag()[*node] {
                         NodeType::Operation(instr) => instr,
                         _ => panic!("Unexpected type in commutation set."),
                     };
@@ -198,7 +198,7 @@ pub(crate) fn cancel_commutations(
                 let mut total_angle: f64 = 0.0;
                 let mut total_phase: f64 = 0.0;
                 for current_node in cancel_set {
-                    let node_op = match &dag.dag[*current_node] {
+                    let node_op = match &dag.dag()[*current_node] {
                         NodeType::Operation(instr) => instr,
                         _ => panic!("Unexpected type in commutation set run."),
                     };
diff --git a/crates/accelerate/src/euler_one_qubit_decomposer.rs b/crates/accelerate/src/euler_one_qubit_decomposer.rs
index 4c0a8539cf34..98333cad39d2 100644
--- a/crates/accelerate/src/euler_one_qubit_decomposer.rs
+++ b/crates/accelerate/src/euler_one_qubit_decomposer.rs
@@ -1086,7 +1086,7 @@ pub(crate) fn optimize_1q_gates_decomposition(
             Some(_) => 1.,
             None => raw_run.len() as f64,
         };
-        let qubit: PhysicalQubit = if let NodeType::Operation(inst) = &dag.dag[raw_run[0]] {
+        let qubit: PhysicalQubit = if let NodeType::Operation(inst) = &dag.dag()[raw_run[0]] {
             PhysicalQubit::new(dag.get_qargs(inst.qubits)[0].0)
         } else {
             unreachable!("nodes in runs will always be op nodes")
@@ -1172,7 +1172,7 @@ pub(crate) fn optimize_1q_gates_decomposition(
         let operator = raw_run
             .iter()
             .map(|node_index| {
-                let node = &dag.dag[*node_index];
+                let node = &dag.dag()[*node_index];
                 if let NodeType::Operation(inst) = node {
                     if let Some(target) = target {
                         error *= compute_error_term_from_target(inst.op.name(), target, qubit);
@@ -1215,7 +1215,7 @@ pub(crate) fn optimize_1q_gates_decomposition(
         let mut outside_basis = false;
         if let Some(basis) = basis_gates {
             for node in &raw_run {
-                if let NodeType::Operation(inst) = &dag.dag[*node] {
+                if let NodeType::Operation(inst) = &dag.dag()[*node] {
                     if !basis.contains(inst.op.name()) {
                         outside_basis = true;
                         break;
diff --git a/crates/accelerate/src/gate_direction.rs b/crates/accelerate/src/gate_direction.rs
index e7fef8456238..7c7d9d898726 100644
--- a/crates/accelerate/src/gate_direction.rs
+++ b/crates/accelerate/src/gate_direction.rs
@@ -89,7 +89,7 @@ where
     T: Fn(&PackedInstruction, &[Qubit]) -> bool,
 {
     for node in dag.op_nodes(false) {
-        let NodeType::Operation(packed_inst) = &dag.dag[node] else {
+        let NodeType::Operation(packed_inst) = &dag.dag()[node] else {
             panic!("PackedInstruction is expected");
         };
 
diff --git a/crates/accelerate/src/inverse_cancellation.rs b/crates/accelerate/src/inverse_cancellation.rs
index 0b3404c92ffb..1cfcc6c83214 100644
--- a/crates/accelerate/src/inverse_cancellation.rs
+++ b/crates/accelerate/src/inverse_cancellation.rs
@@ -65,7 +65,7 @@ fn run_on_self_inverse(
             let mut chunk: Vec<NodeIndex> = Vec::new();
             let max_index = gate_cancel_run.len() - 1;
             for (i, cancel_gate) in gate_cancel_run.iter().enumerate() {
-                let node = &dag.dag[*cancel_gate];
+                let node = &dag.dag()[*cancel_gate];
                 if let NodeType::Operation(inst) = node {
                     if gate_eq(py, inst, &gate)? {
                         chunk.push(*cancel_gate);
@@ -79,7 +79,7 @@ fn run_on_self_inverse(
                         partitions.push(std::mem::take(&mut chunk));
                     } else {
                         let next_qargs = if let NodeType::Operation(next_inst) =
-                            &dag.dag[gate_cancel_run[i + 1]]
+                            &dag.dag()[gate_cancel_run[i + 1]]
                         {
                             next_inst.qubits
                         } else {
@@ -132,8 +132,8 @@ fn run_on_inverse_pairs(
         for nodes in runs {
             let mut i = 0;
             while i < nodes.len() - 1 {
-                if let NodeType::Operation(inst) = &dag.dag[nodes[i]] {
-                    if let NodeType::Operation(next_inst) = &dag.dag[nodes[i + 1]] {
+                if let NodeType::Operation(inst) = &dag.dag()[nodes[i]] {
+                    if let NodeType::Operation(next_inst) = &dag.dag()[nodes[i + 1]] {
                         if inst.qubits == next_inst.qubits
                             && ((gate_eq(py, inst, &gate_0)? && gate_eq(py, next_inst, &gate_1)?)
                                 || (gate_eq(py, inst, &gate_1)?
diff --git a/crates/accelerate/src/remove_diagonal_gates_before_measure.rs b/crates/accelerate/src/remove_diagonal_gates_before_measure.rs
index e510d73666cc..5e1ba4182344 100644
--- a/crates/accelerate/src/remove_diagonal_gates_before_measure.rs
+++ b/crates/accelerate/src/remove_diagonal_gates_before_measure.rs
@@ -48,7 +48,7 @@ fn run_remove_diagonal_before_measure(dag: &mut DAGCircuit) -> PyResult<()> {
 
     let mut nodes_to_remove = Vec::new();
     for index in dag.op_nodes(true) {
-        let node = &dag.dag[index];
+        let node = &dag.dag()[index];
         let NodeType::Operation(inst) = node else {
             panic!()
         };
@@ -58,7 +58,7 @@ fn run_remove_diagonal_before_measure(dag: &mut DAGCircuit) -> PyResult<()> {
                 .next()
                 .expect("index is an operation node, so it must have a predecessor.");
 
-            match &dag.dag[predecessor] {
+            match &dag.dag()[predecessor] {
                 NodeType::Operation(pred_inst) => match pred_inst.standard_gate() {
                     Some(gate) => {
                         if DIAGONAL_1Q_GATES.contains(&gate) {
@@ -69,7 +69,7 @@ fn run_remove_diagonal_before_measure(dag: &mut DAGCircuit) -> PyResult<()> {
                             let successors = dag.quantum_successors(predecessor);
                             let remove_s = successors
                                 .map(|s| {
-                                    let node_s = &dag.dag[s];
+                                    let node_s = &dag.dag()[s];
                                     if let NodeType::Operation(inst_s) = node_s {
                                         inst_s.op.name() == "measure"
                                     } else {
@@ -94,7 +94,7 @@ fn run_remove_diagonal_before_measure(dag: &mut DAGCircuit) -> PyResult<()> {
     }
 
     for node_to_remove in nodes_to_remove {
-        if dag.dag.node_weight(node_to_remove).is_some() {
+        if dag.dag().node_weight(node_to_remove).is_some() {
             dag.remove_op_node(node_to_remove);
         }
     }
diff --git a/crates/accelerate/src/split_2q_unitaries.rs b/crates/accelerate/src/split_2q_unitaries.rs
index 83ab94bf301d..b7bccf44232d 100644
--- a/crates/accelerate/src/split_2q_unitaries.rs
+++ b/crates/accelerate/src/split_2q_unitaries.rs
@@ -28,7 +28,7 @@ pub fn split_2q_unitaries(
 ) -> PyResult<()> {
     let nodes: Vec<NodeIndex> = dag.op_nodes(false).collect();
     for node in nodes {
-        if let NodeType::Operation(inst) = &dag.dag[node] {
+        if let NodeType::Operation(inst) = &dag.dag()[node] {
             let qubits = dag.get_qargs(inst.qubits).to_vec();
             let matrix = inst.op.matrix(inst.params_view());
             // We only attempt to split UnitaryGate objects, but this could be extended in future
diff --git a/crates/circuit/src/dag_circuit.rs b/crates/circuit/src/dag_circuit.rs
index 197ad57278a2..d872806c5315 100644
--- a/crates/circuit/src/dag_circuit.rs
+++ b/crates/circuit/src/dag_circuit.rs
@@ -225,7 +225,7 @@ pub struct DAGCircuit {
 
     calibrations: HashMap<String, Py<PyDict>>,
 
-    pub dag: StableDiGraph<NodeType, Wire>,
+    dag: StableDiGraph<NodeType, Wire>,
 
     #[pyo3(get)]
     qregs: Py<PyDict>,
@@ -237,9 +237,9 @@ pub struct DAGCircuit {
     /// The cache used to intern instruction cargs.
     cargs_interner: Interner<[Clbit]>,
     /// Qubits registered in the circuit.
-    pub qubits: BitData<Qubit>,
+    qubits: BitData<Qubit>,
     /// Clbits registered in the circuit.
-    pub clbits: BitData<Clbit>,
+    clbits: BitData<Clbit>,
     /// Global phase.
     global_phase: Param,
     /// Duration.
@@ -736,8 +736,8 @@ impl DAGCircuit {
     ///
     /// Returns:
     ///     list(:class:`.Qubit`): The current sequence of registered qubits.
-    #[getter]
-    pub fn qubits(&self, py: Python<'_>) -> Py<PyList> {
+    #[getter(qubits)]
+    pub fn py_qubits(&self, py: Python<'_>) -> Py<PyList> {
         self.qubits.cached().clone_ref(py)
     }
 
@@ -751,8 +751,8 @@ impl DAGCircuit {
     ///
     /// Returns:
     ///     list(:class:`.Clbit`): The current sequence of registered clbits.
-    #[getter]
-    pub fn clbits(&self, py: Python<'_>) -> Py<PyList> {
+    #[getter(clbits)]
+    pub fn py_clbits(&self, py: Python<'_>) -> Py<PyList> {
         self.clbits.cached().clone_ref(py)
     }
 
@@ -4985,6 +4985,42 @@ def _format(operand):
 }
 
 impl DAGCircuit {
+    /// Returns an immutable view of the inner StableGraph managed by the circuit.
+    #[inline(always)]
+    pub fn dag(&self) -> &StableDiGraph<NodeType, Wire> {
+        &self.dag
+    }
+
+    /// Returns an immutable view of the Interner used for Qargs
+    #[inline(always)]
+    pub fn qargs_interner(&self) -> &Interner<[Qubit]> {
+        &self.qargs_interner
+    }
+
+    /// Returns an immutable view of the Interner used for Cargs
+    #[inline(always)]
+    pub fn cargs_interner(&self) -> &Interner<[Clbit]> {
+        &self.cargs_interner
+    }
+
+    /// Returns an immutable view of the Global Phase `Param` of the circuit
+    #[inline(always)]
+    pub fn global_phase(&self) -> &Param {
+        &self.global_phase
+    }
+
+    /// Returns an immutable view of the Qubits registered in the circuit
+    #[inline(always)]
+    pub fn qubits(&self) -> &BitData<Qubit> {
+        &self.qubits
+    }
+
+    /// Returns an immutable view of the Classical bits registered in the circuit
+    #[inline(always)]
+    pub fn clbits(&self) -> &BitData<Clbit> {
+        &self.clbits
+    }
+
     /// Return an iterator of gate runs with non-conditional op nodes of given names
     pub fn collect_runs(
         &self,
diff --git a/crates/circuit/src/dot_utils.rs b/crates/circuit/src/dot_utils.rs
index f6769c6cad11..8558535788a0 100644
--- a/crates/circuit/src/dot_utils.rs
+++ b/crates/circuit/src/dot_utils.rs
@@ -38,7 +38,7 @@ pub fn build_dot<T>(
 where
     T: Write,
 {
-    let graph = &dag.dag;
+    let graph = dag.dag();
     writeln!(file, "{} {{", TYPE[graph.is_directed() as usize])?;
     if let Some(graph_attr_map) = graph_attrs {
         for (key, value) in graph_attr_map.iter() {
@@ -57,8 +57,8 @@ where
     }
     for edge in graph.edge_references() {
         let edge_weight = match edge.weight() {
-            Wire::Qubit(qubit) => dag.qubits.get(*qubit).unwrap(),
-            Wire::Clbit(clbit) => dag.clbits.get(*clbit).unwrap(),
+            Wire::Qubit(qubit) => dag.qubits().get(*qubit).unwrap(),
+            Wire::Clbit(clbit) => dag.clbits().get(*clbit).unwrap(),
             Wire::Var(var) => var,
         };
         writeln!(

From 2fa6dd65d6fae28c1b0a364b8d8b068be7cc1cb1 Mon Sep 17 00:00:00 2001
From: Luciano Bello <bel@zurich.ibm.com>
Date: Thu, 12 Sep 2024 10:10:31 +0200
Subject: [PATCH 75/85] deprecate BackendV1 in 
 `PassManagerConfig.from_backend` (#12931)

* deprecate BackendV1 in  PassManagerConfig.from_backend

* test.python.transpiler.test_passmanager_config

* primitives/test_backend_estimator_v2

* test.python.primitives.test_backend_estimator_v2.TestBackendEstimatorV2

* res
---
 qiskit/transpiler/passmanager_config.py       | 22 ++++-
 .../followup_12629-8bfcf1a3d4e6cabf.yaml      |  6 ++
 .../primitives/test_backend_estimator_v2.py   | 99 ++++++++++++++++---
 .../transpiler/test_passmanager_config.py     | 11 ++-
 4 files changed, 119 insertions(+), 19 deletions(-)
 create mode 100644 releasenotes/notes/followup_12629-8bfcf1a3d4e6cabf.yaml

diff --git a/qiskit/transpiler/passmanager_config.py b/qiskit/transpiler/passmanager_config.py
index 4c53bc47b31c..0ebbff430301 100644
--- a/qiskit/transpiler/passmanager_config.py
+++ b/qiskit/transpiler/passmanager_config.py
@@ -13,6 +13,7 @@
 """Pass Manager Configuration class."""
 
 import pprint
+import warnings
 
 from qiskit.transpiler.coupling import CouplingMap
 from qiskit.transpiler.instruction_durations import InstructionDurations
@@ -113,11 +114,17 @@ def __init__(
     def from_backend(cls, backend, _skip_target=False, **pass_manager_options):
         """Construct a configuration based on a backend and user input.
 
-        This method automatically gererates a PassManagerConfig object based on the backend's
+        This method automatically generates a PassManagerConfig object based on the backend's
         features. User options can be used to overwrite the configuration.
 
+        .. deprecated:: 1.3
+            The method ``PassManagerConfig.from_backend`` will stop supporting inputs of type
+            :class:`.BackendV1` in the `backend` parameter in a future release no
+            earlier than 2.0. :class:`.BackendV1` is deprecated and implementations should move
+            to :class:`.BackendV2`.
+
         Args:
-            backend (BackendV1): The backend that provides the configuration.
+            backend (BackendV1 or BackendV2): The backend that provides the configuration.
             pass_manager_options: User-defined option-value pairs.
 
         Returns:
@@ -126,12 +133,21 @@ def from_backend(cls, backend, _skip_target=False, **pass_manager_options):
         Raises:
             AttributeError: If the backend does not support a `configuration()` method.
         """
-        res = cls(**pass_manager_options)
         backend_version = getattr(backend, "version", 0)
+        if backend_version == 1:
+            warnings.warn(
+                "The method PassManagerConfig.from_backend will stop supporting inputs of "
+                f"type `BackendV1` ( {backend} ) in the `backend` parameter in a future "
+                "release no earlier than 2.0. `BackendV1` is deprecated and implementations "
+                "should move to `BackendV2`.",
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
         if not isinstance(backend_version, int):
             backend_version = 0
         if backend_version < 2:
             config = backend.configuration()
+        res = cls(**pass_manager_options)
         if res.basis_gates is None:
             if backend_version < 2:
                 res.basis_gates = getattr(config, "basis_gates", None)
diff --git a/releasenotes/notes/followup_12629-8bfcf1a3d4e6cabf.yaml b/releasenotes/notes/followup_12629-8bfcf1a3d4e6cabf.yaml
new file mode 100644
index 000000000000..227946d0dffb
--- /dev/null
+++ b/releasenotes/notes/followup_12629-8bfcf1a3d4e6cabf.yaml
@@ -0,0 +1,6 @@
+---
+deprecations_transpiler:
+  - |
+    The method :meth:`.PassManagerConfig.from_backend` will stop supporting inputs of type
+    :class:`.BackendV1` in the `backend` parameter in a future release no earlier than 2.0.
+    :class:`.BackendV1` is deprecated and implementations should move to :class:`.BackendV2`.
diff --git a/test/python/primitives/test_backend_estimator_v2.py b/test/python/primitives/test_backend_estimator_v2.py
index 12a932b83819..dd55750c55a0 100644
--- a/test/python/primitives/test_backend_estimator_v2.py
+++ b/test/python/primitives/test_backend_estimator_v2.py
@@ -145,7 +145,10 @@ def test_estimator_run_v1(self, backend, abelian_grouping):
         ):
             pm = generate_preset_pass_manager(optimization_level=0, backend=backend)
         psi1, psi2 = pm.run([psi1, psi2])
-        estimator = BackendEstimatorV2(backend=backend, options=self._options)
+        with self.assertWarns(DeprecationWarning):
+            # When BackendEstimatorV2 is called with a backend V1, it raises a
+            # DeprecationWarning from PassManagerConfig.from_backend
+            estimator = BackendEstimatorV2(backend=backend, options=self._options)
         estimator.options.abelian_grouping = abelian_grouping
         # Specify the circuit and observable by indices.
         # calculate [ <psi1(theta1)|H1|psi1(theta1)> ]
@@ -235,7 +238,10 @@ def test_estimator_with_pub_v1(self, backend, abelian_grouping):
         bind2 = BindingsArray.coerce({tuple(psi2.parameters): theta2})
         pub2 = EstimatorPub(psi2, obs2, bind2)
 
-        estimator = BackendEstimatorV2(backend=backend, options=self._options)
+        with self.assertWarns(DeprecationWarning):
+            # When BackendEstimatorV2 is called with a backend V1, it raises a
+            # DeprecationWarning from PassManagerConfig.from_backend
+            estimator = BackendEstimatorV2(backend=backend, options=self._options)
         estimator.options.abelian_grouping = abelian_grouping
         result4 = estimator.run([pub1, pub2]).result()
         np.testing.assert_allclose(result4[0].data.evs, [1.55555728, -1.08766318], rtol=self._rtol)
@@ -264,7 +270,10 @@ def test_estimator_run_no_params_v1(self, backend, abelian_grouping):
         ):
             pm = generate_preset_pass_manager(optimization_level=0, backend=backend)
         circuit = pm.run(circuit)
-        est = BackendEstimatorV2(backend=backend, options=self._options)
+        with self.assertWarns(DeprecationWarning):
+            # When BackendEstimatorV2 is called with a backend V1, it raises a
+            # DeprecationWarning from PassManagerConfig.from_backend
+            est = BackendEstimatorV2(backend=backend, options=self._options)
         est.options.abelian_grouping = abelian_grouping
         observable = self.observable.apply_layout(circuit.layout)
         result = est.run([(circuit, observable)]).result()
@@ -331,7 +340,13 @@ def test_run_single_circuit_observable(self, backend, abelian_grouping):
     @combine(backend=BACKENDS_V1, abelian_grouping=[True, False])
     def test_run_single_circuit_observable_v1(self, backend, abelian_grouping):
         """Test for single circuit and single observable case."""
-        est = BackendEstimatorV2(backend=backend, options=self._options)
+        with self.assertWarnsRegex(
+            DeprecationWarning,
+            expected_regex=r"The method PassManagerConfig\.from_backend will stop supporting inputs of "
+            "type `BackendV1`",
+        ):
+            # BackendEstimatorV2 wont allow BackendV1
+            est = BackendEstimatorV2(backend=backend, options=self._options)
         est.options.abelian_grouping = abelian_grouping
         with self.assertWarnsRegex(
             DeprecationWarning,
@@ -438,7 +453,11 @@ def test_run_1qubit_v1(self, backend, abelian_grouping):
         op = SparsePauliOp.from_list([("I", 1)])
         op2 = SparsePauliOp.from_list([("Z", 1)])
 
-        est = BackendEstimatorV2(backend=backend, options=self._options)
+        with self.assertWarns(DeprecationWarning):
+            # When BackendEstimatorV2 is called with a backend V1, it raises a
+            # DeprecationWarning from PassManagerConfig.from_backend
+            est = BackendEstimatorV2(backend=backend, options=self._options)
+
         est.options.abelian_grouping = abelian_grouping
         op_1 = op.apply_layout(qc.layout)
         result = est.run([(qc, op_1)]).result()
@@ -513,7 +532,10 @@ def test_run_2qubits_v1(self, backend, abelian_grouping):
         op2 = SparsePauliOp.from_list([("ZI", 1)])
         op3 = SparsePauliOp.from_list([("IZ", 1)])
 
-        est = BackendEstimatorV2(backend=backend, options=self._options)
+        with self.assertWarns(DeprecationWarning):
+            # When BackendEstimatorV2 is called with a backend V1, it raises a
+            # DeprecationWarning from PassManagerConfig.from_backend
+            est = BackendEstimatorV2(backend=backend, options=self._options)
         est.options.abelian_grouping = abelian_grouping
         op_1 = op.apply_layout(qc.layout)
         result = est.run([(qc, op_1)]).result()
@@ -539,7 +561,47 @@ def test_run_2qubits_v1(self, backend, abelian_grouping):
         result = est.run([(qc2, op_6)]).result()
         np.testing.assert_allclose(result[0].data.evs, [-1], rtol=self._rtol)
 
-    @combine(backend=BACKENDS, abelian_grouping=[True, False])
+    @combine(backend=BACKENDS_V1, abelian_grouping=[True, False])
+    def test_run_errors_v1(self, backend, abelian_grouping):
+        """Test for errors.
+        To be removed once BackendV1 is removed."""
+        qc = QuantumCircuit(1)
+        qc2 = QuantumCircuit(2)
+
+        op = SparsePauliOp.from_list([("I", 1)])
+        op2 = SparsePauliOp.from_list([("II", 1)])
+        with self.assertWarns(DeprecationWarning):
+            # When BackendEstimatorV2 is called with a backend V1, it raises a
+            # DeprecationWarning from PassManagerConfig.from_backend
+            est = BackendEstimatorV2(backend=backend, options=self._options)
+        est.options.abelian_grouping = abelian_grouping
+        with self.assertRaises(ValueError):
+            est.run([(qc, op2)]).result()
+        with self.assertRaises(ValueError):
+            est.run([(qc, op, [[1e4]])]).result()
+        with self.assertRaises(ValueError):
+            est.run([(qc2, op2, [[1, 2]])]).result()
+        with self.assertRaises(ValueError):
+            est.run([(qc, [op, op2], [[1]])]).result()
+        with self.assertRaises(ValueError):
+            est.run([(qc, op)], precision=-1).result()
+        with self.assertRaises(ValueError):
+            est.run([(qc, 1j * op)], precision=0.1).result()
+        # precision == 0
+        with self.assertRaises(ValueError):
+            est.run([(qc, op, None, 0)]).result()
+        with self.assertRaises(ValueError):
+            est.run([(qc, op)], precision=0).result()
+        # precision < 0
+        with self.assertRaises(ValueError):
+            est.run([(qc, op, None, -1)]).result()
+        with self.assertRaises(ValueError):
+            est.run([(qc, op)], precision=-1).result()
+        with self.subTest("missing []"):
+            with self.assertRaisesRegex(ValueError, "An invalid Estimator pub-like was given"):
+                _ = est.run((qc, op)).result()
+
+    @combine(backend=BACKENDS_V2, abelian_grouping=[True, False])
     def test_run_errors(self, backend, abelian_grouping):
         """Test for errors"""
         qc = QuantumCircuit(1)
@@ -624,7 +686,13 @@ def test_run_numpy_params_v1(self, backend, abelian_grouping):
         statevector_estimator = StatevectorEstimator(seed=123)
         target = statevector_estimator.run([(qc, op, params_list)]).result()
 
-        backend_estimator = BackendEstimatorV2(backend=backend, options=self._options)
+        with self.assertWarnsRegex(
+            DeprecationWarning,
+            expected_regex=r"The method PassManagerConfig\.from_backend will stop supporting inputs of "
+            "type `BackendV1`",
+        ):
+            # BackendEstimatorV2 wont allow BackendV1
+            backend_estimator = BackendEstimatorV2(backend=backend, options=self._options)
         backend_estimator.options.abelian_grouping = abelian_grouping
 
         with self.subTest("ndarrary"):
@@ -662,7 +730,10 @@ def test_precision(self, backend, abelian_grouping):
     @combine(backend=BACKENDS_V1, abelian_grouping=[True, False])
     def test_precision_v1(self, backend, abelian_grouping):
         """Test for precision"""
-        estimator = BackendEstimatorV2(backend=backend, options=self._options)
+        with self.assertWarns(DeprecationWarning):
+            # When BackendEstimatorV2 is called with a backend V1, it raises a
+            # DeprecationWarning from PassManagerConfig.from_backend
+            estimator = BackendEstimatorV2(backend=backend, options=self._options)
         estimator.options.abelian_grouping = abelian_grouping
         with self.assertWarnsRegex(
             DeprecationWarning,
@@ -705,7 +776,10 @@ def test_diff_precision(self, backend, abelian_grouping):
     @combine(backend=BACKENDS_V1, abelian_grouping=[True, False])
     def test_diff_precision_v1(self, backend, abelian_grouping):
         """Test for running different precisions at once"""
-        estimator = BackendEstimatorV2(backend=backend, options=self._options)
+        with self.assertWarns(DeprecationWarning):
+            # When BackendEstimatorV2 is called with a backend V1, it raises a
+            # DeprecationWarning from PassManagerConfig.from_backend
+            estimator = BackendEstimatorV2(backend=backend, options=self._options)
         estimator.options.abelian_grouping = abelian_grouping
         with self.assertWarnsRegex(
             DeprecationWarning,
@@ -792,7 +866,10 @@ def test_job_size_limit_backend_v1(self):
         op = SparsePauliOp.from_list([("IZ", 1), ("XI", 2), ("ZY", -1)])
         k = 5
         param_list = self._rng.random(qc.num_parameters).tolist()
-        estimator = BackendEstimatorV2(backend=backend)
+        with self.assertWarns(DeprecationWarning):
+            # When BackendEstimatorV2 is called with a backend V1, it raises a
+            # DeprecationWarning from PassManagerConfig.from_backend
+            estimator = BackendEstimatorV2(backend=backend)
         with patch.object(backend, "run") as run_mock:
             estimator.run([(qc, op, param_list)] * k).result()
         self.assertEqual(run_mock.call_count, 10)
diff --git a/test/python/transpiler/test_passmanager_config.py b/test/python/transpiler/test_passmanager_config.py
index 341da357d37a..569f67738a16 100644
--- a/test/python/transpiler/test_passmanager_config.py
+++ b/test/python/transpiler/test_passmanager_config.py
@@ -33,7 +33,7 @@ def test_config_from_backend(self):
         """
         with self.assertWarns(DeprecationWarning):
             backend = Fake27QPulseV1()
-        config = PassManagerConfig.from_backend(backend)
+            config = PassManagerConfig.from_backend(backend)
         self.assertEqual(config.basis_gates, backend.configuration().basis_gates)
         self.assertEqual(config.inst_map, backend.defaults().instruction_schedule_map)
         self.assertEqual(
@@ -66,9 +66,9 @@ def test_from_backend_and_user_v1(self):
 
         with self.assertWarns(DeprecationWarning):
             backend = Fake20QV1()
-        config = PassManagerConfig.from_backend(
-            backend, basis_gates=["user_gate"], initial_layout=initial_layout
-        )
+            config = PassManagerConfig.from_backend(
+                backend, basis_gates=["user_gate"], initial_layout=initial_layout
+            )
         self.assertEqual(config.basis_gates, ["user_gate"])
         self.assertNotEqual(config.basis_gates, backend.configuration().basis_gates)
         self.assertIsNone(config.inst_map)
@@ -107,7 +107,8 @@ def test_from_backendv1_inst_map_is_none(self):
         with self.assertWarns(DeprecationWarning):
             backend = Fake27QPulseV1()
         backend.defaults = lambda: None
-        config = PassManagerConfig.from_backend(backend)
+        with self.assertWarns(DeprecationWarning):
+            config = PassManagerConfig.from_backend(backend)
         self.assertIsInstance(config, PassManagerConfig)
         self.assertIsNone(config.inst_map)
 

From 118a16c0bccc932dac4cc3e545fa358d3e5ad8cf Mon Sep 17 00:00:00 2001
From: Eric Arellano <14852634+Eric-Arellano@users.noreply.github.com>
Date: Thu, 12 Sep 2024 04:17:37 -0400
Subject: [PATCH 76/85] Use new URL for link in circuit docs page (#13135)

Co-authored-by: Luciano Bello <bel@zurich.ibm.com>
---
 qiskit/circuit/quantumcircuit.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qiskit/circuit/quantumcircuit.py b/qiskit/circuit/quantumcircuit.py
index 566a6fef9f70..780efba5faf1 100644
--- a/qiskit/circuit/quantumcircuit.py
+++ b/qiskit/circuit/quantumcircuit.py
@@ -2108,7 +2108,7 @@ def tensor(self, other: "QuantumCircuit", inplace: bool = False) -> Optional["Qu
 
         Remember that in the little-endian convention the leftmost operation will be at the bottom
         of the circuit. See also
-        `the docs <https://docs.quantum.ibm.com/build/circuit-construction>`__
+        `the docs <https://docs.quantum.ibm.com/guides/construct-circuits>`__
         for more information.
 
         .. parsed-literal::

From 1ff6361303c4b4bd472eee5249fadcbace40ca96 Mon Sep 17 00:00:00 2001
From: Julien Gacon <jules.gacon@googlemail.com>
Date: Thu, 12 Sep 2024 15:07:26 +0200
Subject: [PATCH 77/85] Oxidize `PauliFeatureMap` (#13045)

* port PauliFeatureMap to Rust

* more docs, less error expecting

* cleanup, docstrings

* clippy & speedup

* base for dictionary entanglement

* rm unnecessary pub

* add reno

* refactor ``rmultiply_param``

* fix & test dict entanglement

* clippy

* Refactor Rust code a bit

- improve readability
- only create barrier if necessary

* RIP iterators (for proper error handling)

performance seems to be unaffected :)
---
 .../src/circuit_library/entanglement.rs       |  50 ++-
 crates/accelerate/src/circuit_library/mod.rs  |   2 +
 .../src/circuit_library/pauli_feature_map.rs  | 346 +++++++++++++++++
 crates/circuit/src/imports.rs                 |   1 +
 crates/circuit/src/operations.rs              |  22 +-
 qiskit/circuit/library/__init__.py            |   3 +
 .../library/data_preparation/__init__.py      |   9 +-
 .../{z_feature_map.py => _z_feature_map.py}   |  77 ++--
 .../{zz_feature_map.py => _zz_feature_map.py} |  35 +-
 .../data_preparation/pauli_feature_map.py     | 359 ++++++++++++++++--
 .../notes/rust-paulifm-1dc7b1c2dc756614.yaml  |  16 +
 .../circuit/library/test_pauli_feature_map.py | 295 +++++++++++++-
 12 files changed, 1119 insertions(+), 96 deletions(-)
 create mode 100644 crates/accelerate/src/circuit_library/pauli_feature_map.rs
 rename qiskit/circuit/library/data_preparation/{z_feature_map.py => _z_feature_map.py} (52%)
 rename qiskit/circuit/library/data_preparation/{zz_feature_map.py => _zz_feature_map.py} (71%)
 create mode 100644 releasenotes/notes/rust-paulifm-1dc7b1c2dc756614.yaml

diff --git a/crates/accelerate/src/circuit_library/entanglement.rs b/crates/accelerate/src/circuit_library/entanglement.rs
index db602ef717fa..fbfb5c0193f1 100644
--- a/crates/accelerate/src/circuit_library/entanglement.rs
+++ b/crates/accelerate/src/circuit_library/entanglement.rs
@@ -12,6 +12,7 @@
 
 use itertools::Itertools;
 use pyo3::prelude::*;
+use pyo3::types::PyDict;
 use pyo3::{
     types::{PyAnyMethods, PyInt, PyList, PyListMethods, PyString, PyTuple},
     Bound, PyAny, PyResult,
@@ -173,30 +174,45 @@ pub fn get_entanglement<'a>(
         return Ok(Box::new(
             get_entanglement_from_str(num_qubits, block_size, as_str.as_str(), offset)?.map(Ok),
         ));
+    } else if let Ok(dict) = entanglement.downcast::<PyDict>() {
+        if let Some(value) = dict.get_item(block_size)? {
+            let list = value.downcast::<PyList>()?;
+            return _check_entanglement_list(list.to_owned(), block_size);
+        } else {
+            return Ok(Box::new(std::iter::empty()));
+        }
     } else if let Ok(list) = entanglement.downcast::<PyList>() {
-        let entanglement_iter = list.iter().map(move |el| {
-            let connections = el
-                .downcast::<PyTuple>()?
-                // .expect("Entanglement must be list of tuples") // clearer error message than `?`
-                .iter()
-                .map(|index| index.downcast::<PyInt>()?.extract())
-                .collect::<Result<Vec<u32>, _>>()?;
-
-            if connections.len() != block_size as usize {
-                return Err(QiskitError::new_err(format!(
-                    "Entanglement {:?} does not match block size {}",
-                    connections, block_size
-                )));
-            }
-            Ok(connections)
-        });
-        return Ok(Box::new(entanglement_iter));
+        return _check_entanglement_list(list.to_owned(), block_size);
     }
     Err(QiskitError::new_err(
         "Entanglement must be a string or list of qubit indices.",
     ))
 }
 
+fn _check_entanglement_list<'a>(
+    list: Bound<'a, PyList>,
+    block_size: u32,
+) -> PyResult<Box<dyn Iterator<Item = PyResult<Vec<u32>>> + 'a>> {
+    let entanglement_iter = list.iter().map(move |el| {
+        let connections = el
+            .downcast::<PyTuple>()?
+            // .expect("Entanglement must be list of tuples") // clearer error message than `?`
+            .iter()
+            .map(|index| index.downcast::<PyInt>()?.extract())
+            .collect::<Result<Vec<u32>, _>>()?;
+
+        if connections.len() != block_size as usize {
+            return Err(QiskitError::new_err(format!(
+                "Entanglement {:?} does not match block size {}",
+                connections, block_size
+            )));
+        }
+
+        Ok(connections)
+    });
+    Ok(Box::new(entanglement_iter))
+}
+
 /// Get the entanglement for given number of qubits and block size.
 ///
 /// Args:
diff --git a/crates/accelerate/src/circuit_library/mod.rs b/crates/accelerate/src/circuit_library/mod.rs
index 9df16a04fc6c..94db90ccd234 100644
--- a/crates/accelerate/src/circuit_library/mod.rs
+++ b/crates/accelerate/src/circuit_library/mod.rs
@@ -13,8 +13,10 @@
 use pyo3::prelude::*;
 
 mod entanglement;
+mod pauli_feature_map;
 
 pub fn circuit_library(m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_wrapped(wrap_pyfunction!(pauli_feature_map::pauli_feature_map))?;
     m.add_wrapped(wrap_pyfunction!(entanglement::get_entangler_map))?;
     Ok(())
 }
diff --git a/crates/accelerate/src/circuit_library/pauli_feature_map.rs b/crates/accelerate/src/circuit_library/pauli_feature_map.rs
new file mode 100644
index 000000000000..53e84a197f1d
--- /dev/null
+++ b/crates/accelerate/src/circuit_library/pauli_feature_map.rs
@@ -0,0 +1,346 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// 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.
+
+use itertools::Itertools;
+use pyo3::prelude::*;
+use pyo3::types::PySequence;
+use pyo3::types::PyString;
+use qiskit_circuit::circuit_data::CircuitData;
+use qiskit_circuit::imports;
+use qiskit_circuit::operations::PyInstruction;
+use qiskit_circuit::operations::{add_param, multiply_param, multiply_params, Param, StandardGate};
+use qiskit_circuit::packed_instruction::PackedOperation;
+use qiskit_circuit::{Clbit, Qubit};
+use smallvec::{smallvec, SmallVec};
+use std::f64::consts::PI;
+
+use crate::circuit_library::entanglement;
+use crate::QiskitError;
+
+// custom math and types for a more readable code
+const PI2: f64 = PI / 2.;
+type Instruction = (
+    PackedOperation,
+    SmallVec<[Param; 3]>,
+    Vec<Qubit>,
+    Vec<Clbit>,
+);
+type StandardInstruction = (StandardGate, SmallVec<[Param; 3]>, SmallVec<[Qubit; 2]>);
+
+/// Return instructions (using only StandardGate operations) to implement a Pauli evolution
+/// of a given Pauli string over a given time (as Param).
+///
+/// The Pauli evolution is implemented as a basis transformation to the Pauli-Z basis,
+/// followed by a CX-chain and then a single Pauli-Z rotation on the last qubit. Then the CX-chain
+/// is uncomputed and the inverse basis transformation applied. E.g. for the evolution under the
+/// Pauli string XIYZ we have the circuit
+///                     ┌───┐┌───────┐┌───┐
+/// 0: ─────────────────┤ X ├┤ Rz(2) ├┤ X ├──────────────────
+///    ┌──────────┐┌───┐└─┬─┘└───────┘└─┬─┘┌───┐┌───────────┐
+/// 1: ┤ Rx(pi/2) ├┤ X ├──■─────────────■──┤ X ├┤ Rx(-pi/2) ├
+///    └──────────┘└─┬─┘                   └─┬─┘└───────────┘
+/// 2: ──────────────┼───────────────────────┼───────────────
+///     ┌───┐        │                       │  ┌───┐
+/// 3: ─┤ H ├────────■───────────────────────■──┤ H ├────────
+///     └───┘                                   └───┘
+fn pauli_evolution(
+    pauli: &str,
+    indices: Vec<u32>,
+    time: Param,
+) -> impl Iterator<Item = StandardInstruction> + '_ {
+    // Get pairs of (pauli, qubit) that are active, i.e. that are not the identity. Note that
+    // the rest of the code also works if there are only identities, in which case we will
+    // effectively return an empty iterator.
+    let qubits = indices.iter().map(|i| Qubit(*i)).collect_vec();
+    let binding = pauli.to_lowercase(); // lowercase for convenience
+    let active_paulis = binding
+        .as_str()
+        .chars()
+        .rev() // reverse due to Qiskit's bit ordering convention
+        .zip(qubits)
+        .filter(|(p, _)| *p != 'i')
+        .collect_vec();
+
+    // get the basis change: x -> HGate, y -> RXGate(pi/2), z -> nothing
+    let basis_change = active_paulis
+        .clone()
+        .into_iter()
+        .filter(|(p, _)| *p != 'z')
+        .map(|(p, q)| match p {
+            'x' => (StandardGate::HGate, smallvec![], smallvec![q]),
+            'y' => (
+                StandardGate::RXGate,
+                smallvec![Param::Float(PI2)],
+                smallvec![q],
+            ),
+            _ => unreachable!("Invalid Pauli string."), // "z" and "i" have been filtered out
+        });
+
+    // get the inverse basis change
+    let inverse_basis_change = basis_change.clone().map(|(gate, _, qubit)| match gate {
+        StandardGate::HGate => (gate, smallvec![], qubit),
+        StandardGate::RXGate => (gate, smallvec![Param::Float(-PI2)], qubit),
+        _ => unreachable!(),
+    });
+
+    // get the CX chain down to the target rotation qubit
+    let chain_down = active_paulis
+        .clone()
+        .into_iter()
+        .map(|(_, q)| q)
+        .tuple_windows() // iterates over (q[i], q[i+1]) windows
+        .map(|(ctrl, target)| (StandardGate::CXGate, smallvec![], smallvec![ctrl, target]));
+
+    // get the CX chain up (cannot use chain_down.rev since tuple_windows is not double ended)
+    let chain_up = active_paulis
+        .clone()
+        .into_iter()
+        .rev()
+        .map(|(_, q)| q)
+        .tuple_windows()
+        .map(|(target, ctrl)| (StandardGate::CXGate, smallvec![], smallvec![ctrl, target]));
+
+    // get the RZ gate on the last qubit
+    let last_qubit = active_paulis.last().unwrap().1;
+    let z_rotation = std::iter::once((
+        StandardGate::PhaseGate,
+        smallvec![time],
+        smallvec![last_qubit],
+    ));
+
+    // and finally chain everything together
+    basis_change
+        .chain(chain_down)
+        .chain(z_rotation)
+        .chain(chain_up)
+        .chain(inverse_basis_change)
+}
+
+/// Build a Pauli feature map circuit.
+///
+/// Args:
+///     feature_dimension: The feature dimension (i.e. the number of qubits).
+///     parameters: A parameter vector with ``feature_dimension`` elements. Taken as input
+///         here to avoid a call to Python constructing the vector.
+///     reps: The number of repetitions of Hadamard + evolution layers.
+///     entanglement: The entanglement, given as Python string or None (defaults to "full").
+///     paulis: The Pauli strings as list of strings or None (default to ["z", "zz"]).
+///     alpha: A float multiplier for rotation angles.
+///     insert_barriers: Whether to insert barriers in between the Hadamard and evolution layers.
+///     data_map_func: An accumulation function that takes as input a vector of parameters the
+///         current gate acts on and returns a scalar.
+///     
+/// Returns:
+///     The ``CircuitData`` to construct the Pauli feature map.
+#[pyfunction]
+#[pyo3(signature = (feature_dimension, parameters, *, reps=1, entanglement=None, paulis=None, alpha=2.0, insert_barriers=false, data_map_func=None))]
+#[allow(clippy::too_many_arguments)]
+pub fn pauli_feature_map(
+    py: Python,
+    feature_dimension: u32,
+    parameters: Bound<PyAny>,
+    reps: usize,
+    entanglement: Option<&Bound<PyAny>>,
+    paulis: Option<&Bound<PySequence>>,
+    alpha: f64,
+    insert_barriers: bool,
+    data_map_func: Option<&Bound<PyAny>>,
+) -> PyResult<CircuitData> {
+    // normalize the Pauli strings
+    let pauli_strings = _get_paulis(feature_dimension, paulis)?;
+
+    // set the default value for entanglement
+    let default = PyString::new_bound(py, "full");
+    let entanglement = entanglement.unwrap_or(&default);
+
+    // extract the parameters from the input variable ``parameters``
+    let parameter_vector = parameters
+        .iter()?
+        .map(|el| Param::extract_no_coerce(&el?))
+        .collect::<PyResult<Vec<Param>>>()?;
+
+    // construct a Barrier object Python side to (possibly) add to the circuit
+    let packed_barrier = if insert_barriers {
+        Some(_get_barrier(py, feature_dimension)?)
+    } else {
+        None
+    };
+
+    // Main work: construct the circuit instructions as iterator. Each repetition is constituted
+    // by a layer of Hadamards and the Pauli evolutions of the specified Paulis.
+    // Note that we eagerly trigger errors, since the final CircuitData::from_packed_operations
+    // does not allow Result objects in the iterator.
+    let mut packed_insts: Vec<Instruction> = Vec::new();
+    for rep in 0..reps {
+        // add H layer
+        packed_insts.extend(_get_h_layer(feature_dimension));
+
+        if insert_barriers {
+            packed_insts.push(packed_barrier.clone().unwrap());
+        }
+
+        // add evolutions
+        let evo_layer = _get_evolution_layer(
+            py,
+            feature_dimension,
+            rep,
+            alpha,
+            &parameter_vector,
+            &pauli_strings,
+            entanglement,
+            data_map_func,
+        )?;
+        packed_insts.extend(evo_layer);
+
+        // add barriers, if necessary
+        if insert_barriers && rep < reps - 1 {
+            packed_insts.push(packed_barrier.clone().unwrap());
+        }
+    }
+
+    CircuitData::from_packed_operations(py, feature_dimension, 0, packed_insts, Param::Float(0.0))
+}
+
+fn _get_h_layer(feature_dimension: u32) -> impl Iterator<Item = Instruction> {
+    (0..feature_dimension).map(|i| {
+        (
+            StandardGate::HGate.into(),
+            smallvec![],
+            vec![Qubit(i)],
+            vec![] as Vec<Clbit>,
+        )
+    })
+}
+
+#[allow(clippy::too_many_arguments)]
+fn _get_evolution_layer<'a>(
+    py: Python<'a>,
+    feature_dimension: u32,
+    rep: usize,
+    alpha: f64,
+    parameter_vector: &'a [Param],
+    pauli_strings: &'a [String],
+    entanglement: &'a Bound<PyAny>,
+    data_map_func: Option<&'a Bound<PyAny>>,
+) -> PyResult<Vec<Instruction>> {
+    let mut insts: Vec<Instruction> = Vec::new();
+
+    for pauli in pauli_strings {
+        let block_size = pauli.len() as u32;
+        let entanglement =
+            entanglement::get_entanglement(feature_dimension, block_size, entanglement, rep)?;
+
+        for indices in entanglement {
+            let indices = indices?;
+            let active_parameters: Vec<Param> = indices
+                .clone()
+                .iter()
+                .map(|i| parameter_vector[*i as usize].clone())
+                .collect();
+
+            let angle = match data_map_func {
+                Some(fun) => fun.call1((active_parameters,))?.extract()?,
+                None => _default_reduce(py, active_parameters),
+            };
+
+            // Get the pauli evolution and map it into
+            //   (PackedOperation, SmallVec<[Params; 3]>, Vec<Qubit>, Vec<Clbit>)
+            // to call CircuitData::from_packed_operations. This is needed since we might
+            // have to interject barriers, which are not a standard gate and prevents us
+            // from using CircuitData::from_standard_gates.
+            let evo = pauli_evolution(pauli, indices.clone(), multiply_param(&angle, alpha, py))
+                .map(|(gate, params, qargs)| {
+                    (gate.into(), params, qargs.to_vec(), vec![] as Vec<Clbit>)
+                })
+                .collect::<Vec<Instruction>>();
+            insts.extend(evo);
+        }
+    }
+
+    Ok(insts)
+}
+
+/// The default data_map_func for Pauli feature maps. For a parameter vector (x1, ..., xN), this
+/// implements
+///   (pi - x1) (pi - x2) ... (pi - xN)
+/// unless there is only one parameter, in which case it returns just the value.
+fn _default_reduce(py: Python, parameters: Vec<Param>) -> Param {
+    if parameters.len() == 1 {
+        parameters[0].clone()
+    } else {
+        let acc = parameters.iter().fold(Param::Float(1.0), |acc, param| {
+            multiply_params(acc, add_param(param, -PI, py), py)
+        });
+        if parameters.len() % 2 == 0 {
+            acc
+        } else {
+            multiply_param(&acc, -1.0, py) // take care of parity
+        }
+    }
+}
+
+/// Normalize the Pauli strings to a Vec<String>. We first define the default, which is
+/// ["z", "zz"], unless we only have a single qubit, in which case we default to ["z"].
+/// Then, ``pauli_strings`` is either set to the default, or we try downcasting to a
+/// PyString->String, followed by a check whether the feature dimension is large enough
+/// for the Pauli (e.g. we cannot implement a "zzz" Pauli on a 2 qubit circuit).
+fn _get_paulis(
+    feature_dimension: u32,
+    paulis: Option<&Bound<PySequence>>,
+) -> PyResult<Vec<String>> {
+    let default_pauli: Vec<String> = if feature_dimension == 1 {
+        vec!["z".to_string()]
+    } else {
+        vec!["z".to_string(), "zz".to_string()]
+    };
+
+    paulis.map_or_else(
+        || Ok(default_pauli), // use Ok() since we might raise an error in the other arm
+        |v| {
+            let v = PySequenceMethods::to_list(v)?; // sequence to list
+            v.iter() // iterate over the list of Paulis
+                .map(|el| {
+                    // Get the string and check whether it fits the feature dimension
+                    let as_string = (*el.downcast::<PyString>()?).to_string();
+                    if as_string.len() > feature_dimension as usize {
+                        Err(QiskitError::new_err(format!(
+                            "feature_dimension ({}) smaller than the Pauli ({})",
+                            feature_dimension, as_string
+                        )))
+                    } else {
+                        Ok(as_string)
+                    }
+                })
+                .collect::<PyResult<Vec<String>>>()
+        },
+    )
+}
+
+/// Get a barrier object from Python space.
+fn _get_barrier(py: Python, feature_dimension: u32) -> PyResult<Instruction> {
+    let barrier_cls = imports::BARRIER.get_bound(py);
+    let barrier = barrier_cls.call1((feature_dimension,))?;
+    let barrier_inst = PyInstruction {
+        qubits: feature_dimension,
+        clbits: 0,
+        params: 0,
+        op_name: "barrier".to_string(),
+        control_flow: false,
+        instruction: barrier.into(),
+    };
+    Ok((
+        barrier_inst.into(),
+        smallvec![],
+        (0..feature_dimension).map(Qubit).collect(),
+        vec![] as Vec<Clbit>,
+    ))
+}
diff --git a/crates/circuit/src/imports.rs b/crates/circuit/src/imports.rs
index a8f6d9562559..5c77f8ef7d17 100644
--- a/crates/circuit/src/imports.rs
+++ b/crates/circuit/src/imports.rs
@@ -109,6 +109,7 @@ pub static SWITCH_CASE_OP_CHECK: ImportOnceCell =
 pub static FOR_LOOP_OP_CHECK: ImportOnceCell =
     ImportOnceCell::new("qiskit.dagcircuit.dagnode", "_for_loop_eq");
 pub static UUID: ImportOnceCell = ImportOnceCell::new("uuid", "UUID");
+pub static BARRIER: ImportOnceCell = ImportOnceCell::new("qiskit.circuit", "Barrier");
 pub static UNITARY_GATE: ImportOnceCell = ImportOnceCell::new(
     "qiskit.circuit.library.generalized_gates.unitary",
     "UnitaryGate",
diff --git a/crates/circuit/src/operations.rs b/crates/circuit/src/operations.rs
index a3fd2fc83c3d..2a341d687f6c 100644
--- a/crates/circuit/src/operations.rs
+++ b/crates/circuit/src/operations.rs
@@ -2051,7 +2051,8 @@ fn clone_param(param: &Param, py: Python) -> Param {
     }
 }
 
-fn multiply_param(param: &Param, mult: f64, py: Python) -> Param {
+/// Multiply a ``Param`` with a float.
+pub fn multiply_param(param: &Param, mult: f64, py: Python) -> Param {
     match param {
         Param::Float(theta) => Param::Float(theta * mult),
         Param::ParameterExpression(theta) => Param::ParameterExpression(
@@ -2064,7 +2065,24 @@ fn multiply_param(param: &Param, mult: f64, py: Python) -> Param {
     }
 }
 
-fn add_param(param: &Param, summand: f64, py: Python) -> Param {
+/// Multiply two ``Param``s.
+pub fn multiply_params(param1: Param, param2: Param, py: Python) -> Param {
+    match (&param1, &param2) {
+        (Param::Float(theta), Param::Float(lambda)) => Param::Float(theta * lambda),
+        (param, Param::Float(theta)) => multiply_param(param, *theta, py),
+        (Param::Float(theta), param) => multiply_param(param, *theta, py),
+        (Param::ParameterExpression(p1), Param::ParameterExpression(p2)) => {
+            Param::ParameterExpression(
+                p1.clone_ref(py)
+                    .call_method1(py, intern!(py, "__rmul__"), (p2,))
+                    .expect("Parameter expression multiplication failed"),
+            )
+        }
+        _ => unreachable!("Unsupported multiplication."),
+    }
+}
+
+pub fn add_param(param: &Param, summand: f64, py: Python) -> Param {
     match param {
         Param::Float(theta) => Param::Float(*theta + summand),
         Param::ParameterExpression(theta) => Param::ParameterExpression(
diff --git a/qiskit/circuit/library/__init__.py b/qiskit/circuit/library/__init__.py
index 39266cf4ca17..9dd1fdebf08a 100644
--- a/qiskit/circuit/library/__init__.py
+++ b/qiskit/circuit/library/__init__.py
@@ -555,6 +555,9 @@
     QAOAAnsatz,
 )
 from .data_preparation import (
+    z_feature_map,
+    zz_feature_map,
+    pauli_feature_map,
     PauliFeatureMap,
     ZFeatureMap,
     ZZFeatureMap,
diff --git a/qiskit/circuit/library/data_preparation/__init__.py b/qiskit/circuit/library/data_preparation/__init__.py
index 192308a3a7f5..475046d78338 100644
--- a/qiskit/circuit/library/data_preparation/__init__.py
+++ b/qiskit/circuit/library/data_preparation/__init__.py
@@ -38,15 +38,18 @@
 
 """
 
-from .pauli_feature_map import PauliFeatureMap
-from .z_feature_map import ZFeatureMap
-from .zz_feature_map import ZZFeatureMap
+from .pauli_feature_map import PauliFeatureMap, pauli_feature_map, z_feature_map, zz_feature_map
+from ._z_feature_map import ZFeatureMap
+from ._zz_feature_map import ZZFeatureMap
 from .state_preparation import StatePreparation, UniformSuperpositionGate
 from .initializer import Initialize
 
 __all__ = [
+    "pauli_feature_map",
     "PauliFeatureMap",
+    "z_feature_map",
     "ZFeatureMap",
+    "zz_feature_map",
     "ZZFeatureMap",
     "StatePreparation",
     "UniformSuperpositionGate",
diff --git a/qiskit/circuit/library/data_preparation/z_feature_map.py b/qiskit/circuit/library/data_preparation/_z_feature_map.py
similarity index 52%
rename from qiskit/circuit/library/data_preparation/z_feature_map.py
rename to qiskit/circuit/library/data_preparation/_z_feature_map.py
index 902de1a6a5ac..451776067114 100644
--- a/qiskit/circuit/library/data_preparation/z_feature_map.py
+++ b/qiskit/circuit/library/data_preparation/_z_feature_map.py
@@ -14,6 +14,7 @@
 
 from typing import Callable, Optional
 import numpy as np
+from qiskit.utils.deprecation import deprecate_func
 
 from .pauli_feature_map import PauliFeatureMap
 
@@ -25,13 +26,13 @@ class ZFeatureMap(PauliFeatureMap):
 
     .. parsed-literal::
 
-        ┌───┐┌──────────────┐┌───┐┌──────────────┐
-        ┤ H ├┤ U1(2.0*x[0]) ├┤ H ├┤ U1(2.0*x[0]) ├
-        ├───┤├──────────────┤├───┤├──────────────┤
-        ┤ H ├┤ U1(2.0*x[1]) ├┤ H ├┤ U1(2.0*x[1]) ├
-        ├───┤├──────────────┤├───┤├──────────────┤
-        ┤ H ├┤ U1(2.0*x[2]) ├┤ H ├┤ U1(2.0*x[2]) ├
-        └───┘└──────────────┘└───┘└──────────────┘
+        ┌───┐┌─────────────┐┌───┐┌─────────────┐
+        ┤ H ├┤ P(2.0*x[0]) ├┤ H ├┤ P(2.0*x[0]) ├
+        ├───┤├─────────────┤├───┤├─────────────┤
+        ┤ H ├┤ U(2.0*x[1]) ├┤ H ├┤ P(2.0*x[1]) ├
+        ├───┤├─────────────┤├───┤├─────────────┤
+        ┤ H ├┤ P(2.0*x[2]) ├┤ H ├┤ P(2.0*x[2]) ├
+        └───┘└─────────────┘└───┘└─────────────┘
 
     This is a sub-class of :class:`~qiskit.circuit.library.PauliFeatureMap` where the Pauli
     strings are fixed as `['Z']`. As a result the first order expansion will be a circuit without
@@ -40,38 +41,48 @@ class ZFeatureMap(PauliFeatureMap):
     Examples:
 
         >>> prep = ZFeatureMap(3, reps=3, insert_barriers=True)
-        >>> print(prep)
-             ┌───┐ ░ ┌──────────────┐ ░ ┌───┐ ░ ┌──────────────┐ ░ ┌───┐ ░ ┌──────────────┐
-        q_0: ┤ H ├─░─┤ U1(2.0*x[0]) ├─░─┤ H ├─░─┤ U1(2.0*x[0]) ├─░─┤ H ├─░─┤ U1(2.0*x[0]) ├
-             ├───┤ ░ ├──────────────┤ ░ ├───┤ ░ ├──────────────┤ ░ ├───┤ ░ ├──────────────┤
-        q_1: ┤ H ├─░─┤ U1(2.0*x[1]) ├─░─┤ H ├─░─┤ U1(2.0*x[1]) ├─░─┤ H ├─░─┤ U1(2.0*x[1]) ├
-             ├───┤ ░ ├──────────────┤ ░ ├───┤ ░ ├──────────────┤ ░ ├───┤ ░ ├──────────────┤
-        q_2: ┤ H ├─░─┤ U1(2.0*x[2]) ├─░─┤ H ├─░─┤ U1(2.0*x[2]) ├─░─┤ H ├─░─┤ U1(2.0*x[2]) ├
-             └───┘ ░ └──────────────┘ ░ └───┘ ░ └──────────────┘ ░ └───┘ ░ └──────────────┘
+        >>> print(prep.decompose())
+             ┌───┐ ░ ┌─────────────┐ ░ ┌───┐ ░ ┌─────────────┐ ░ ┌───┐ ░ ┌─────────────┐
+        q_0: ┤ H ├─░─┤ P(2.0*x[0]) ├─░─┤ H ├─░─┤ P(2.0*x[0]) ├─░─┤ H ├─░─┤ P(2.0*x[0]) ├
+             ├───┤ ░ ├─────────────┤ ░ ├───┤ ░ ├─────────────┤ ░ ├───┤ ░ ├─────────────┤
+        q_1: ┤ H ├─░─┤ P(2.0*x[1]) ├─░─┤ H ├─░─┤ P(2.0*x[1]) ├─░─┤ H ├─░─┤ P(2.0*x[1]) ├
+             ├───┤ ░ ├─────────────┤ ░ ├───┤ ░ ├─────────────┤ ░ ├───┤ ░ ├─────────────┤
+        q_2: ┤ H ├─░─┤ P(2.0*x[2]) ├─░─┤ H ├─░─┤ P(2.0*x[2]) ├─░─┤ H ├─░─┤ P(2.0*x[2]) ├
+             └───┘ ░ └─────────────┘ ░ └───┘ ░ └─────────────┘ ░ └───┘ ░ └─────────────┘
 
         >>> data_map = lambda x: x[0]*x[0] + 1  # note: input is an array
         >>> prep = ZFeatureMap(3, reps=1, data_map_func=data_map)
-        >>> print(prep)
-             ┌───┐┌───────────────────────┐
-        q_0: ┤ H ├┤ U1(2.0*x[0]**2 + 2.0) ├
-             ├───┤├───────────────────────┤
-        q_1: ┤ H ├┤ U1(2.0*x[1]**2 + 2.0) ├
-             ├───┤├───────────────────────┤
-        q_2: ┤ H ├┤ U1(2.0*x[2]**2 + 2.0) ├
-             └───┘└───────────────────────┘
-
-        >>> classifier = ZFeatureMap(3, reps=1) + RY(3, reps=1)
-        >>> print(classifier)
-             ┌───┐┌──────────────┐┌──────────┐      ┌──────────┐
-        q_0: ┤ H ├┤ U1(2.0*x[0]) ├┤ RY(θ[0]) ├─■──■─┤ RY(θ[3]) ├────────────
-             ├───┤├──────────────┤├──────────┤ │  │ └──────────┘┌──────────┐
-        q_1: ┤ H ├┤ U1(2.0*x[1]) ├┤ RY(θ[1]) ├─■──┼──────■──────┤ RY(θ[4]) ├
-             ├───┤├──────────────┤├──────────┤    │      │      ├──────────┤
-        q_2: ┤ H ├┤ U1(2.0*x[2]) ├┤ RY(θ[2]) ├────■──────■──────┤ RY(θ[5]) ├
-             └───┘└──────────────┘└──────────┘                  └──────────┘
+        >>> print(prep.decompose())
+             ┌───┐┌──────────────────────┐
+        q_0: ┤ H ├┤ P(2.0*x[0]**2 + 2.0) ├
+             ├───┤├──────────────────────┤
+        q_1: ┤ H ├┤ P(2.0*x[1]**2 + 2.0) ├
+             ├───┤├──────────────────────┤
+        q_2: ┤ H ├┤ P(2.0*x[2]**2 + 2.0) ├
+             └───┘└──────────────────────┘
+
+        >>> from qiskit.circuit.library import TwoLocal
+        >>> ry = TwoLocal(3, "ry", "cz", reps=1)
+        >>> classifier = ZFeatureMap(3, reps=1) + ry
+        >>> print(classifier.decompose())
+             ┌───┐┌─────────────┐┌──────────┐      ┌──────────┐
+        q_0: ┤ H ├┤ P(2.0*x[0]) ├┤ RY(θ[0]) ├─■──■─┤ RY(θ[3]) ├────────────
+             ├───┤├─────────────┤├──────────┤ │  │ └──────────┘┌──────────┐
+        q_1: ┤ H ├┤ P(2.0*x[1]) ├┤ RY(θ[1]) ├─■──┼──────■──────┤ RY(θ[4]) ├
+             ├───┤├─────────────┤├──────────┤    │      │      ├──────────┤
+        q_2: ┤ H ├┤ P(2.0*x[2]) ├┤ RY(θ[2]) ├────■──────■──────┤ RY(θ[5]) ├
+             └───┘└─────────────┘└──────────┘                  └──────────┘
 
     """
 
+    @deprecate_func(
+        since="1.3",
+        additional_msg=(
+            "Use the z_feature_map function as a replacement. Note that this will no longer "
+            "return a BlueprintCircuit, but just a plain QuantumCircuit."
+        ),
+        pending=True,
+    )
     def __init__(
         self,
         feature_dimension: int,
diff --git a/qiskit/circuit/library/data_preparation/zz_feature_map.py b/qiskit/circuit/library/data_preparation/_zz_feature_map.py
similarity index 71%
rename from qiskit/circuit/library/data_preparation/zz_feature_map.py
rename to qiskit/circuit/library/data_preparation/_zz_feature_map.py
index 2f51b8f63482..2a170513dfdb 100644
--- a/qiskit/circuit/library/data_preparation/zz_feature_map.py
+++ b/qiskit/circuit/library/data_preparation/_zz_feature_map.py
@@ -14,6 +14,7 @@
 
 from typing import Callable, List, Union, Optional, Dict, Tuple
 import numpy as np
+from qiskit.utils.deprecation import deprecate_func
 from .pauli_feature_map import PauliFeatureMap
 
 
@@ -24,13 +25,13 @@ class ZZFeatureMap(PauliFeatureMap):
 
     .. parsed-literal::
 
-        ┌───┐┌─────────────────┐
-        ┤ H ├┤ U1(2.0*φ(x[0])) ├──■────────────────────────────■────────────────────────────────────
-        ├───┤├─────────────────┤┌─┴─┐┌──────────────────────┐┌─┴─┐
-        ┤ H ├┤ U1(2.0*φ(x[1])) ├┤ X ├┤ U1(2.0*φ(x[0],x[1])) ├┤ X ├──■────────────────────────────■──
-        ├───┤├─────────────────┤└───┘└──────────────────────┘└───┘┌─┴─┐┌──────────────────────┐┌─┴─┐
-        ┤ H ├┤ U1(2.0*φ(x[2])) ├──────────────────────────────────┤ X ├┤ U1(2.0*φ(x[1],x[2])) ├┤ X ├
-        └───┘└─────────────────┘                                  └───┘└──────────────────────┘└───┘
+        ┌───┐┌────────────────┐
+        ┤ H ├┤ P(2.0*φ(x[0])) ├──■───────────────────────────■───────────────────────────────────
+        ├───┤├────────────────┤┌─┴─┐┌─────────────────────┐┌─┴─┐
+        ┤ H ├┤ P(2.0*φ(x[1])) ├┤ X ├┤ P(2.0*φ(x[0],x[1])) ├┤ X ├──■───────────────────────────■──
+        ├───┤├────────────────┤└───┘└─────────────────────┘└───┘┌─┴─┐┌─────────────────────┐┌─┴─┐
+        ┤ H ├┤ P(2.0*φ(x[2])) ├─────────────────────────────────┤ X ├┤ P(2.0*φ(x[1],x[2])) ├┤ X ├
+        └───┘└────────────────┘                                 └───┘└─────────────────────┘└───┘
 
     where :math:`\varphi` is a classical non-linear function, which defaults to :math:`\varphi(x) = x`
     if and :math:`\varphi(x,y) = (\pi - x)(\pi - y)`.
@@ -39,12 +40,12 @@ class ZZFeatureMap(PauliFeatureMap):
 
         >>> from qiskit.circuit.library import ZZFeatureMap
         >>> prep = ZZFeatureMap(2, reps=1)
-        >>> print(prep)
-             ┌───┐┌──────────────┐
-        q_0: ┤ H ├┤ U1(2.0*x[0]) ├──■───────────────────────────────────────■──
-             ├───┤├──────────────┤┌─┴─┐┌─────────────────────────────────┐┌─┴─┐
-        q_1: ┤ H ├┤ U1(2.0*x[1]) ├┤ X ├┤ U1(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├
-             └───┘└──────────────┘└───┘└─────────────────────────────────┘└───┘
+        >>> print(prep.decompose())
+             ┌───┐┌─────────────┐
+        q_0: ┤ H ├┤ P(2.0*x[0]) ├──■──────────────────────────────────────■──
+             ├───┤├─────────────┤┌─┴─┐┌────────────────────────────────┐┌─┴─┐
+        q_1: ┤ H ├┤ P(2.0*x[1]) ├┤ X ├┤ P(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├
+             └───┘└─────────────┘└───┘└────────────────────────────────┘└───┘
 
         >>> from qiskit.circuit.library import EfficientSU2
         >>> classifier = ZZFeatureMap(3) + EfficientSU2(3)
@@ -71,6 +72,14 @@ class ZZFeatureMap(PauliFeatureMap):
         OrderedDict([('ZZFeatureMap', 1), ('EfficientSU2', 1)])
     """
 
+    @deprecate_func(
+        since="1.3",
+        additional_msg=(
+            "Use the z_feature_map function as a replacement. Note that this will no longer "
+            "return a BlueprintCircuit, but just a plain QuantumCircuit."
+        ),
+        pending=True,
+    )
     def __init__(
         self,
         feature_dimension: int,
diff --git a/qiskit/circuit/library/data_preparation/pauli_feature_map.py b/qiskit/circuit/library/data_preparation/pauli_feature_map.py
index 8cad7d23835b..a40deb6ea18b 100644
--- a/qiskit/circuit/library/data_preparation/pauli_feature_map.py
+++ b/qiskit/circuit/library/data_preparation/pauli_feature_map.py
@@ -11,17 +11,316 @@
 # that they have been altered from the originals.
 
 """The Pauli expansion circuit module."""
-from typing import Optional, Callable, List, Union, Sequence, Dict, Tuple
+
+from __future__ import annotations
+
+from collections.abc import Sequence, Mapping
+from typing import Optional, Callable, List, Union, Dict, Tuple
 from functools import reduce
 import numpy as np
 
 from qiskit.circuit import QuantumCircuit
-from qiskit.circuit import Parameter, ParameterVector
+from qiskit.circuit import Parameter, ParameterVector, ParameterExpression
 from qiskit.circuit.library.standard_gates import HGate
+from qiskit.utils.deprecation import deprecate_func
+from qiskit._accelerate.circuit_library import pauli_feature_map as _fast_map
 
 from ..n_local.n_local import NLocal
 
 
+def _normalize_entanglement(
+    entanglement: str | Mapping[int, Sequence[Sequence[int]]]
+) -> str | dict[int, list[tuple[int]]]:
+    if isinstance(entanglement, str):
+        return entanglement
+
+    return {
+        num_paulis: [tuple(connections) for connections in ent]
+        for num_paulis, ent in entanglement.items()
+    }
+
+
+def pauli_feature_map(
+    feature_dimension: int,
+    reps: int = 2,
+    entanglement: (
+        str
+        | Mapping[int, Sequence[Sequence[int]]]
+        | Callable[[int], str | Mapping[int, Sequence[Sequence[int]]]]
+    ) = "full",
+    alpha: float = 2.0,
+    paulis: list[str] | None = None,
+    data_map_func: Callable[[Parameter], ParameterExpression] | None = None,
+    parameter_prefix: str = "x",
+    insert_barriers: bool = False,
+    name: str = "PauliFeatureMap",
+) -> QuantumCircuit:
+    r"""The Pauli expansion circuit.
+
+    The Pauli expansion circuit is a data encoding circuit that transforms input data
+    :math:`\vec{x} \in \mathbb{R}^n`, where :math:`n` is the ``feature_dimension``, as
+
+    .. math::
+
+        U_{\Phi(\vec{x})}=\exp\left(i\sum_{S \in \mathcal{I}}
+        \phi_S(\vec{x})\prod_{i\in S} P_i\right).
+
+    Here, :math:`S` is a set of qubit indices that describes the connections in the feature map,
+    :math:`\mathcal{I}` is a set containing all these index sets, and
+    :math:`P_i \in \{I, X, Y, Z\}`. Per default the data-mapping
+    :math:`\phi_S` is
+
+    .. math::
+
+        \phi_S(\vec{x}) = \begin{cases}
+            x_i \text{ if } S = \{i\} \\
+            \prod_{j \in S} (\pi - x_j) \text{ if } |S| > 1
+            \end{cases}.
+
+    The possible connections can be set using the ``entanglement`` and ``paulis`` arguments.
+    For example, for single-qubit :math:`Z` rotations and two-qubit :math:`YY` interactions
+    between all qubit pairs, we can set::
+
+
+        circuit = pauli_feature_map(..., paulis=["Z", "YY"], entanglement="full")
+
+    which will produce blocks of the form
+
+    .. parsed-literal::
+
+        ┌───┐┌─────────────┐┌──────────┐                                            ┌───────────┐
+        ┤ H ├┤ P(2.0*x[0]) ├┤ RX(pi/2) ├──■──────────────────────────────────────■──┤ RX(-pi/2) ├
+        ├───┤├─────────────┤├──────────┤┌─┴─┐┌────────────────────────────────┐┌─┴─┐├───────────┤
+        ┤ H ├┤ P(2.0*x[1]) ├┤ RX(pi/2) ├┤ X ├┤ P(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├┤ RX(-pi/2) ├
+        └───┘└─────────────┘└──────────┘└───┘└────────────────────────────────┘└───┘└───────────┘
+
+    The circuit contains ``reps`` repetitions of this transformation.
+
+    Please refer to :func:`.z_feature_map` for the case of single-qubit Pauli-:math:`Z` rotations
+    and to :func:`.zz_feature_map` for the single- and two-qubit Pauli-:math:`Z` rotations.
+
+    Examples:
+
+        >>> prep = pauli_feature_map(2, reps=1, paulis=["ZZ"])
+        >>> print(prep)
+             ┌───┐
+        q_0: ┤ H ├──■──────────────────────────────────────■──
+             ├───┤┌─┴─┐┌────────────────────────────────┐┌─┴─┐
+        q_1: ┤ H ├┤ X ├┤ P(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├
+             └───┘└───┘└────────────────────────────────┘└───┘
+
+        >>> prep = pauli_feature_map(2, reps=1, paulis=["Z", "XX"])
+        >>> print(prep)
+             ┌───┐┌─────────────┐┌───┐                                            ┌───┐
+        q_0: ┤ H ├┤ P(2.0*x[0]) ├┤ H ├──■──────────────────────────────────────■──┤ H ├
+             ├───┤├─────────────┤├───┤┌─┴─┐┌────────────────────────────────┐┌─┴─┐├───┤
+        q_1: ┤ H ├┤ P(2.0*x[1]) ├┤ H ├┤ X ├┤ P(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├┤ H ├
+             └───┘└─────────────┘└───┘└───┘└────────────────────────────────┘└───┘└───┘
+
+        >>> prep = pauli_feature_map(2, reps=1, paulis=["ZY"])
+        >>> print(prep)
+             ┌───┐┌──────────┐                                            ┌───────────┐
+        q_0: ┤ H ├┤ RX(pi/2) ├──■──────────────────────────────────────■──┤ RX(-pi/2) ├
+             ├───┤└──────────┘┌─┴─┐┌────────────────────────────────┐┌─┴─┐└───────────┘
+        q_1: ┤ H ├────────────┤ X ├┤ P(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├─────────────
+             └───┘            └───┘└────────────────────────────────┘└───┘
+
+        >>> from qiskit.circuit.library import EfficientSU2
+        >>> prep = pauli_feature_map(3, reps=3, paulis=["Z", "YY", "ZXZ"])
+        >>> wavefunction = EfficientSU2(3)
+        >>> classifier = prep.compose(wavefunction)
+        >>> classifier.num_parameters
+        27
+        >>> classifier.count_ops()
+        OrderedDict([('cx', 39), ('rx', 36), ('u1', 21), ('h', 15), ('ry', 12), ('rz', 12)])
+
+    References:
+
+    [1] Havlicek et al. Supervised learning with quantum enhanced feature spaces,
+    `Nature 567, 209-212 (2019) <https://www.nature.com/articles/s41586-019-0980-2>`__.
+    """
+    # create parameter vector used in the Pauli feature map
+    parameters = ParameterVector(parameter_prefix, feature_dimension)
+
+    # the Rust implementation expects the entanglement to be a str or list[tuple[int]] (or the
+    # callable to return these types), therefore we normalize the entanglement here
+    if callable(entanglement):
+        normalized = lambda offset: _normalize_entanglement(entanglement(offset))
+    else:
+        normalized = _normalize_entanglement(entanglement)
+
+    # construct from Rust
+    circuit = QuantumCircuit._from_circuit_data(
+        _fast_map(
+            feature_dimension,
+            paulis=paulis,
+            entanglement=normalized,
+            reps=reps,
+            parameters=parameters,
+            data_map_func=data_map_func,
+            alpha=alpha,
+            insert_barriers=insert_barriers,
+        )
+    )
+    circuit.name = name
+
+    return circuit
+
+
+def z_feature_map(
+    feature_dimension: int,
+    reps: int = 2,
+    entanglement: (
+        str | Sequence[Sequence[int]] | Callable[[int], str | Sequence[Sequence[int]]]
+    ) = "full",
+    alpha: float = 2.0,
+    data_map_func: Callable[[Parameter], ParameterExpression] | None = None,
+    parameter_prefix: str = "x",
+    insert_barriers: bool = False,
+    name: str = "ZFeatureMap",
+) -> QuantumCircuit:
+    """The first order Pauli Z-evolution circuit.
+
+    On 3 qubits and with 2 repetitions the circuit is represented by:
+
+    .. parsed-literal::
+
+        ┌───┐┌─────────────┐┌───┐┌─────────────┐
+        ┤ H ├┤ P(2.0*x[0]) ├┤ H ├┤ P(2.0*x[0]) ├
+        ├───┤├─────────────┤├───┤├─────────────┤
+        ┤ H ├┤ U(2.0*x[1]) ├┤ H ├┤ P(2.0*x[1]) ├
+        ├───┤├─────────────┤├───┤├─────────────┤
+        ┤ H ├┤ P(2.0*x[2]) ├┤ H ├┤ P(2.0*x[2]) ├
+        └───┘└─────────────┘└───┘└─────────────┘
+
+    This is a sub-class of :class:`~qiskit.circuit.library.PauliFeatureMap` where the Pauli
+    strings are fixed as `['Z']`. As a result the first order expansion will be a circuit without
+    entangling gates.
+
+    Examples:
+
+        >>> prep = z_feature_map(3, reps=3, insert_barriers=True)
+        >>> print(prep)
+             ┌───┐ ░ ┌─────────────┐ ░ ┌───┐ ░ ┌─────────────┐ ░ ┌───┐ ░ ┌─────────────┐
+        q_0: ┤ H ├─░─┤ P(2.0*x[0]) ├─░─┤ H ├─░─┤ P(2.0*x[0]) ├─░─┤ H ├─░─┤ P(2.0*x[0]) ├
+             ├───┤ ░ ├─────────────┤ ░ ├───┤ ░ ├─────────────┤ ░ ├───┤ ░ ├─────────────┤
+        q_1: ┤ H ├─░─┤ P(2.0*x[1]) ├─░─┤ H ├─░─┤ P(2.0*x[1]) ├─░─┤ H ├─░─┤ P(2.0*x[1]) ├
+             ├───┤ ░ ├─────────────┤ ░ ├───┤ ░ ├─────────────┤ ░ ├───┤ ░ ├─────────────┤
+        q_2: ┤ H ├─░─┤ P(2.0*x[2]) ├─░─┤ H ├─░─┤ P(2.0*x[2]) ├─░─┤ H ├─░─┤ P(2.0*x[2]) ├
+             └───┘ ░ └─────────────┘ ░ └───┘ ░ └─────────────┘ ░ └───┘ ░ └─────────────┘
+
+        >>> data_map = lambda x: x[0]*x[0] + 1  # note: input is an array
+        >>> prep = z_feature_map(3, reps=1, data_map_func=data_map)
+        >>> print(prep)
+             ┌───┐┌──────────────────────┐
+        q_0: ┤ H ├┤ P(2.0*x[0]**2 + 2.0) ├
+             ├───┤├──────────────────────┤
+        q_1: ┤ H ├┤ P(2.0*x[1]**2 + 2.0) ├
+             ├───┤├──────────────────────┤
+        q_2: ┤ H ├┤ P(2.0*x[2]**2 + 2.0) ├
+             └───┘└──────────────────────┘
+
+        >>> from qiskit.circuit.library import TwoLocal
+        >>> ry = TwoLocal(3, "ry", "cz", reps=1).decompose()
+        >>> classifier = z_feature_map(3, reps=1) + ry
+        >>> print(classifier)
+             ┌───┐┌─────────────┐┌──────────┐      ┌──────────┐
+        q_0: ┤ H ├┤ P(2.0*x[0]) ├┤ RY(θ[0]) ├─■──■─┤ RY(θ[3]) ├────────────
+             ├───┤├─────────────┤├──────────┤ │  │ └──────────┘┌──────────┐
+        q_1: ┤ H ├┤ P(2.0*x[1]) ├┤ RY(θ[1]) ├─■──┼──────■──────┤ RY(θ[4]) ├
+             ├───┤├─────────────┤├──────────┤    │      │      ├──────────┤
+        q_2: ┤ H ├┤ P(2.0*x[2]) ├┤ RY(θ[2]) ├────■──────■──────┤ RY(θ[5]) ├
+             └───┘└─────────────┘└──────────┘                  └──────────┘
+
+    """
+    return pauli_feature_map(
+        feature_dimension=feature_dimension,
+        reps=reps,
+        entanglement=entanglement,
+        alpha=alpha,
+        paulis=["z"],
+        data_map_func=data_map_func,
+        parameter_prefix=parameter_prefix,
+        insert_barriers=insert_barriers,
+        name=name,
+    )
+
+
+def zz_feature_map(
+    feature_dimension: int,
+    reps: int = 2,
+    entanglement: (
+        str | Sequence[Sequence[int]] | Callable[[int], str | Sequence[Sequence[int]]]
+    ) = "full",
+    alpha: float = 2.0,
+    data_map_func: Callable[[Parameter], ParameterExpression] | None = None,
+    parameter_prefix: str = "x",
+    insert_barriers: bool = False,
+    name: str = "ZZFeatureMap",
+) -> QuantumCircuit:
+    r"""Second-order Pauli-Z evolution circuit.
+
+    For 3 qubits and 1 repetition and linear entanglement the circuit is represented by:
+
+    .. parsed-literal::
+
+        ┌───┐┌────────────────┐
+        ┤ H ├┤ P(2.0*φ(x[0])) ├──■───────────────────────────■───────────────────────────────────
+        ├───┤├────────────────┤┌─┴─┐┌─────────────────────┐┌─┴─┐
+        ┤ H ├┤ P(2.0*φ(x[1])) ├┤ X ├┤ P(2.0*φ(x[0],x[1])) ├┤ X ├──■───────────────────────────■──
+        ├───┤├────────────────┤└───┘└─────────────────────┘└───┘┌─┴─┐┌─────────────────────┐┌─┴─┐
+        ┤ H ├┤ P(2.0*φ(x[2])) ├─────────────────────────────────┤ X ├┤ P(2.0*φ(x[1],x[2])) ├┤ X ├
+        └───┘└────────────────┘                                 └───┘└─────────────────────┘└───┘
+
+    where :math:`\varphi` is a classical non-linear function, which defaults to :math:`\varphi(x) = x`
+    if and :math:`\varphi(x,y) = (\pi - x)(\pi - y)`.
+
+    Examples:
+
+        >>> from qiskit.circuit.library import ZZFeatureMap
+        >>> prep = zz_feature_map(2, reps=1)
+        >>> print(prep)
+             ┌───┐┌─────────────┐
+        q_0: ┤ H ├┤ P(2.0*x[0]) ├──■──────────────────────────────────────■──
+             ├───┤├─────────────┤┌─┴─┐┌────────────────────────────────┐┌─┴─┐
+        q_1: ┤ H ├┤ P(2.0*x[1]) ├┤ X ├┤ P(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├
+             └───┘└─────────────┘└───┘└────────────────────────────────┘└───┘
+
+        >>> from qiskit.circuit.library import EfficientSU2
+        >>> classifier = zz_feature_map(3) + EfficientSU2(3)
+        >>> classifier.num_parameters
+        15
+        >>> classifier.parameters  # 'x' for the data preparation, 'θ' for the SU2 parameters
+        ParameterView([
+            ParameterVectorElement(x[0]), ParameterVectorElement(x[1]),
+            ParameterVectorElement(x[2]), ParameterVectorElement(θ[0]),
+            ParameterVectorElement(θ[1]), ParameterVectorElement(θ[2]),
+            ParameterVectorElement(θ[3]), ParameterVectorElement(θ[4]),
+            ParameterVectorElement(θ[5]), ParameterVectorElement(θ[6]),
+            ParameterVectorElement(θ[7]), ParameterVectorElement(θ[8]),
+            ParameterVectorElement(θ[9]), ParameterVectorElement(θ[10]),
+            ParameterVectorElement(θ[11]), ParameterVectorElement(θ[12]),
+            ParameterVectorElement(θ[13]), ParameterVectorElement(θ[14]),
+            ParameterVectorElement(θ[15]), ParameterVectorElement(θ[16]),
+            ParameterVectorElement(θ[17]), ParameterVectorElement(θ[18]),
+            ParameterVectorElement(θ[19]), ParameterVectorElement(θ[20]),
+            ParameterVectorElement(θ[21]), ParameterVectorElement(θ[22]),
+            ParameterVectorElement(θ[23])
+        ])
+    """
+    return pauli_feature_map(
+        feature_dimension=feature_dimension,
+        reps=reps,
+        entanglement=entanglement,
+        alpha=alpha,
+        paulis=["z", "zz"],
+        data_map_func=data_map_func,
+        parameter_prefix=parameter_prefix,
+        insert_barriers=insert_barriers,
+        name=name,
+    )
+
+
 class PauliFeatureMap(NLocal):
     r"""The Pauli Expansion circuit.
 
@@ -56,11 +355,11 @@ class PauliFeatureMap(NLocal):
 
     .. parsed-literal::
 
-        ┌───┐┌──────────────┐┌──────────┐                                             ┌───────────┐
-        ┤ H ├┤ U1(2.0*x[0]) ├┤ RX(pi/2) ├──■───────────────────────────────────────■──┤ RX(-pi/2) ├
-        ├───┤├──────────────┤├──────────┤┌─┴─┐┌─────────────────────────────────┐┌─┴─┐├───────────┤
-        ┤ H ├┤ U1(2.0*x[1]) ├┤ RX(pi/2) ├┤ X ├┤ U1(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├┤ RX(-pi/2) ├
-        └───┘└──────────────┘└──────────┘└───┘└─────────────────────────────────┘└───┘└───────────┘
+        ┌───┐┌─────────────┐┌──────────┐                                            ┌───────────┐
+        ┤ H ├┤ P(2.0*x[0]) ├┤ RX(pi/2) ├──■──────────────────────────────────────■──┤ RX(-pi/2) ├
+        ├───┤├─────────────┤├──────────┤┌─┴─┐┌────────────────────────────────┐┌─┴─┐├───────────┤
+        ┤ H ├┤ P(2.0*x[1]) ├┤ RX(pi/2) ├┤ X ├┤ P(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├┤ RX(-pi/2) ├
+        └───┘└─────────────┘└──────────┘└───┘└────────────────────────────────┘└───┘└───────────┘
 
     The circuit contains ``reps`` repetitions of this transformation.
 
@@ -70,28 +369,28 @@ class PauliFeatureMap(NLocal):
     Examples:
 
         >>> prep = PauliFeatureMap(2, reps=1, paulis=['ZZ'])
-        >>> print(prep)
+        >>> print(prep.decompose())
              ┌───┐
-        q_0: ┤ H ├──■───────────────────────────────────────■──
-             ├───┤┌─┴─┐┌─────────────────────────────────┐┌─┴─┐
-        q_1: ┤ H ├┤ X ├┤ U1(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├
-             └───┘└───┘└─────────────────────────────────┘└───┘
+        q_0: ┤ H ├──■──────────────────────────────────────■──
+             ├───┤┌─┴─┐┌────────────────────────────────┐┌─┴─┐
+        q_1: ┤ H ├┤ X ├┤ P(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├
+             └───┘└───┘└────────────────────────────────┘└───┘
 
         >>> prep = PauliFeatureMap(2, reps=1, paulis=['Z', 'XX'])
-        >>> print(prep)
-             ┌───┐┌──────────────┐┌───┐                                             ┌───┐
-        q_0: ┤ H ├┤ U1(2.0*x[0]) ├┤ H ├──■───────────────────────────────────────■──┤ H ├
-             ├───┤├──────────────┤├───┤┌─┴─┐┌─────────────────────────────────┐┌─┴─┐├───┤
-        q_1: ┤ H ├┤ U1(2.0*x[1]) ├┤ H ├┤ X ├┤ U1(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├┤ H ├
-             └───┘└──────────────┘└───┘└───┘└─────────────────────────────────┘└───┘└───┘
+        >>> print(prep.decompose())
+             ┌───┐┌─────────────┐┌───┐                                            ┌───┐
+        q_0: ┤ H ├┤ P(2.0*x[0]) ├┤ H ├──■──────────────────────────────────────■──┤ H ├
+             ├───┤├─────────────┤├───┤┌─┴─┐┌────────────────────────────────┐┌─┴─┐├───┤
+        q_1: ┤ H ├┤ P(2.0*x[1]) ├┤ H ├┤ X ├┤ P(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├┤ H ├
+             └───┘└─────────────┘└───┘└───┘└────────────────────────────────┘└───┘└───┘
 
         >>> prep = PauliFeatureMap(2, reps=1, paulis=['ZY'])
-        >>> print(prep)
-             ┌───┐┌──────────┐                                             ┌───────────┐
-        q_0: ┤ H ├┤ RX(pi/2) ├──■───────────────────────────────────────■──┤ RX(-pi/2) ├
-             ├───┤└──────────┘┌─┴─┐┌─────────────────────────────────┐┌─┴─┐└───────────┘
-        q_1: ┤ H ├────────────┤ X ├┤ U1(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├─────────────
-             └───┘            └───┘└─────────────────────────────────┘└───┘
+        >>> print(prep.decompose())
+             ┌───┐┌──────────┐                                            ┌───────────┐
+        q_0: ┤ H ├┤ RX(pi/2) ├──■──────────────────────────────────────■──┤ RX(-pi/2) ├
+             ├───┤└──────────┘┌─┴─┐┌────────────────────────────────┐┌─┴─┐└───────────┘
+        q_1: ┤ H ├────────────┤ X ├┤ P(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├─────────────
+             └───┘            └───┘└────────────────────────────────┘└───┘
 
         >>> from qiskit.circuit.library import EfficientSU2
         >>> prep = PauliFeatureMap(3, reps=3, paulis=['Z', 'YY', 'ZXZ'])
@@ -104,13 +403,18 @@ class PauliFeatureMap(NLocal):
 
     References:
 
-
-
     [1] Havlicek et al. Supervised learning with quantum enhanced feature spaces,
     `Nature 567, 209-212 (2019) <https://www.nature.com/articles/s41586-019-0980-2>`__.
-
     """
 
+    @deprecate_func(
+        since="1.3",
+        additional_msg=(
+            "Use the pauli_feature_map function as a replacement. Note that this will no longer "
+            "return a BlueprintCircuit, but just a plain QuantumCircuit."
+        ),
+        pending=True,
+    )
     def __init__(
         self,
         feature_dimension: Optional[int] = None,
@@ -161,6 +465,7 @@ def __init__(
             name=name,
         )
 
+        self._prefix = parameter_prefix
         self._data_map_func = data_map_func or self_product
         self._paulis = paulis or ["Z", "ZZ"]
         self._alpha = alpha
diff --git a/releasenotes/notes/rust-paulifm-1dc7b1c2dc756614.yaml b/releasenotes/notes/rust-paulifm-1dc7b1c2dc756614.yaml
new file mode 100644
index 000000000000..103e792381ab
--- /dev/null
+++ b/releasenotes/notes/rust-paulifm-1dc7b1c2dc756614.yaml
@@ -0,0 +1,16 @@
+---
+features_circuits:
+  - |
+    Added circuit library functions :func:`.pauli_feature_map`, :func:`.z_feature_map`,
+    :func:`.zz_feature_map` to construct Pauli feature map circuits. These functions
+    are approximately 8x faster than the current circuit library objects,
+    :class:`.PauliFeatureMap`, :class:`.ZFeatureMap`, and :class:`.ZZFeatureMap`,
+    and will replace them in the future. Note, that the new functions return a plain
+    :class:`.QuantumCircuit` instead of a :class:`.BlueprintCircuit`.
+
+    The functions can be used as drop-in replacement::
+
+      from qiskit.circuit.library import pauli_feature_map, PauliFeatureMap
+
+      fm = pauli_feature_map(20, paulis=["z", "xx", "yyy"])
+      also_fm = PauliFeatureMap(20, paulis=["z", "xx", "yyy"]).decompose()
diff --git a/test/python/circuit/library/test_pauli_feature_map.py b/test/python/circuit/library/test_pauli_feature_map.py
index 0e15af654edd..5d61944d4032 100644
--- a/test/python/circuit/library/test_pauli_feature_map.py
+++ b/test/python/circuit/library/test_pauli_feature_map.py
@@ -19,7 +19,16 @@
 from ddt import ddt, data, unpack
 
 from qiskit.circuit import QuantumCircuit, Parameter, ParameterVector
-from qiskit.circuit.library import PauliFeatureMap, ZFeatureMap, ZZFeatureMap, HGate
+from qiskit.circuit.library import (
+    PauliFeatureMap,
+    ZFeatureMap,
+    ZZFeatureMap,
+    HGate,
+    pauli_feature_map,
+    z_feature_map,
+    zz_feature_map,
+)
+from qiskit.exceptions import QiskitError
 from qiskit.quantum_info import Operator
 from test import QiskitTestCase  # pylint: disable=wrong-import-order
 
@@ -295,5 +304,289 @@ def test_entanglement_not_specified(self):
             feat_map.count_ops()
 
 
+@ddt
+class TestPauliFeatureMap(QiskitTestCase):
+    """Test the Pauli feature map."""
+
+    @data((2, 3, ["X", "YY"]), (5, 2, ["ZZZXZ", "XZ"]))
+    @unpack
+    def test_num_parameters(self, num_qubits, reps, pauli_strings):
+        """Test the number of parameters equals the number of qubits, independent of reps."""
+        encoding = pauli_feature_map(num_qubits, paulis=pauli_strings, reps=reps)
+        self.assertEqual(encoding.num_parameters, num_qubits)
+
+    def test_pauli_zz_with_barriers(self):
+        """Test the generation of Pauli blocks."""
+        encoding = QuantumCircuit(3)
+        encoding.compose(pauli_feature_map(3, paulis=["zz"], insert_barriers=True), inplace=True)
+
+        params = encoding.parameters
+
+        def zz(circuit, i, j):
+            circuit.cx(i, j)
+            circuit.p(2 * (np.pi - params[i]) * (np.pi - params[j]), j)
+            circuit.cx(i, j)
+
+        ref = QuantumCircuit(3)
+        for i in range(2):
+            ref.h(range(3))
+            ref.barrier()
+            zz(ref, 0, 1)
+            zz(ref, 0, 2)
+            zz(ref, 1, 2)
+            if i == 0:
+                ref.barrier()
+
+        self.assertEqual(ref, encoding)
+
+    def test_pauli_xyz(self):
+        """Test the generation of Pauli blocks."""
+        encoding = QuantumCircuit(3)
+        encoding.compose(pauli_feature_map(3, paulis=["xyz"], reps=1), inplace=True)
+        # encoding = PauliFeatureMap(3, paulis=["XYZ"], reps=1).decompose()
+
+        params = encoding.parameters
+
+        # q_0: ─────────────■────────────────────────■──────────────
+        #      ┌─────────┐┌─┴─┐                    ┌─┴─┐┌──────────┐
+        # q_1: ┤ Rx(π/2) ├┤ X ├──■──────────────■──┤ X ├┤ Rx(-π/2) ├
+        #      └──┬───┬──┘└───┘┌─┴─┐┌────────┐┌─┴─┐├───┤└──────────┘
+        # q_2: ───┤ H ├────────┤ X ├┤ P(2.8) ├┤ X ├┤ H ├────────────
+        #         └───┘        └───┘└────────┘└───┘└───┘
+        # X on the most-significant, bottom qubit, Z on the top
+        ref = QuantumCircuit(3)
+        ref.h(range(3))
+        ref.h(2)
+        ref.rx(np.pi / 2, 1)
+        ref.cx(0, 1)
+        ref.cx(1, 2)
+        ref.p(2 * np.prod([np.pi - p for p in params]), 2)
+        ref.cx(1, 2)
+        ref.cx(0, 1)
+        ref.rx(-np.pi / 2, 1)
+        ref.h(2)
+
+        self.assertEqual(ref, encoding)
+
+    def test_first_order_circuit(self):
+        """Test a first order expansion circuit."""
+        times = [0.2, 1, np.pi, -1.2]
+        encoding = z_feature_map(4, reps=3).assign_parameters(times)
+
+        #      ┌───┐ ┌────────┐┌───┐ ┌────────┐┌───┐ ┌────────┐
+        # q_0: ┤ H ├─┤ P(0.4) ├┤ H ├─┤ P(0.4) ├┤ H ├─┤ P(0.4) ├
+        #      ├───┤ └┬──────┬┘├───┤ └┬──────┬┘├───┤ └┬──────┬┘
+        # q_1: ┤ H ├──┤ P(2) ├─┤ H ├──┤ P(2) ├─┤ H ├──┤ P(2) ├─
+        #      ├───┤ ┌┴──────┤ ├───┤ ┌┴──────┤ ├───┤ ┌┴──────┤
+        # q_2: ┤ H ├─┤ P(2π) ├─┤ H ├─┤ P(2π) ├─┤ H ├─┤ P(2π) ├─
+        #      ├───┤┌┴───────┴┐├───┤┌┴───────┴┐├───┤┌┴───────┴┐
+        # q_3: ┤ H ├┤ P(-2.4) ├┤ H ├┤ P(-2.4) ├┤ H ├┤ P(-2.4) ├
+        #      └───┘└─────────┘└───┘└─────────┘└───┘└─────────┘
+        ref = QuantumCircuit(4)
+        for _ in range(3):
+            ref.h([0, 1, 2, 3])
+            for i in range(4):
+                ref.p(2 * times[i], i)
+
+        self.assertTrue(Operator(encoding).equiv(ref))
+
+    def test_second_order_circuit(self):
+        """Test a second order expansion circuit."""
+        times = [0.2, 1, np.pi]
+        encoding = zz_feature_map(3, reps=2).assign_parameters(times)
+
+        def zz_evolution(circuit, qubit1, qubit2):
+            time = (np.pi - times[qubit1]) * (np.pi - times[qubit2])
+            circuit.cx(qubit1, qubit2)
+            circuit.p(2 * time, qubit2)
+            circuit.cx(qubit1, qubit2)
+
+        #      ┌───┐┌────────┐                                         ┌───┐┌────────┐»
+        # q_0: ┤ H ├┤ P(0.4) ├──■─────────────────■────■────────────■──┤ H ├┤ P(0.4) ├»
+        #      ├───┤└┬──────┬┘┌─┴─┐┌───────────┐┌─┴─┐  │            │  └───┘└────────┘»
+        # q_1: ┤ H ├─┤ P(2) ├─┤ X ├┤ P(12.599) ├┤ X ├──┼────────────┼────■────────────»
+        #      ├───┤┌┴──────┤ └───┘└───────────┘└───┘┌─┴─┐┌──────┐┌─┴─┐┌─┴─┐ ┌──────┐ »
+        # q_2: ┤ H ├┤ P(2π) ├────────────────────────┤ X ├┤ P(0) ├┤ X ├┤ X ├─┤ P(0) ├─»
+        #      └───┘└───────┘                        └───┘└──────┘└───┘└───┘ └──────┘ »
+        # «                                                                              »
+        # «q_0: ─────────────────────■─────────────────■────■────────────■───────────────»
+        # «          ┌───┐ ┌──────┐┌─┴─┐┌───────────┐┌─┴─┐  │            │               »
+        # «q_1: ──■──┤ H ├─┤ P(2) ├┤ X ├┤ P(12.599) ├┤ X ├──┼────────────┼────■──────────»
+        # «     ┌─┴─┐├───┤┌┴──────┤└───┘└───────────┘└───┘┌─┴─┐┌──────┐┌─┴─┐┌─┴─┐┌──────┐»
+        # «q_2: ┤ X ├┤ H ├┤ P(2π) ├───────────────────────┤ X ├┤ P(0) ├┤ X ├┤ X ├┤ P(0) ├»
+        # «     └───┘└───┘└───────┘                       └───┘└──────┘└───┘└───┘└──────┘»
+        # «
+        # «q_0: ─────
+        # «
+        # «q_1: ──■──
+        # «     ┌─┴─┐
+        # «q_2: ┤ X ├
+        # «     └───┘
+        ref = QuantumCircuit(3)
+        for _ in range(2):
+            ref.h([0, 1, 2])
+            for i in range(3):
+                ref.p(2 * times[i], i)
+            zz_evolution(ref, 0, 1)
+            zz_evolution(ref, 0, 2)
+            zz_evolution(ref, 1, 2)
+
+        self.assertTrue(Operator(encoding).equiv(ref))
+
+    @combine(entanglement=["linear", "reverse_linear", "pairwise"])
+    def test_zz_entanglement(self, entanglement):
+        """Test the ZZ feature map works with pairwise, linear and reverse_linear entanglement."""
+        num_qubits = 5
+        encoding = zz_feature_map(num_qubits, entanglement=entanglement, reps=1)
+        ops = encoding.count_ops()
+        expected_ops = {"h": num_qubits, "p": 2 * num_qubits - 1, "cx": 2 * (num_qubits - 1)}
+        self.assertEqual(ops, expected_ops)
+
+    def test_pauli_alpha(self):
+        """Test  Pauli rotation factor (getter, setter)."""
+        alpha = 1.234
+
+        # this is needed as the outcoming Rust circuit has no qreg
+        encoding = QuantumCircuit(1)
+        encoding.compose(pauli_feature_map(1, alpha=alpha, paulis=["z"], reps=1), inplace=True)
+
+        ref = QuantumCircuit(1)
+        ref.h(0)
+        ref.p(alpha * encoding.parameters[0], 0)
+
+        self.assertEqual(ref, encoding)
+
+    def test_zzfeaturemap_raises_if_too_small(self):
+        """Test the ``ZZFeatureMap`` raises an error if the number of qubits is smaller than 2."""
+        with self.assertRaises(QiskitError):
+            _ = zz_feature_map(1)
+
+    def test_dict_entanglement(self):
+        """Test passing the entanglement as dictionary."""
+        entanglement = {1: [(0,), (2,)], 2: [(1, 2)], 3: [(0, 1, 2)]}
+        circuit = QuantumCircuit(3)
+        circuit.compose(
+            pauli_feature_map(3, reps=1, paulis=["z", "xx", "yyy"], entanglement=entanglement),
+            inplace=True,
+        )
+        x = circuit.parameters
+
+        ref = QuantumCircuit(3)
+        ref.h(ref.qubits)
+
+        ref.p(2 * x[0], 0)
+        ref.p(2 * x[2], 2)
+
+        ref.h([1, 2])
+        ref.cx(1, 2)
+        ref.p(2 * np.prod([np.pi - xi for xi in [x[1], x[2]]]), 2)
+        ref.cx(1, 2)
+        ref.h([1, 2])
+
+        ref.rx(np.pi / 2, range(3))
+        ref.cx(0, 1)
+        ref.cx(1, 2)
+        ref.p(2 * np.prod([np.pi - xi for xi in x]), 2)
+        ref.cx(1, 2)
+        ref.cx(0, 1)
+        ref.rx(-np.pi / 2, range(3))
+
+        self.assertEqual(ref, circuit)
+
+    def test_invalid_entanglement(self):
+        """Test if a ValueError is raised when an invalid entanglement is passed"""
+        n_qubits = 3
+        entanglement = {
+            1: [(0, 1), (2,)],
+            2: [(0, 1), (1, 2)],
+            3: [(0, 1, 2)],
+        }
+
+        with self.assertRaises(QiskitError):
+            _ = pauli_feature_map(
+                n_qubits, reps=2, paulis=["Z", "ZZ", "ZZZ"], entanglement=entanglement
+            )
+
+    def test_entanglement_not_specified(self):
+        """Test if an error is raised when entanglement is not explicitly specified for
+        all n-qubit pauli blocks"""
+        n_qubits = 3
+        entanglement = {
+            1: [(0, 1), (2,)],
+            3: [(0, 1, 2)],
+        }
+        with self.assertRaises(QiskitError):
+            _ = pauli_feature_map(
+                n_qubits, reps=2, paulis=["Z", "ZZ", "ZZZ"], entanglement=entanglement
+            )
+
+    def test_parameter_prefix(self):
+        """Test the Parameter prefix"""
+        encoding_pauli = pauli_feature_map(
+            feature_dimension=2, reps=2, paulis=["ZY"], parameter_prefix="p"
+        )
+        encoding_z = z_feature_map(feature_dimension=2, reps=2, parameter_prefix="q")
+        encoding_zz = zz_feature_map(feature_dimension=2, reps=2, parameter_prefix="r")
+        x = ParameterVector("x", 2)
+        y = Parameter("y")
+
+        self.assertEqual(
+            str(encoding_pauli.parameters),
+            "ParameterView([ParameterVectorElement(p[0]), ParameterVectorElement(p[1])])",
+        )
+        self.assertEqual(
+            str(encoding_z.parameters),
+            "ParameterView([ParameterVectorElement(q[0]), ParameterVectorElement(q[1])])",
+        )
+        self.assertEqual(
+            str(encoding_zz.parameters),
+            "ParameterView([ParameterVectorElement(r[0]), ParameterVectorElement(r[1])])",
+        )
+
+        encoding_pauli_param_x = encoding_pauli.assign_parameters(x)
+        encoding_z_param_x = encoding_z.assign_parameters(x)
+        encoding_zz_param_x = encoding_zz.assign_parameters(x)
+
+        self.assertEqual(
+            str(encoding_pauli_param_x.parameters),
+            "ParameterView([ParameterVectorElement(x[0]), ParameterVectorElement(x[1])])",
+        )
+        self.assertEqual(
+            str(encoding_z_param_x.parameters),
+            "ParameterView([ParameterVectorElement(x[0]), ParameterVectorElement(x[1])])",
+        )
+        self.assertEqual(
+            str(encoding_zz_param_x.parameters),
+            "ParameterView([ParameterVectorElement(x[0]), ParameterVectorElement(x[1])])",
+        )
+
+        encoding_pauli_param_y = encoding_pauli.assign_parameters([1, y])
+        encoding_z_param_y = encoding_z.assign_parameters([1, y])
+        encoding_zz_param_y = encoding_zz.assign_parameters([1, y])
+
+        self.assertEqual(str(encoding_pauli_param_y.parameters), "ParameterView([Parameter(y)])")
+        self.assertEqual(str(encoding_z_param_y.parameters), "ParameterView([Parameter(y)])")
+        self.assertEqual(str(encoding_zz_param_y.parameters), "ParameterView([Parameter(y)])")
+
+    def test_custom_data_mapping(self):
+        """Test passing a custom data mapping function."""
+
+        def my_mapping(x):
+            return 42 if len(x) == 1 else np.sum(x)
+
+        encoding = QuantumCircuit(2)
+        encoding.compose(zz_feature_map(2, reps=1, data_map_func=my_mapping), inplace=True)
+
+        params = encoding.parameters
+        ref = QuantumCircuit(2)
+        ref.h(range(2))
+        ref.p(2 * 42, range(2))
+        ref.cx(0, 1)
+        ref.p(2 * (params[0] + params[1]), 1)
+        ref.cx(0, 1)
+
+        self.assertEqual(ref, encoding)
+
+
 if __name__ == "__main__":
     unittest.main()

From b083de6cdefac86c47171f4b8e4ef2913979bebc Mon Sep 17 00:00:00 2001
From: Matthew Treinish <mtreinish@kortar.org>
Date: Thu, 12 Sep 2024 11:00:04 -0400
Subject: [PATCH 78/85] Revert version number back to 1.3.0 after beta
 pre-release (#13142)

Now that the 1.3.0b1 pre-release has been published this commit reverts
the version number back to 1.3.0 to differentiate development builds
from the published pre-release.
---
 Cargo.lock         | 269 ++++++++++++++++++++++++---------------------
 docs/conf.py       |   2 +-
 qiskit/VERSION.txt |   2 +-
 3 files changed, 146 insertions(+), 127 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d00620630e79..d73b21266dab 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -82,9 +82,9 @@ dependencies = [
 
 [[package]]
 name = "autocfg"
-version = "1.2.0"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1fdabc7756949593fe60f30ec81974b613357de856987752631dea1e3394c80"
+checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
 
 [[package]]
 name = "bitflags"
@@ -94,9 +94,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.5.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
 
 [[package]]
 name = "block-buffer"
@@ -129,13 +129,13 @@ dependencies = [
 
 [[package]]
 name = "bytemuck_derive"
-version = "1.6.0"
+version = "1.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4da9a32f3fed317401fa3c862968128267c3106685286e15d5aaa3d7389c2f60"
+checksum = "0cc8b54b395f2fcfbb3d90c47b01c7f444d94d05bdeb775811dec868ac3bbc26"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.76",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -184,24 +184,24 @@ checksum = "7704b5fdd17b18ae31c4c1da5a2e0305a2bf17b5249300a9ee9ed7b72114c636"
 
 [[package]]
 name = "cov-mark"
-version = "2.0.0-pre.1"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d48d8f76bd9331f19fe2aaf3821a9f9fb32c3963e1e3d6ce82a8c09cef7444a"
+checksum = "0570650661aa447e7335f1d5e4f499d8e58796e617bedc9267d971e51c8b49d4"
 
 [[package]]
 name = "cpufeatures"
-version = "0.2.12"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504"
+checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "crossbeam-channel"
-version = "0.5.12"
+version = "0.5.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab3db02a9c5b5121e1e42fbdb1aeb65f5e02624cc58c43f2884c6ccac0b82f95"
+checksum = "33480d6946193aa8033910124896ca395333cae7e2d1113d1fef6c3272217df2"
 dependencies = [
  "crossbeam-utils",
 ]
@@ -227,9 +227,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.19"
+version = "0.8.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345"
+checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
 
 [[package]]
 name = "crunchy"
@@ -281,20 +281,20 @@ dependencies = [
 
 [[package]]
 name = "either"
-version = "1.11.0"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a47c1c47d2f5964e29c61246e81db715514cd532db6b5116a25ea3c03d6780a2"
+checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
 
 [[package]]
 name = "enum-as-inner"
-version = "0.6.0"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ffccbb6966c05b32ef8fbac435df276c4ae4d3dc55a8cd0eb9745e6c12f546a"
+checksum = "a1e6a265c649f3f5979b601d26f1d05ada116434c87741c9493cb56218f76cbc"
 dependencies = [
- "heck",
+ "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.76",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -323,7 +323,7 @@ checksum = "3bf679796c0322556351f287a51b49e48f7c4986e727b5dd78c972d30e2e16cc"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.76",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -334,7 +334,7 @@ checksum = "5322a90066ddae2b705096eb9e10c465c0498ae93bf9bdd6437415327c88e3bb"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.76",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -533,9 +533,9 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.14"
+version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
+checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
 dependencies = [
  "cfg-if",
  "libc",
@@ -580,11 +580,17 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
 
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
 [[package]]
 name = "hermit-abi"
-version = "0.3.9"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
+checksum = "fbf6a919d6cf397374f7dfeeea91d974c7c0a7221d0d0f4f20d859d329e53fcc"
 
 [[package]]
 name = "indexmap"
@@ -605,9 +611,9 @@ checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5"
 
 [[package]]
 name = "is-terminal"
-version = "0.4.12"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f23ff5ef2b80d608d61efee834934d862cd92461afc0560dedf493e4c033738b"
+checksum = "261f68e344040fbd0edea105bef17c66edf46f984ddb1115b775ce31be948f4b"
 dependencies = [
  "hermit-abi",
  "libc",
@@ -655,9 +661,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "libc"
-version = "0.2.154"
+version = "0.2.158"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae743338b92ff9146ce83992f766a31066a91a8c84a45e0e9f21e7cf6de6d346"
+checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
 
 [[package]]
 name = "libm"
@@ -677,9 +683,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.21"
+version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
 
 [[package]]
 name = "matrixcompare"
@@ -699,9 +705,9 @@ checksum = "b0bdabb30db18805d5290b3da7ceaccbddba795620b86c02145d688e04900a73"
 
 [[package]]
 name = "matrixmultiply"
-version = "0.3.8"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7574c1cf36da4798ab73da5b215bbf444f50718207754cb522201d78d1cd0ff2"
+checksum = "9380b911e3e96d10c1f415da0876389aaf1b56759054eeb0de7df940c456ba1a"
 dependencies = [
  "autocfg",
  "rawpointer",
@@ -709,9 +715,9 @@ dependencies = [
 
 [[package]]
 name = "memchr"
-version = "2.7.2"
+version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
 [[package]]
 name = "memoffset"
@@ -969,9 +975,9 @@ dependencies = [
 
 [[package]]
 name = "parking_lot"
-version = "0.12.2"
+version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e4af0ca4f6caed20e900d564c242b8e5d4903fdacf31d3daf527b66fe6f42fb"
+checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27"
 dependencies = [
  "lock_api",
  "parking_lot_core",
@@ -987,20 +993,20 @@ dependencies = [
  "libc",
  "redox_syscall",
  "smallvec",
- "windows-targets 0.52.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
 name = "paste"
-version = "1.0.14"
+version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de3145af08024dea9fa9914f381a17b8fc6034dfb00f3a84013f7ff43f29ed4c"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
 [[package]]
 name = "pest"
-version = "2.7.10"
+version = "2.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "560131c633294438da9f7c4b08189194b20946c8274c6b9e38881a7874dc8ee8"
+checksum = "9c73c26c01b8c87956cea613c907c9d6ecffd8d18a2a5908e5de0adfaa185cea"
 dependencies = [
  "memchr",
  "thiserror",
@@ -1009,9 +1015,9 @@ dependencies = [
 
 [[package]]
 name = "pest_derive"
-version = "2.7.10"
+version = "2.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26293c9193fbca7b1a3bf9b79dc1e388e927e6cacaa78b4a3ab705a1d3d41459"
+checksum = "664d22978e2815783adbdd2c588b455b1bd625299ce36b2a99881ac9627e6d8d"
 dependencies = [
  "pest",
  "pest_generator",
@@ -1019,22 +1025,22 @@ dependencies = [
 
 [[package]]
 name = "pest_generator"
-version = "2.7.10"
+version = "2.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ec22af7d3fb470a85dd2ca96b7c577a1eb4ef6f1683a9fe9a8c16e136c04687"
+checksum = "a2d5487022d5d33f4c30d91c22afa240ce2a644e87fe08caad974d4eab6badbe"
 dependencies = [
  "pest",
  "pest_meta",
  "proc-macro2",
  "quote",
- "syn 2.0.76",
+ "syn 2.0.77",
 ]
 
 [[package]]
 name = "pest_meta"
-version = "2.7.10"
+version = "2.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7a240022f37c361ec1878d646fc5b7d7c4d28d5946e1a80ad5a7a4f4ca0bdcd"
+checksum = "0091754bbd0ea592c4deb3a122ce8ecbb0753b738aa82bc055fcc2eccc8d8174"
 dependencies = [
  "once_cell",
  "pest",
@@ -1053,21 +1059,24 @@ dependencies = [
 
 [[package]]
 name = "portable-atomic"
-version = "1.6.0"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7170ef9988bc169ba16dd36a7fa041e5c4cbeb6a35b76d4c03daded371eae7c0"
+checksum = "da544ee218f0d287a911e9c99a39a8c9bc8fcad3cb8db5959940044ecfc67265"
 
 [[package]]
 name = "ppv-lite86"
-version = "0.2.17"
+version = "0.2.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
+dependencies = [
+ "zerocopy",
+]
 
 [[package]]
 name = "priority-queue"
-version = "2.0.3"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70c501afe3a2e25c9bd219aa56ec1e04cdb3fcdd763055be268778c13fa82c1f"
+checksum = "560bcab673ff7f6ca9e270c17bf3affd8a05e3bd9207f123b0d45076fd8197e8"
 dependencies = [
  "autocfg",
  "equivalent",
@@ -1128,7 +1137,7 @@ checksum = "d315b3197b780e4873bc0e11251cb56a33f65a6032a3d39b8d1405c255513766"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.76",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -1196,7 +1205,7 @@ dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
  "quote",
- "syn 2.0.76",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -1205,11 +1214,11 @@ version = "0.21.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08260721f32db5e1a5beae69a55553f56b99bd0e1c3e6e0a5e8851a9d0f5a85c"
 dependencies = [
- "heck",
+ "heck 0.4.1",
  "proc-macro2",
  "pyo3-build-config",
  "quote",
- "syn 2.0.76",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -1296,9 +1305,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.36"
+version = "1.0.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
 dependencies = [
  "proc-macro2",
 ]
@@ -1426,11 +1435,11 @@ checksum = "03251193000f4bd3b042892be858ee50e8b3719f2b08e5833ac4353724632430"
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.1"
+version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "469052894dcb553421e483e4209ee581a45100d31b4018de03e5a7ad86374a7e"
+checksum = "0884ad60e090bf1345b93da0a5de8923c93884cd03f40dfcfddd3b4bee661853"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
 ]
 
 [[package]]
@@ -1483,9 +1492,9 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
 [[package]]
 name = "rustversion"
-version = "1.0.15"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80af6f9131f277a45a3fba6ce8e2258037bb0477a67e610d3c1fe046ab31de47"
+checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6"
 
 [[package]]
 name = "rustworkx-core"
@@ -1530,22 +1539,22 @@ checksum = "a3f0bf26fd526d2a95683cd0f87bf103b8539e2ca1ef48ce002d67aad59aa0b4"
 
 [[package]]
 name = "serde"
-version = "1.0.200"
+version = "1.0.210"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddc6f9cc94d67c0e21aaf7eda3a010fd3af78ebf6e096aa6e2e13c79749cce4f"
+checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.200"
+version = "1.0.210"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "856f046b9400cee3c8c94ed572ecdb752444c24528c035cd35882aad6f492bcb"
+checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.76",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -1567,9 +1576,9 @@ checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 
 [[package]]
 name = "smol_str"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6845563ada680337a52d43bb0b29f396f2d911616f6573012645b9e3d048a49"
+checksum = "dd538fb6910ac1099850255cf94a94df6551fbdd602454387d0adb2d1ca6dead"
 dependencies = [
  "serde",
 ]
@@ -1587,9 +1596,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.76"
+version = "2.0.77"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525"
+checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1602,7 +1611,7 @@ version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec7dddc5f0fee506baf8b9fdb989e242f17e4b11c61dfbb0635b705217199eea"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "byteorder",
  "enum-as-inner",
  "libc",
@@ -1612,9 +1621,9 @@ dependencies = [
 
 [[package]]
 name = "target-lexicon"
-version = "0.12.14"
+version = "0.12.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1fc403891a21bcfb7c37834ba66a547a8f402146eba7265b5a6d88059c9ff2f"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
 [[package]]
 name = "text-size"
@@ -1639,7 +1648,7 @@ checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.76",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -1662,27 +1671,27 @@ checksum = "ed646292ffc8188ef8ea4d1e0e0150fb15a5c2e12ad9b8fc191ae7a8a7f3c4b9"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.12"
+version = "1.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
 
 [[package]]
 name = "unicode-properties"
-version = "0.1.1"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4259d9d4425d9f0661581b804cb85fe66a4c631cadd8f490d1c13a35d5d9291"
+checksum = "52ea75f83c0137a9b98608359a5f1af8144876eb67bcb1ce837368e906a9f524"
 
 [[package]]
 name = "unicode-width"
-version = "0.1.12"
+version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68f5e5f3158ecfd4b8ff6fe086db7c8467a2dfdac97fe420f2b7c4aa97af66d6"
+checksum = "0336d538f7abc86d282a4189614dfaa90810dfc2c6f6427eaf88e16311dd225d"
 
 [[package]]
 name = "unicode-xid"
-version = "0.2.4"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
+checksum = "229730647fbc343e3a80e463c1db7f78f3855d3f3739bee0dda773c9a037c90a"
 
 [[package]]
 name = "unindent"
@@ -1692,9 +1701,9 @@ checksum = "c7de7d73e1754487cb58364ee906a499937a0dfabd86bcb980fa99ec8c8fa2ce"
 
 [[package]]
 name = "version_check"
-version = "0.9.4"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
 name = "walkdir"
@@ -1730,11 +1739,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
 name = "winapi-util"
-version = "0.1.8"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"
+checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -1773,7 +1782,16 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows-targets 0.52.5",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -1793,18 +1811,18 @@ dependencies = [
 
 [[package]]
 name = "windows-targets"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "windows_aarch64_gnullvm 0.52.5",
- "windows_aarch64_msvc 0.52.5",
- "windows_i686_gnu 0.52.5",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
  "windows_i686_gnullvm",
- "windows_i686_msvc 0.52.5",
- "windows_x86_64_gnu 0.52.5",
- "windows_x86_64_gnullvm 0.52.5",
- "windows_x86_64_msvc 0.52.5",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
 ]
 
 [[package]]
@@ -1815,9 +1833,9 @@ checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
 
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
 [[package]]
 name = "windows_aarch64_msvc"
@@ -1827,9 +1845,9 @@ checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
 [[package]]
 name = "windows_i686_gnu"
@@ -1839,15 +1857,15 @@ checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
 [[package]]
 name = "windows_i686_gnullvm"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
 [[package]]
 name = "windows_i686_msvc"
@@ -1857,9 +1875,9 @@ checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
 [[package]]
 name = "windows_x86_64_gnu"
@@ -1869,9 +1887,9 @@ checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
@@ -1881,9 +1899,9 @@ checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
 [[package]]
 name = "windows_x86_64_msvc"
@@ -1893,9 +1911,9 @@ checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
 name = "xshell"
@@ -1920,20 +1938,21 @@ checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"
 
 [[package]]
 name = "zerocopy"
-version = "0.7.32"
+version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
 dependencies = [
+ "byteorder",
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.7.32"
+version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.76",
+ "syn 2.0.77",
 ]
diff --git a/docs/conf.py b/docs/conf.py
index 493dd58de83c..a84a1ff691bf 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -32,7 +32,7 @@
 # The short X.Y version
 version = "1.3"
 # The full version, including alpha/beta/rc tags
-release = "1.3.0b1"
+release = "1.3.0"
 
 language = "en"
 
diff --git a/qiskit/VERSION.txt b/qiskit/VERSION.txt
index 94bfba8ed4ed..f0bb29e76388 100644
--- a/qiskit/VERSION.txt
+++ b/qiskit/VERSION.txt
@@ -1 +1 @@
-1.3.0b1
+1.3.0

From 4c88a71237ccfc528e8a0b3704a53a3375cab8be Mon Sep 17 00:00:00 2001
From: Matthew Treinish <mtreinish@kortar.org>
Date: Thu, 12 Sep 2024 15:28:26 -0400
Subject: [PATCH 79/85] Oxidize dag_to_circuit() (#13126)

* Oxidize dag_to_circuit()

This commit migrates the dag_to_circuit() converter function
implementation to rust. The core of this is having a DAGCircuit to
CircuitData converter function in rust. To do this efficiently we just
copy the BitDatas and Interners to the new circuit data object being
created and then just iterate over all the packed instructions in the
circuit. To facilitate this a new constructor for CircuitData is added
that takes an iterator of PackedInstructions and the BitDatas and
Interners and builds a new circuit data from that.

* Apply suggestions from code review

Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>

* Update crates/circuit/src/converters.rs

Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>

* Update crates/circuit/src/converters.rs

Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>

* Use immutable access methods instead of relying on public fields

* Add docstring to the new CircuitData constructor method

---------

Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>
---
 crates/circuit/src/circuit_data.rs  | 57 +++++++++++++++++++++++++++++
 crates/circuit/src/converters.rs    | 51 +++++++++++++++++++++++++-
 crates/circuit/src/dag_circuit.rs   |  4 +-
 qiskit/converters/dag_to_circuit.py |  6 ++-
 4 files changed, 113 insertions(+), 5 deletions(-)

diff --git a/crates/circuit/src/circuit_data.rs b/crates/circuit/src/circuit_data.rs
index da49f9edc605..b367a6877c11 100644
--- a/crates/circuit/src/circuit_data.rs
+++ b/crates/circuit/src/circuit_data.rs
@@ -166,6 +166,63 @@ impl CircuitData {
         Ok(res)
     }
 
+    /// A constructor for CircuitData from an iterator of PackedInstruction objects
+    ///
+    /// This is tpically useful when iterating over a CircuitData or DAGCircuit
+    /// to construct a new CircuitData from the iterator of PackedInstructions. As
+    /// such it requires that you have `BitData` and `Interner` objects to run. If
+    /// you just wish to build a circuit data from an iterator of instructions
+    /// the `from_packed_operations` or `from_standard_gates` constructor methods
+    /// are a better choice
+    ///
+    /// # Args
+    ///
+    /// * py: A GIL handle this is needed to instantiate Qubits in Python space
+    /// * qubits: The BitData to use for the new circuit's qubits
+    /// * clbits: The BitData to use for the new circuit's clbits
+    /// * qargs_interner: The interner for Qubit objects in the circuit. This must
+    ///     contain all the Interned<Qubit> indices stored in the
+    ///     PackedInstructions from `instructions`
+    /// * cargs_interner: The interner for Clbit objects in the circuit. This must
+    ///     contain all the Interned<Clbit> indices stored in the
+    ///     PackedInstructions from `instructions`
+    /// * Instructions: An iterator with items of type: `PyResult<PackedInstruction>`
+    ///     that contais the instructions to insert in iterator order to the new
+    ///     CircuitData. This returns a `PyResult` to facilitate the case where
+    ///     you need to make a python copy (such as with `PackedOperation::py_deepcopy()`)
+    ///     of the operation while iterating for constructing the new `CircuitData`. An
+    ///     example of this use case is in `qiskit_circuit::converters::dag_to_circuit`.
+    /// * global_phase: The global phase value to use for the new circuit.
+    pub fn from_packed_instructions<I>(
+        py: Python,
+        qubits: BitData<Qubit>,
+        clbits: BitData<Clbit>,
+        qargs_interner: Interner<[Qubit]>,
+        cargs_interner: Interner<[Clbit]>,
+        instructions: I,
+        global_phase: Param,
+    ) -> PyResult<Self>
+    where
+        I: IntoIterator<Item = PyResult<PackedInstruction>>,
+    {
+        let instruction_iter = instructions.into_iter();
+        let mut res = CircuitData {
+            data: Vec::with_capacity(instruction_iter.size_hint().0),
+            qargs_interner,
+            cargs_interner,
+            qubits,
+            clbits,
+            param_table: ParameterTable::new(),
+            global_phase,
+        };
+
+        for inst in instruction_iter {
+            res.data.push(inst?);
+            res.track_instruction_parameters(py, res.data.len() - 1)?;
+        }
+        Ok(res)
+    }
+
     /// An alternate constructor to build a new `CircuitData` from an iterator
     /// of standard gates. This can be used to build a circuit from a sequence
     /// of standard gates, such as for a `StandardGate` definition or circuit
diff --git a/crates/circuit/src/converters.rs b/crates/circuit/src/converters.rs
index ab9d4bce0475..37ba83ae5173 100644
--- a/crates/circuit/src/converters.rs
+++ b/crates/circuit/src/converters.rs
@@ -10,6 +10,9 @@
 // copyright notice, and modified files need to carry a notice indicating
 // that they have been altered from the originals.
 
+#[cfg(feature = "cache_pygates")]
+use std::cell::OnceCell;
+
 use ::pyo3::prelude::*;
 use hashbrown::HashMap;
 use pyo3::{
@@ -17,7 +20,9 @@ use pyo3::{
     types::{PyDict, PyList},
 };
 
-use crate::{circuit_data::CircuitData, dag_circuit::DAGCircuit};
+use crate::circuit_data::CircuitData;
+use crate::dag_circuit::{DAGCircuit, NodeType};
+use crate::packed_instruction::PackedInstruction;
 
 /// An extractable representation of a QuantumCircuit reserved only for
 /// conversion purposes.
@@ -85,7 +90,51 @@ pub fn circuit_to_dag(
     )
 }
 
+#[pyfunction(signature = (dag, copy_operations = true))]
+pub fn dag_to_circuit(
+    py: Python,
+    dag: &DAGCircuit,
+    copy_operations: bool,
+) -> PyResult<CircuitData> {
+    CircuitData::from_packed_instructions(
+        py,
+        dag.qubits().clone(),
+        dag.clbits().clone(),
+        dag.qargs_interner().clone(),
+        dag.cargs_interner().clone(),
+        dag.topological_op_nodes()?.map(|node_index| {
+            let NodeType::Operation(ref instr) = dag.dag()[node_index] else {
+                unreachable!(
+                    "The received node from topological_op_nodes() is not an Operation node."
+                )
+            };
+            if copy_operations {
+                let op = instr.op.py_deepcopy(py, None)?;
+                Ok(PackedInstruction {
+                    op,
+                    qubits: instr.qubits,
+                    clbits: instr.clbits,
+                    params: Some(Box::new(
+                        instr
+                            .params_view()
+                            .iter()
+                            .map(|param| param.clone_ref(py))
+                            .collect(),
+                    )),
+                    extra_attrs: instr.extra_attrs.clone(),
+                    #[cfg(feature = "cache_pygates")]
+                    py_op: OnceCell::new(),
+                })
+            } else {
+                Ok(instr.clone())
+            }
+        }),
+        dag.get_global_phase(),
+    )
+}
+
 pub fn converters(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(circuit_to_dag, m)?)?;
+    m.add_function(wrap_pyfunction!(dag_to_circuit, m)?)?;
     Ok(())
 }
diff --git a/crates/circuit/src/dag_circuit.rs b/crates/circuit/src/dag_circuit.rs
index d872806c5315..0e944789d307 100644
--- a/crates/circuit/src/dag_circuit.rs
+++ b/crates/circuit/src/dag_circuit.rs
@@ -782,7 +782,7 @@ impl DAGCircuit {
 
     /// Return the global phase of the circuit.
     #[getter]
-    fn get_global_phase(&self) -> Param {
+    pub fn get_global_phase(&self) -> Param {
         self.global_phase.clone()
     }
 
@@ -6375,7 +6375,7 @@ impl DAGCircuit {
                 params: (!new_op.params.is_empty()).then(|| Box::new(new_op.params)),
                 extra_attrs: new_op.extra_attrs,
                 #[cfg(feature = "cache_pygates")]
-                py_op: py_op,
+                py_op,
             };
             let new_index = self.dag.add_node(NodeType::Operation(inst));
             self.dag.add_edge(source, new_index, weight.clone());
diff --git a/qiskit/converters/dag_to_circuit.py b/qiskit/converters/dag_to_circuit.py
index 47adee456380..84ea6ef0fd24 100644
--- a/qiskit/converters/dag_to_circuit.py
+++ b/qiskit/converters/dag_to_circuit.py
@@ -13,6 +13,7 @@
 """Helper function for converting a dag to a circuit."""
 
 from qiskit.circuit import QuantumCircuit
+from qiskit._accelerate.converters import dag_to_circuit as dag_to_circuit_rs
 
 
 def dag_to_circuit(dag, copy_operations=True):
@@ -54,6 +55,8 @@ def dag_to_circuit(dag, copy_operations=True):
     """
 
     name = dag.name or None
+
+    circuit_data = dag_to_circuit_rs(dag, copy_operations)
     circuit = QuantumCircuit(
         dag.qubits,
         dag.clbits,
@@ -69,8 +72,7 @@ def dag_to_circuit(dag, copy_operations=True):
     circuit.metadata = dag.metadata
     circuit.calibrations = dag.calibrations
 
-    for node in dag.topological_op_nodes():
-        circuit._append(node._to_circuit_instruction(deepcopy=copy_operations))
+    circuit._data = circuit_data
 
     circuit.duration = dag.duration
     circuit.unit = dag.unit

From c655acb51bf41d70e6c22cdf176f3cad6334198d Mon Sep 17 00:00:00 2001
From: Kevin Hartman <kevin@hart.mn>
Date: Thu, 12 Sep 2024 16:23:26 -0400
Subject: [PATCH 80/85] Move `Option<Box<_>>` into
 `ExtraInstructionAttributes`. (#13127)

* Move Option<Box<_>> into ExtraInstructionAttributes.

Previously, CircuitInstruction and PackedInstruction held
the ExtraInstructionAttributes struct within an Option<Box<_>>.
By putting the Option<Box<_>> inside ExtraInstructionAttributes,
we can use the struct itself to manage its memory and provide
access to the attributes behind a nicer interface.

The size of ExtraInstructionAttributes should be the same size
as the old Option<Box<ExtraInstructionAttributes>>, so this
should not have memory implications.

* Address review comments.

- Use tuple struct.
- Use 'Attributes' over 'Attrs'.
- Add doc comment for internal 'ExtraAttributes' struct.
- Add doc comments for methods.
- Add setters for unit and duration.

* Fix performance regression from unnecessary dict creation.
---
 crates/accelerate/src/commutation_analysis.rs |   4 +-
 crates/accelerate/src/commutation_checker.rs  |  20 +-
 crates/circuit/src/circuit_data.rs            |  17 +-
 crates/circuit/src/circuit_instruction.rs     | 205 +++++++++++++-----
 crates/circuit/src/dag_circuit.rs             | 111 ++--------
 crates/circuit/src/dag_node.rs                |  43 +---
 crates/circuit/src/operations.rs              |  18 +-
 crates/circuit/src/packed_instruction.rs      |  12 +-
 8 files changed, 209 insertions(+), 221 deletions(-)

diff --git a/crates/accelerate/src/commutation_analysis.rs b/crates/accelerate/src/commutation_analysis.rs
index e8b47658b9f4..a29c648a5f81 100644
--- a/crates/accelerate/src/commutation_analysis.rs
+++ b/crates/accelerate/src/commutation_analysis.rs
@@ -95,12 +95,12 @@ pub(crate) fn analyze_commutations_inner(
                             py,
                             &op1,
                             params1,
-                            packed_inst0.extra_attrs.as_deref(),
+                            &packed_inst0.extra_attrs,
                             qargs1,
                             cargs1,
                             &op2,
                             params2,
-                            packed_inst1.extra_attrs.as_deref(),
+                            &packed_inst1.extra_attrs,
                             qargs2,
                             cargs2,
                             MAX_NUM_QUBITS,
diff --git a/crates/accelerate/src/commutation_checker.rs b/crates/accelerate/src/commutation_checker.rs
index c7fbd03a2afe..b6e61fcf3f6d 100644
--- a/crates/accelerate/src/commutation_checker.rs
+++ b/crates/accelerate/src/commutation_checker.rs
@@ -121,12 +121,12 @@ impl CommutationChecker {
             py,
             &op1.instruction.operation.view(),
             &op1.instruction.params,
-            op1.instruction.extra_attrs.as_deref(),
+            &op1.instruction.extra_attrs,
             &qargs1,
             &cargs1,
             &op2.instruction.operation.view(),
             &op2.instruction.params,
-            op2.instruction.extra_attrs.as_deref(),
+            &op2.instruction.extra_attrs,
             &qargs2,
             &cargs2,
             max_num_qubits,
@@ -162,12 +162,12 @@ impl CommutationChecker {
             py,
             &op1.operation.view(),
             &op1.params,
-            op1.extra_attrs.as_deref(),
+            &op1.extra_attrs,
             &qargs1,
             &cargs1,
             &op2.operation.view(),
             &op2.params,
-            op2.extra_attrs.as_deref(),
+            &op2.extra_attrs,
             &qargs2,
             &cargs2,
             max_num_qubits,
@@ -232,12 +232,12 @@ impl CommutationChecker {
         py: Python,
         op1: &OperationRef,
         params1: &[Param],
-        attrs1: Option<&ExtraInstructionAttributes>,
+        attrs1: &ExtraInstructionAttributes,
         qargs1: &[Qubit],
         cargs1: &[Clbit],
         op2: &OperationRef,
         params2: &[Param],
-        attrs2: Option<&ExtraInstructionAttributes>,
+        attrs2: &ExtraInstructionAttributes,
         qargs2: &[Qubit],
         cargs2: &[Clbit],
         max_num_qubits: u32,
@@ -494,20 +494,20 @@ impl CommutationChecker {
 fn commutation_precheck(
     op1: &OperationRef,
     params1: &[Param],
-    attrs1: Option<&ExtraInstructionAttributes>,
+    attrs1: &ExtraInstructionAttributes,
     qargs1: &[Qubit],
     cargs1: &[Clbit],
     op2: &OperationRef,
     params2: &[Param],
-    attrs2: Option<&ExtraInstructionAttributes>,
+    attrs2: &ExtraInstructionAttributes,
     qargs2: &[Qubit],
     cargs2: &[Clbit],
     max_num_qubits: u32,
 ) -> Option<bool> {
     if op1.control_flow()
         || op2.control_flow()
-        || attrs1.is_some_and(|attr| attr.condition.is_some())
-        || attrs2.is_some_and(|attr| attr.condition.is_some())
+        || attrs1.condition().is_some()
+        || attrs2.condition().is_some()
     {
         return Some(false);
     }
diff --git a/crates/circuit/src/circuit_data.rs b/crates/circuit/src/circuit_data.rs
index b367a6877c11..0308bd8dfb8b 100644
--- a/crates/circuit/src/circuit_data.rs
+++ b/crates/circuit/src/circuit_data.rs
@@ -14,7 +14,9 @@
 use std::cell::OnceCell;
 
 use crate::bit_data::BitData;
-use crate::circuit_instruction::{CircuitInstruction, OperationFromPython};
+use crate::circuit_instruction::{
+    CircuitInstruction, ExtraInstructionAttributes, OperationFromPython,
+};
 use crate::imports::{ANNOTATED_OPERATION, CLBIT, QUANTUM_CIRCUIT, QUBIT};
 use crate::interner::{Interned, Interner};
 use crate::operations::{Operation, OperationRef, Param, StandardGate};
@@ -157,7 +159,7 @@ impl CircuitData {
                 qubits,
                 clbits,
                 params,
-                extra_attrs: None,
+                extra_attrs: ExtraInstructionAttributes::default(),
                 #[cfg(feature = "cache_pygates")]
                 py_op: OnceCell::new(),
             });
@@ -266,7 +268,7 @@ impl CircuitData {
                 qubits,
                 clbits: no_clbit_index,
                 params,
-                extra_attrs: None,
+                extra_attrs: ExtraInstructionAttributes::default(),
                 #[cfg(feature = "cache_pygates")]
                 py_op: OnceCell::new(),
             });
@@ -324,7 +326,7 @@ impl CircuitData {
             qubits,
             clbits: no_clbit_index,
             params,
-            extra_attrs: None,
+            extra_attrs: ExtraInstructionAttributes::default(),
             #[cfg(feature = "cache_pygates")]
             py_op: OnceCell::new(),
         });
@@ -683,12 +685,7 @@ impl CircuitData {
     #[pyo3(signature = (func))]
     pub fn map_nonstandard_ops(&mut self, py: Python<'_>, func: &Bound<PyAny>) -> PyResult<()> {
         for inst in self.data.iter_mut() {
-            if inst.op.try_standard_gate().is_some()
-                && !inst
-                    .extra_attrs
-                    .as_ref()
-                    .is_some_and(|attrs| attrs.condition.is_some())
-            {
+            if inst.op.try_standard_gate().is_some() && inst.extra_attrs.condition().is_none() {
                 continue;
             }
             let py_op = func.call1((inst.unpack_py_op(py)?,))?;
diff --git a/crates/circuit/src/circuit_instruction.rs b/crates/circuit/src/circuit_instruction.rs
index 463f3352aa92..a56aee2c6137 100644
--- a/crates/circuit/src/circuit_instruction.rs
+++ b/crates/circuit/src/circuit_instruction.rs
@@ -30,18 +30,23 @@ use crate::operations::{
 };
 use crate::packed_instruction::PackedOperation;
 
-/// These are extra mutable attributes for a circuit instruction's state. In general we don't
-/// typically deal with this in rust space and the majority of the time they're not used in Python
-/// space either. To save memory these are put in a separate struct and are stored inside a
-/// `Box` on `CircuitInstruction` and `PackedInstruction`.
+/// This is a private struct used to hold the actual attributes, which we store
+/// on the heap using the [Box] within [ExtraInstructionAttributes].
 #[derive(Debug, Clone)]
-pub struct ExtraInstructionAttributes {
-    pub label: Option<String>,
-    pub duration: Option<PyObject>,
-    pub unit: Option<String>,
-    pub condition: Option<PyObject>,
+struct ExtraAttributes {
+    label: Option<String>,
+    duration: Option<PyObject>,
+    unit: Option<String>,
+    condition: Option<PyObject>,
 }
 
+/// Extra mutable attributes for a circuit instruction's state. In general we don't
+/// typically deal with this in rust space and the majority of the time they're not used in Python
+/// space either. To save memory, the attributes are stored inside a `Box` internally, so this
+/// struct is no larger than that.
+#[derive(Default, Debug, Clone)]
+pub struct ExtraInstructionAttributes(Option<Box<ExtraAttributes>>);
+
 impl ExtraInstructionAttributes {
     /// Construct a new set of the extra attributes if any of the elements are not `None`, or return
     /// `None` if there is no need for an object.
@@ -51,25 +56,32 @@ impl ExtraInstructionAttributes {
         duration: Option<Py<PyAny>>,
         unit: Option<String>,
         condition: Option<Py<PyAny>>,
-    ) -> Option<Self> {
-        if label.is_some() || duration.is_some() || unit.is_some() || condition.is_some() {
-            Some(Self {
-                label,
-                duration,
-                unit,
-                condition,
-            })
-        } else {
-            None
-        }
+    ) -> Self {
+        ExtraInstructionAttributes(
+            if label.is_some() || duration.is_some() || unit.is_some() || condition.is_some() {
+                Some(Box::new(ExtraAttributes {
+                    label,
+                    duration,
+                    unit,
+                    condition,
+                }))
+            } else {
+                None
+            },
+        )
     }
 
-    /// Get the Python-space version of the stored `unit`.  This evalutes the Python-space default
-    /// (`"dt"`) value if we're storing a `None`.
+    /// Get the Python-space version of the stored `unit`.
+    /// This evaluates the Python-space default (`"dt"`) value if we're storing a `None`.
     pub fn py_unit(&self, py: Python) -> Py<PyString> {
-        self.unit
+        self.0
             .as_deref()
-            .map(|unit| <&str as IntoPy<Py<PyString>>>::into_py(unit, py))
+            .and_then(|attrs| {
+                attrs
+                    .unit
+                    .as_deref()
+                    .map(|unit| <&str as IntoPy<Py<PyString>>>::into_py(unit, py))
+            })
             .unwrap_or_else(|| Self::default_unit(py).clone().unbind())
     }
 
@@ -77,6 +89,106 @@ impl ExtraInstructionAttributes {
     pub fn default_unit(py: Python) -> &Bound<PyString> {
         intern!(py, "dt")
     }
+
+    /// Get the stored label attribute.
+    pub fn label(&self) -> Option<&str> {
+        self.0.as_deref().and_then(|attrs| attrs.label.as_deref())
+    }
+
+    /// Set the stored label attribute, or clear it if `label` is `None`.
+    pub fn set_label(&mut self, label: Option<String>) {
+        if let Some(attrs) = &mut self.0 {
+            attrs.label = label;
+            self.shrink_if_empty();
+            return;
+        }
+        if label.is_some() {
+            self.0 = Some(Box::new(ExtraAttributes {
+                label,
+                duration: None,
+                unit: None,
+                condition: None,
+            }))
+        }
+    }
+
+    /// Get the stored duration attribute.
+    pub fn duration(&self) -> Option<&PyObject> {
+        self.0.as_deref().and_then(|attrs| attrs.duration.as_ref())
+    }
+
+    /// Set the stored duration attribute, or clear it if `duration` is `None`.
+    pub fn set_duration(&mut self, duration: Option<PyObject>) {
+        if let Some(attrs) = &mut self.0 {
+            attrs.duration = duration;
+            self.shrink_if_empty();
+            return;
+        }
+        if duration.is_some() {
+            self.0 = Some(Box::new(ExtraAttributes {
+                label: None,
+                duration,
+                unit: None,
+                condition: None,
+            }))
+        }
+    }
+
+    /// Get the unit attribute.
+    pub fn unit(&self) -> Option<&str> {
+        self.0.as_deref().and_then(|attrs| attrs.unit.as_deref())
+    }
+
+    /// Set the stored unit attribute, or clear it if `unit` is `None`.
+    pub fn set_unit(&mut self, unit: Option<String>) {
+        if let Some(attrs) = &mut self.0 {
+            attrs.unit = unit;
+            self.shrink_if_empty();
+            return;
+        }
+        if unit.is_some() {
+            self.0 = Some(Box::new(ExtraAttributes {
+                label: None,
+                duration: None,
+                unit,
+                condition: None,
+            }))
+        }
+    }
+
+    /// Get the condition attribute.
+    pub fn condition(&self) -> Option<&PyObject> {
+        self.0.as_deref().and_then(|attrs| attrs.condition.as_ref())
+    }
+
+    /// Set the stored condition attribute, or clear it if `condition` is `None`.
+    pub fn set_condition(&mut self, condition: Option<PyObject>) {
+        if let Some(attrs) = &mut self.0 {
+            attrs.condition = condition;
+            self.shrink_if_empty();
+            return;
+        }
+        if condition.is_some() {
+            self.0 = Some(Box::new(ExtraAttributes {
+                label: None,
+                duration: None,
+                unit: None,
+                condition,
+            }))
+        }
+    }
+
+    fn shrink_if_empty(&mut self) {
+        if let Some(attrs) = &self.0 {
+            if attrs.label.is_none()
+                && attrs.duration.is_none()
+                && attrs.unit.is_none()
+                && attrs.condition.is_none()
+            {
+                self.0 = None;
+            }
+        }
+    }
 }
 
 /// A single instruction in a :class:`.QuantumCircuit`, comprised of the :attr:`operation` and
@@ -122,7 +234,7 @@ pub struct CircuitInstruction {
     #[pyo3(get)]
     pub clbits: Py<PyTuple>,
     pub params: SmallVec<[Param; 3]>,
-    pub extra_attrs: Option<Box<ExtraInstructionAttributes>>,
+    pub extra_attrs: ExtraInstructionAttributes,
     #[cfg(feature = "cache_pygates")]
     pub py_op: OnceCell<Py<PyAny>>,
 }
@@ -146,9 +258,7 @@ impl CircuitInstruction {
     }
 
     pub fn condition(&self) -> Option<&PyObject> {
-        self.extra_attrs
-            .as_ref()
-            .and_then(|args| args.condition.as_ref())
+        self.extra_attrs.condition()
     }
 }
 
@@ -189,14 +299,7 @@ impl CircuitInstruction {
             qubits: as_tuple(py, qubits)?.unbind(),
             clbits: PyTuple::empty_bound(py).unbind(),
             params,
-            extra_attrs: label.map(|label| {
-                Box::new(ExtraInstructionAttributes {
-                    label: Some(label),
-                    duration: None,
-                    unit: None,
-                    condition: None,
-                })
-            }),
+            extra_attrs: ExtraInstructionAttributes::new(label, None, None, None),
             #[cfg(feature = "cache_pygates")]
             py_op: OnceCell::new(),
         })
@@ -227,7 +330,7 @@ impl CircuitInstruction {
 
         let out = match self.operation.view() {
             OperationRef::Standard(standard) => standard
-                .create_py_op(py, Some(&self.params), self.extra_attrs.as_deref())?
+                .create_py_op(py, Some(&self.params), &self.extra_attrs)?
                 .into_any(),
             OperationRef::Gate(gate) => gate.gate.clone_ref(py),
             OperationRef::Instruction(instruction) => instruction.instruction.clone_ref(py),
@@ -261,37 +364,24 @@ impl CircuitInstruction {
 
     #[getter]
     fn label(&self) -> Option<&str> {
-        self.extra_attrs
-            .as_ref()
-            .and_then(|attrs| attrs.label.as_deref())
+        self.extra_attrs.label()
     }
 
     #[getter]
     fn get_condition(&self, py: Python) -> Option<PyObject> {
-        self.extra_attrs
-            .as_ref()
-            .and_then(|attrs| attrs.condition.as_ref().map(|x| x.clone_ref(py)))
+        self.extra_attrs.condition().map(|x| x.clone_ref(py))
     }
 
     #[getter]
     fn duration(&self, py: Python) -> Option<PyObject> {
-        self.extra_attrs
-            .as_ref()
-            .and_then(|attrs| attrs.duration.as_ref().map(|x| x.clone_ref(py)))
+        self.extra_attrs.duration().map(|x| x.clone_ref(py))
     }
 
     #[getter]
     fn unit(&self, py: Python) -> Py<PyString> {
         // Python space uses `"dt"` as the default, whereas we simply don't store the extra
         // attributes at all if they're none.
-        self.extra_attrs
-            .as_ref()
-            .map(|attrs| attrs.py_unit(py))
-            .unwrap_or_else(|| {
-                ExtraInstructionAttributes::default_unit(py)
-                    .clone()
-                    .unbind()
-            })
+        self.extra_attrs.py_unit(py)
     }
 
     /// Is the :class:`.Operation` contained in this instruction a Qiskit standard gate?
@@ -524,7 +614,7 @@ impl CircuitInstruction {
 pub struct OperationFromPython {
     pub operation: PackedOperation,
     pub params: SmallVec<[Param; 3]>,
-    pub extra_attrs: Option<Box<ExtraInstructionAttributes>>,
+    pub extra_attrs: ExtraInstructionAttributes,
 }
 
 impl<'py> FromPyObject<'py> for OperationFromPython {
@@ -558,8 +648,7 @@ impl<'py> FromPyObject<'py> for OperationFromPython {
                 ob.getattr(intern!(py, "duration"))?.extract()?,
                 unit,
                 ob.getattr(intern!(py, "condition"))?.extract()?,
-            )
-            .map(Box::from))
+            ))
         };
 
         'standard: {
@@ -640,7 +729,7 @@ impl<'py> FromPyObject<'py> for OperationFromPython {
             return Ok(OperationFromPython {
                 operation: PackedOperation::from_operation(operation),
                 params,
-                extra_attrs: None,
+                extra_attrs: ExtraInstructionAttributes::default(),
             });
         }
         Err(PyTypeError::new_err(format!("invalid input: {}", ob)))
diff --git a/crates/circuit/src/dag_circuit.rs b/crates/circuit/src/dag_circuit.rs
index 0e944789d307..5b218b2de818 100644
--- a/crates/circuit/src/dag_circuit.rs
+++ b/crates/circuit/src/dag_circuit.rs
@@ -2485,16 +2485,8 @@ def _format(operand):
                         true
                     };
                     let check_conditions = || -> PyResult<bool> {
-                        if let Some(cond1) = inst1
-                            .extra_attrs
-                            .as_ref()
-                            .and_then(|attrs| attrs.condition.as_ref())
-                        {
-                            if let Some(cond2) = inst2
-                                .extra_attrs
-                                .as_ref()
-                                .and_then(|attrs| attrs.condition.as_ref())
-                            {
+                        if let Some(cond1) = inst1.extra_attrs.condition() {
+                            if let Some(cond2) = inst2.extra_attrs.condition() {
                                 legacy_condition_eq
                                     .call1((cond1, cond2, &self_bit_indices, &other_bit_indices))?
                                     .extract::<bool>()
@@ -2502,11 +2494,7 @@ def _format(operand):
                                 Ok(false)
                             }
                         } else {
-                            Ok(inst2
-                                .extra_attrs
-                                .as_ref()
-                                .and_then(|attrs| attrs.condition.as_ref())
-                                .is_none())
+                            Ok(inst2.extra_attrs.condition().is_none())
                         }
                     };
 
@@ -3067,11 +3055,7 @@ def _format(operand):
         let node_map = if propagate_condition && !node.op.control_flow() {
             // Nested until https://github.com/rust-lang/rust/issues/53667 is fixed in a stable
             // release
-            if let Some(condition) = node
-                .extra_attrs
-                .as_ref()
-                .and_then(|attrs| attrs.condition.as_ref())
-            {
+            if let Some(condition) = node.extra_attrs.condition() {
                 let mut in_dag = input_dag.copy_empty_like(py, "alike")?;
                 // The remapping of `condition` below is still using the old code that assumes a 2-tuple.
                 // This is because this remapping code only makes sense in the case of non-control-flow
@@ -3164,12 +3148,7 @@ def _format(operand):
                 for in_node_index in input_dag.topological_op_nodes()? {
                     let in_node = &input_dag.dag[in_node_index];
                     if let NodeType::Operation(inst) = in_node {
-                        if inst
-                            .extra_attrs
-                            .as_ref()
-                            .and_then(|attrs| attrs.condition.as_ref())
-                            .is_some()
-                        {
+                        if inst.extra_attrs.condition().is_some() {
                             return Err(DAGCircuitError::new_err(
                                 "cannot propagate a condition to an element that already has one",
                             ));
@@ -3189,16 +3168,9 @@ def _format(operand):
                         }
                         let mut new_inst = inst.clone();
                         if new_condition.is_truthy()? {
-                            if let Some(ref mut attrs) = new_inst.extra_attrs {
-                                attrs.condition = Some(new_condition.as_any().clone().unbind());
-                            } else {
-                                new_inst.extra_attrs = Some(Box::new(ExtraInstructionAttributes {
-                                    condition: Some(new_condition.as_any().clone().unbind()),
-                                    label: None,
-                                    duration: None,
-                                    unit: None,
-                                }));
-                            }
+                            new_inst
+                                .extra_attrs
+                                .set_condition(Some(new_condition.as_any().clone().unbind()));
                             #[cfg(feature = "cache_pygates")]
                             {
                                 new_inst.py_op.take();
@@ -3283,13 +3255,7 @@ def _format(operand):
                         let raw_target = old_op.instruction.getattr(py, "target")?;
                         let target = raw_target.bind(py);
                         let kwargs = PyDict::new_bound(py);
-                        kwargs.set_item(
-                            "label",
-                            old_inst
-                                .extra_attrs
-                                .as_ref()
-                                .and_then(|attrs| attrs.label.as_ref()),
-                        )?;
+                        kwargs.set_item("label", old_inst.extra_attrs.label())?;
                         let new_op = imports::SWITCH_CASE_OP.get_bound(py).call(
                             (
                                 variable_mapper.map_target(target)?,
@@ -3318,11 +3284,7 @@ def _format(operand):
                         }
                     }
                 }
-                if let Some(condition) = old_inst
-                    .extra_attrs
-                    .as_ref()
-                    .and_then(|attrs| attrs.condition.as_ref())
-                {
+                if let Some(condition) = old_inst.extra_attrs.condition() {
                     if old_inst.op.name() != "switch_case" {
                         let new_condition: Option<PyObject> = variable_mapper
                             .map_condition(condition.bind(py), false)?
@@ -3332,18 +3294,7 @@ def _format(operand):
                         if let NodeType::Operation(ref mut new_inst) =
                             &mut self.dag[*new_node_index]
                         {
-                            match &mut new_inst.extra_attrs {
-                                Some(attrs) => attrs.condition.clone_from(&new_condition),
-                                None => {
-                                    new_inst.extra_attrs =
-                                        Some(Box::new(ExtraInstructionAttributes {
-                                            label: None,
-                                            condition: new_condition.clone(),
-                                            unit: None,
-                                            duration: None,
-                                        }))
-                                }
-                            }
+                            new_inst.extra_attrs.set_condition(new_condition.clone());
                             #[cfg(feature = "cache_pygates")]
                             {
                                 new_inst.py_op.take();
@@ -3440,14 +3391,8 @@ def _format(operand):
                     .map(|x| Wire::Clbit(*x)),
             )
             .collect();
-        let (additional_clbits, additional_vars) = self.additional_wires(
-            py,
-            new_op.operation.view(),
-            new_op
-                .extra_attrs
-                .as_ref()
-                .and_then(|attrs| attrs.condition.as_ref()),
-        )?;
+        let (additional_clbits, additional_vars) =
+            self.additional_wires(py, new_op.operation.view(), new_op.extra_attrs.condition())?;
         new_wires.extend(additional_clbits.iter().map(|x| Wire::Clbit(*x)));
         new_wires.extend(additional_vars.iter().map(|x| Wire::Var(x.clone_ref(py))));
 
@@ -3470,12 +3415,7 @@ def _format(operand):
             && !(node.instruction.operation.control_flow() || new_op.operation.control_flow())
         {
             // if new_op has a condition, the condition can't be propagated from the old node
-            if new_op
-                .extra_attrs
-                .as_ref()
-                .and_then(|extra| extra.condition.as_ref())
-                .is_some()
-            {
+            if new_op.extra_attrs.condition().is_some() {
                 return Err(DAGCircuitError::new_err(
                     "Cannot propagate a condition to an operation that already has one.",
                 ));
@@ -3486,17 +3426,8 @@ def _format(operand):
                         "Cannot add a condition on a generic Operation.",
                     ));
                 }
-                if let Some(ref mut extra) = extra_attrs {
-                    extra.condition = Some(old_condition.clone_ref(py));
-                } else {
-                    extra_attrs = ExtraInstructionAttributes::new(
-                        None,
-                        None,
-                        None,
-                        Some(old_condition.clone_ref(py)),
-                    )
-                    .map(Box::new)
-                }
+                extra_attrs.set_condition(Some(old_condition.clone_ref(py)));
+
                 let binding = self
                     .control_flow_module
                     .condition_resources(old_condition.bind(py))?;
@@ -5029,11 +4960,9 @@ impl DAGCircuit {
         let filter_fn = move |node_index: NodeIndex| -> Result<bool, Infallible> {
             let node = &self.dag[node_index];
             match node {
-                NodeType::Operation(inst) => Ok(namelist.contains(inst.op.name())
-                    && match &inst.extra_attrs {
-                        None => true,
-                        Some(attrs) => attrs.condition.is_none(),
-                    }),
+                NodeType::Operation(inst) => {
+                    Ok(namelist.contains(inst.op.name()) && inst.extra_attrs.condition().is_none())
+                }
                 _ => Ok(false),
             }
         };
@@ -6276,7 +6205,7 @@ impl DAGCircuit {
                 clbits: old_node.clbits,
                 params: (!new_gate.1.is_empty())
                     .then(|| Box::new(new_gate.1.iter().map(|x| Param::Float(*x)).collect())),
-                extra_attrs: None,
+                extra_attrs: ExtraInstructionAttributes::default(),
                 #[cfg(feature = "cache_pygates")]
                 py_op: OnceCell::new(),
             }
diff --git a/crates/circuit/src/dag_node.rs b/crates/circuit/src/dag_node.rs
index ccae7a8c5d82..4d82cf31e813 100644
--- a/crates/circuit/src/dag_node.rs
+++ b/crates/circuit/src/dag_node.rs
@@ -368,34 +368,28 @@ impl DAGOpNode {
 
     #[getter]
     fn label(&self) -> Option<&str> {
-        self.instruction
-            .extra_attrs
-            .as_ref()
-            .and_then(|attrs| attrs.label.as_deref())
+        self.instruction.extra_attrs.label()
     }
 
     #[getter]
     fn condition(&self, py: Python) -> Option<PyObject> {
         self.instruction
             .extra_attrs
-            .as_ref()
-            .and_then(|attrs| attrs.condition.as_ref().map(|x| x.clone_ref(py)))
+            .condition()
+            .map(|x| x.clone_ref(py))
     }
 
     #[getter]
     fn duration(&self, py: Python) -> Option<PyObject> {
         self.instruction
             .extra_attrs
-            .as_ref()
-            .and_then(|attrs| attrs.duration.as_ref().map(|x| x.clone_ref(py)))
+            .duration()
+            .map(|x| x.clone_ref(py))
     }
 
     #[getter]
     fn unit(&self) -> Option<&str> {
-        self.instruction
-            .extra_attrs
-            .as_ref()
-            .and_then(|attrs| attrs.unit.as_deref())
+        self.instruction.extra_attrs.unit()
     }
 
     /// Is the :class:`.Operation` contained in this node a Qiskit standard gate?
@@ -426,30 +420,7 @@ impl DAGOpNode {
 
     #[setter]
     fn set_label(&mut self, val: Option<String>) {
-        match self.instruction.extra_attrs.as_mut() {
-            Some(attrs) => attrs.label = val,
-            None => {
-                if val.is_some() {
-                    self.instruction.extra_attrs = Some(Box::new(
-                        crate::circuit_instruction::ExtraInstructionAttributes {
-                            label: val,
-                            duration: None,
-                            unit: None,
-                            condition: None,
-                        },
-                    ))
-                }
-            }
-        };
-        if let Some(attrs) = &self.instruction.extra_attrs {
-            if attrs.label.is_none()
-                && attrs.duration.is_none()
-                && attrs.unit.is_none()
-                && attrs.condition.is_none()
-            {
-                self.instruction.extra_attrs = None;
-            }
-        }
+        self.instruction.extra_attrs.set_label(val);
     }
 
     #[getter]
diff --git a/crates/circuit/src/operations.rs b/crates/circuit/src/operations.rs
index 2a341d687f6c..ad76e9d44008 100644
--- a/crates/circuit/src/operations.rs
+++ b/crates/circuit/src/operations.rs
@@ -425,22 +425,28 @@ impl StandardGate {
         &self,
         py: Python,
         params: Option<&[Param]>,
-        extra_attrs: Option<&ExtraInstructionAttributes>,
+        extra_attrs: &ExtraInstructionAttributes,
     ) -> PyResult<Py<PyAny>> {
         let gate_class = get_std_gate_class(py, *self)?;
         let args = match params.unwrap_or(&[]) {
             &[] => PyTuple::empty_bound(py),
             params => PyTuple::new_bound(py, params),
         };
-        if let Some(extra) = extra_attrs {
+        let (label, unit, duration, condition) = (
+            extra_attrs.label(),
+            extra_attrs.unit(),
+            extra_attrs.duration(),
+            extra_attrs.condition(),
+        );
+        if label.is_some() || unit.is_some() || duration.is_some() || condition.is_some() {
             let kwargs = [
-                ("label", extra.label.to_object(py)),
-                ("unit", extra.py_unit(py).into_any()),
-                ("duration", extra.duration.to_object(py)),
+                ("label", label.to_object(py)),
+                ("unit", extra_attrs.py_unit(py).into_any()),
+                ("duration", duration.to_object(py)),
             ]
             .into_py_dict_bound(py);
             let mut out = gate_class.call_bound(py, args, Some(&kwargs))?;
-            if let Some(ref condition) = extra.condition {
+            if let Some(condition) = condition {
                 out = out.call_method0(py, "to_mutable")?;
                 out.setattr(py, "condition", condition)?;
             }
diff --git a/crates/circuit/src/packed_instruction.rs b/crates/circuit/src/packed_instruction.rs
index df8f9801314a..82c678031a15 100644
--- a/crates/circuit/src/packed_instruction.rs
+++ b/crates/circuit/src/packed_instruction.rs
@@ -497,7 +497,7 @@ pub struct PackedInstruction {
     /// The index under which the interner has stored `clbits`.
     pub clbits: Interned<[Clbit]>,
     pub params: Option<Box<SmallVec<[Param; 3]>>>,
-    pub extra_attrs: Option<Box<ExtraInstructionAttributes>>,
+    pub extra_attrs: ExtraInstructionAttributes,
 
     #[cfg(feature = "cache_pygates")]
     /// This is hidden in a `OnceCell` because it's just an on-demand cache; we don't create this
@@ -548,16 +548,12 @@ impl PackedInstruction {
 
     #[inline]
     pub fn condition(&self) -> Option<&Py<PyAny>> {
-        self.extra_attrs
-            .as_ref()
-            .and_then(|extra| extra.condition.as_ref())
+        self.extra_attrs.condition()
     }
 
     #[inline]
     pub fn label(&self) -> Option<&str> {
-        self.extra_attrs
-            .as_ref()
-            .and_then(|extra| extra.label.as_deref())
+        self.extra_attrs.label()
     }
 
     /// Build a reference to the Python-space operation object (the `Gate`, etc) packed into this
@@ -573,7 +569,7 @@ impl PackedInstruction {
                 OperationRef::Standard(standard) => standard.create_py_op(
                     py,
                     self.params.as_deref().map(SmallVec::as_slice),
-                    self.extra_attrs.as_deref(),
+                    &self.extra_attrs,
                 ),
                 OperationRef::Gate(gate) => Ok(gate.gate.clone_ref(py)),
                 OperationRef::Instruction(instruction) => Ok(instruction.instruction.clone_ref(py)),

From 653b5b66f5d856290acf26d40a9dac29ccfa21d5 Mon Sep 17 00:00:00 2001
From: Shelly Garion <46566946+ShellyGarion@users.noreply.github.com>
Date: Fri, 13 Sep 2024 17:35:03 +0300
Subject: [PATCH 81/85] Clean two_qubit_decompose code (#13093)

* add pyfunction for decompose_two_qubit_product_gate

* replace python code by rust for decompose_two_qubit_product_gate

* remove unused code from two_qubit_decompose.py

* updates following review comments

* port trace_to_fid to rust

* port Ud to rust

* fix lint errors

* fix lint errors

* format

* remove PyResult following review
---
 crates/accelerate/src/two_qubit_decompose.rs  | 73 ++++++++++++++++++-
 .../two_qubit/two_qubit_decompose.py          | 67 +----------------
 test/python/synthesis/test_synthesis.py       |  2 +-
 test/randomized/test_synthesis.py             |  2 +-
 4 files changed, 78 insertions(+), 66 deletions(-)

diff --git a/crates/accelerate/src/two_qubit_decompose.rs b/crates/accelerate/src/two_qubit_decompose.rs
index 92ad4724682f..76b92acd3faf 100644
--- a/crates/accelerate/src/two_qubit_decompose.rs
+++ b/crates/accelerate/src/two_qubit_decompose.rs
@@ -32,7 +32,7 @@ use ndarray::linalg::kron;
 use ndarray::prelude::*;
 use ndarray::Zip;
 use numpy::{IntoPyArray, ToPyArray};
-use numpy::{PyReadonlyArray1, PyReadonlyArray2};
+use numpy::{PyArray2, PyArrayLike2, PyReadonlyArray1, PyReadonlyArray2};
 
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
@@ -154,6 +154,15 @@ impl TraceToFidelity for c64 {
     }
 }
 
+#[pyfunction]
+#[pyo3(name = "trace_to_fid")]
+/// Average gate fidelity is :math:`Fbar = (d + |Tr (Utarget \\cdot U^dag)|^2) / d(d+1)`
+/// M. Horodecki, P. Horodecki and R. Horodecki, PRA 60, 1888 (1999)
+fn py_trace_to_fid(trace: Complex64) -> PyResult<f64> {
+    let fid = trace.trace_to_fid();
+    Ok(fid)
+}
+
 fn decompose_two_qubit_product_gate(
     special_unitary: ArrayView2<Complex64>,
 ) -> PyResult<(Array2<Complex64>, Array2<Complex64>, f64)> {
@@ -182,9 +191,31 @@ fn decompose_two_qubit_product_gate(
     }
     l.mapv_inplace(|x| x / det_l.sqrt());
     let phase = det_l.arg() / 2.;
+
     Ok((l, r, phase))
 }
 
+#[pyfunction]
+#[pyo3(name = "decompose_two_qubit_product_gate")]
+/// Decompose :math:`U = U_l \otimes U_r` where :math:`U \in SU(4)`,
+/// and :math:`U_l,~U_r \in SU(2)`.
+/// Args:
+///     special_unitary_matrix: special unitary matrix to decompose
+/// Raises:
+///     QiskitError: if decomposition isn't possible.
+fn py_decompose_two_qubit_product_gate(
+    py: Python,
+    special_unitary: PyArrayLike2<Complex64>,
+) -> PyResult<(PyObject, PyObject, f64)> {
+    let view = special_unitary.as_array();
+    let (l, r, phase) = decompose_two_qubit_product_gate(view)?;
+    Ok((
+        l.into_pyarray_bound(py).unbind().into(),
+        r.into_pyarray_bound(py).unbind().into(),
+        phase,
+    ))
+}
+
 fn __weyl_coordinates(unitary: MatRef<c64>) -> [f64; 3] {
     let uscaled = scale(C1 / unitary.determinant().powf(0.25)) * unitary;
     let uup = transform_from_magic_basis(uscaled);
@@ -301,6 +332,43 @@ fn rz_matrix(theta: f64) -> Array2<Complex64> {
     array![[(-ilam2).exp(), C_ZERO], [C_ZERO, ilam2.exp()]]
 }
 
+/// Generates the array :math:`e^{(i a XX + i b YY + i c ZZ)}`
+fn ud(a: f64, b: f64, c: f64) -> Array2<Complex64> {
+    array![
+        [
+            (IM * c).exp() * (a - b).cos(),
+            C_ZERO,
+            C_ZERO,
+            IM * (IM * c).exp() * (a - b).sin()
+        ],
+        [
+            C_ZERO,
+            (M_IM * c).exp() * (a + b).cos(),
+            IM * (M_IM * c).exp() * (a + b).sin(),
+            C_ZERO
+        ],
+        [
+            C_ZERO,
+            IM * (M_IM * c).exp() * (a + b).sin(),
+            (M_IM * c).exp() * (a + b).cos(),
+            C_ZERO
+        ],
+        [
+            IM * (IM * c).exp() * (a - b).sin(),
+            C_ZERO,
+            C_ZERO,
+            (IM * c).exp() * (a - b).cos()
+        ]
+    ]
+}
+
+#[pyfunction]
+#[pyo3(name = "Ud")]
+fn py_ud(py: Python, a: f64, b: f64, c: f64) -> Py<PyArray2<Complex64>> {
+    let ud_mat = ud(a, b, c);
+    ud_mat.into_pyarray_bound(py).unbind()
+}
+
 fn compute_unitary(sequence: &TwoQubitSequenceVec, global_phase: f64) -> Array2<Complex64> {
     let identity = aview2(&ONE_QUBIT_IDENTITY);
     let phase = c64(0., global_phase).exp();
@@ -2278,9 +2346,12 @@ pub fn local_equivalence(weyl: PyReadonlyArray1<f64>) -> PyResult<[f64; 3]> {
 
 pub fn two_qubit_decompose(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(_num_basis_gates))?;
+    m.add_wrapped(wrap_pyfunction!(py_decompose_two_qubit_product_gate))?;
     m.add_wrapped(wrap_pyfunction!(two_qubit_decompose_up_to_diagonal))?;
     m.add_wrapped(wrap_pyfunction!(two_qubit_local_invariants))?;
     m.add_wrapped(wrap_pyfunction!(local_equivalence))?;
+    m.add_wrapped(wrap_pyfunction!(py_trace_to_fid))?;
+    m.add_wrapped(wrap_pyfunction!(py_ud))?;
     m.add_class::<TwoQubitGateSequence>()?;
     m.add_class::<TwoQubitWeylDecomposition>()?;
     m.add_class::<Specialization>()?;
diff --git a/qiskit/synthesis/two_qubit/two_qubit_decompose.py b/qiskit/synthesis/two_qubit/two_qubit_decompose.py
index 0e3427773387..d4c7702da35a 100644
--- a/qiskit/synthesis/two_qubit/two_qubit_decompose.py
+++ b/qiskit/synthesis/two_qubit/two_qubit_decompose.py
@@ -24,8 +24,6 @@
 arXiv:1811.12926 [quant-ph] (2018).
 """
 from __future__ import annotations
-import cmath
-import math
 import io
 import base64
 import warnings
@@ -91,41 +89,18 @@ def decompose_two_qubit_product_gate(special_unitary_matrix: np.ndarray):
         QiskitError: if decomposition isn't possible.
     """
     special_unitary_matrix = np.asarray(special_unitary_matrix, dtype=complex)
-    # extract the right component
-    R = special_unitary_matrix[:2, :2].copy()
-    detR = R[0, 0] * R[1, 1] - R[0, 1] * R[1, 0]
-    if abs(detR) < 0.1:
-        R = special_unitary_matrix[2:, :2].copy()
-        detR = R[0, 0] * R[1, 1] - R[0, 1] * R[1, 0]
-    if abs(detR) < 0.1:
-        raise QiskitError("decompose_two_qubit_product_gate: unable to decompose: detR < 0.1")
-    R /= np.sqrt(detR)
-
-    # extract the left component
-    temp = np.kron(np.eye(2), R.T.conj())
-    temp = special_unitary_matrix.dot(temp)
-    L = temp[::2, ::2]
-    detL = L[0, 0] * L[1, 1] - L[0, 1] * L[1, 0]
-    if abs(detL) < 0.9:
-        raise QiskitError("decompose_two_qubit_product_gate: unable to decompose: detL < 0.9")
-    L /= np.sqrt(detL)
-    phase = cmath.phase(detL) / 2
+    (L, R, phase) = two_qubit_decompose.decompose_two_qubit_product_gate(special_unitary_matrix)
 
     temp = np.kron(L, R)
     deviation = abs(abs(temp.conj().T.dot(special_unitary_matrix).trace()) - 4)
+
     if deviation > 1.0e-13:
         raise QiskitError(
             "decompose_two_qubit_product_gate: decomposition failed: "
             f"deviation too large: {deviation}"
         )
 
-    return L, R, phase
-
-
-_ipx = np.array([[0, 1j], [1j, 0]], dtype=complex)
-_ipy = np.array([[0, 1], [-1, 0]], dtype=complex)
-_ipz = np.array([[1j, 0], [0, -1j]], dtype=complex)
-_id = np.array([[1, 0], [0, 1]], dtype=complex)
+    return (L, R, phase)
 
 
 class TwoQubitWeylDecomposition:
@@ -239,7 +214,7 @@ def actual_fidelity(self, **kwargs) -> float:
         """Calculates the actual fidelity of the decomposed circuit to the input unitary."""
         circ = self.circuit(**kwargs)
         trace = np.trace(Operator(circ).data.T.conj() @ self.unitary_matrix)
-        return trace_to_fid(trace)
+        return two_qubit_decompose.trace_to_fid(trace)
 
     def __repr__(self):
         """Represent with enough precision to allow copy-paste debugging of all corner cases"""
@@ -460,40 +435,6 @@ def _weyl_gate(self, circ: QuantumCircuit, atol=1.0e-13):
         return circ
 
 
-def Ud(a, b, c):
-    r"""Generates the array :math:`e^{(i a XX + i b YY + i c ZZ)}`"""
-    return np.array(
-        [
-            [cmath.exp(1j * c) * math.cos(a - b), 0, 0, 1j * cmath.exp(1j * c) * math.sin(a - b)],
-            [0, cmath.exp(-1j * c) * math.cos(a + b), 1j * cmath.exp(-1j * c) * math.sin(a + b), 0],
-            [0, 1j * cmath.exp(-1j * c) * math.sin(a + b), cmath.exp(-1j * c) * math.cos(a + b), 0],
-            [1j * cmath.exp(1j * c) * math.sin(a - b), 0, 0, cmath.exp(1j * c) * math.cos(a - b)],
-        ],
-        dtype=complex,
-    )
-
-
-def trace_to_fid(trace):
-    r"""Average gate fidelity is
-
-    .. math::
-
-        \bar{F} = \frac{d + |\mathrm{Tr} (U_\text{target} \cdot U^{\dag})|^2}{d(d+1)}
-
-    M. Horodecki, P. Horodecki and R. Horodecki, PRA 60, 1888 (1999)"""
-    return (4 + abs(trace) ** 2) / 20
-
-
-def rz_array(theta):
-    """Return numpy array for Rz(theta).
-
-    Rz(theta) = diag(exp(-i*theta/2),exp(i*theta/2))
-    """
-    return np.array(
-        [[cmath.exp(-1j * theta / 2.0), 0], [0, cmath.exp(1j * theta / 2.0)]], dtype=complex
-    )
-
-
 class TwoQubitBasisDecomposer:
     """A class for decomposing 2-qubit unitaries into minimal number of uses of a 2-qubit
     basis gate.
diff --git a/test/python/synthesis/test_synthesis.py b/test/python/synthesis/test_synthesis.py
index b4fac3f427f0..b08240197211 100644
--- a/test/python/synthesis/test_synthesis.py
+++ b/test/python/synthesis/test_synthesis.py
@@ -59,11 +59,11 @@
     two_qubit_cnot_decompose,
     TwoQubitBasisDecomposer,
     TwoQubitControlledUDecomposer,
-    Ud,
     decompose_two_qubit_product_gate,
 )
 from qiskit._accelerate.two_qubit_decompose import two_qubit_decompose_up_to_diagonal
 from qiskit._accelerate.two_qubit_decompose import Specialization
+from qiskit._accelerate.two_qubit_decompose import Ud
 from qiskit.synthesis.unitary import qsd
 from test import combine  # pylint: disable=wrong-import-order
 from test import QiskitTestCase  # pylint: disable=wrong-import-order
diff --git a/test/randomized/test_synthesis.py b/test/randomized/test_synthesis.py
index 9f0619a0c296..5e500b78dafc 100644
--- a/test/randomized/test_synthesis.py
+++ b/test/randomized/test_synthesis.py
@@ -23,8 +23,8 @@
 from qiskit.synthesis.two_qubit.two_qubit_decompose import (
     two_qubit_cnot_decompose,
     TwoQubitBasisDecomposer,
-    Ud,
 )
+from qiskit._accelerate.two_qubit_decompose import Ud
 
 
 class TestSynthesis(CheckDecompositions):

From a0918b8fc6c25bd9cb35ede1b7778f7ae9178aed Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 16 Sep 2024 13:59:12 +0100
Subject: [PATCH 82/85] Bump once_cell from 1.19.0 to 1.20.0 (#13156)

Bumps [once_cell](https://github.com/matklad/once_cell) from 1.19.0 to 1.20.0.
- [Changelog](https://github.com/matklad/once_cell/blob/master/CHANGELOG.md)
- [Commits](https://github.com/matklad/once_cell/compare/v1.19.0...v1.20.0)

---
updated-dependencies:
- dependency-name: once_cell
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock                   | 4 ++--
 crates/accelerate/Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d73b21266dab..15f5a7833ca5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -903,9 +903,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.19.0"
+version = "1.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+checksum = "33ea5043e58958ee56f3e15a90aee535795cd7dfd319846288d93c5b57d85cbe"
 
 [[package]]
 name = "oq3_lexer"
diff --git a/crates/accelerate/Cargo.toml b/crates/accelerate/Cargo.toml
index 4b5c18e5eb93..4c570f4a5285 100644
--- a/crates/accelerate/Cargo.toml
+++ b/crates/accelerate/Cargo.toml
@@ -25,7 +25,7 @@ itertools.workspace = true
 qiskit-circuit.workspace = true
 thiserror.workspace = true
 ndarray_einsum_beta = "0.7"
-once_cell = "1.19.0"
+once_cell = "1.20.0"
 
 [dependencies.smallvec]
 workspace = true

From 87836411a897a977b3d19c4a76d71634c47d7747 Mon Sep 17 00:00:00 2001
From: Matthew Treinish <mtreinish@kortar.org>
Date: Mon, 16 Sep 2024 16:59:21 -0400
Subject: [PATCH 83/85] Add LightSABRE citation to sabre documentation (#13160)

* Add LightSABRE citation to sabre documentation

We recently published a pre-print of a new paper that describes all the
improvements we've developed ontop of the original SABRE algorithm as
part of Qiskit's implementation. This commit adds a citation for that
new paper to the documentation of the two sabre passes in qiskit to
better document how the pass works in practice.

* Add missing citation to SabrePreLayout and fix formatting in SabreSwap

* Tweak wording in sabre swap docstring
---
 qiskit/transpiler/passes/layout/sabre_layout.py     |  5 ++++-
 qiskit/transpiler/passes/layout/sabre_pre_layout.py |  5 +++++
 qiskit/transpiler/passes/routing/sabre_swap.py      | 10 +++++++---
 3 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/qiskit/transpiler/passes/layout/sabre_layout.py b/qiskit/transpiler/passes/layout/sabre_layout.py
index 7e7031ec3361..78af67ad9118 100644
--- a/qiskit/transpiler/passes/layout/sabre_layout.py
+++ b/qiskit/transpiler/passes/layout/sabre_layout.py
@@ -101,7 +101,10 @@ class SabreLayout(TransformationPass):
 
     **References:**
 
-    [1] Li, Gushu, Yufei Ding, and Yuan Xie. "Tackling the qubit mapping problem
+    [1] Henry Zou and Matthew Treinish and Kevin Hartman and Alexander Ivrii and Jake Lishman.
+    "LightSABRE: A Lightweight and Enhanced SABRE Algorithm"
+    `arXiv:2409.08368 <https://doi.org/10.48550/arXiv.2409.08368>`__
+    [2] Li, Gushu, Yufei Ding, and Yuan Xie. "Tackling the qubit mapping problem
     for NISQ-era quantum devices." ASPLOS 2019.
     `arXiv:1809.02573 <https://arxiv.org/pdf/1809.02573.pdf>`_
     """
diff --git a/qiskit/transpiler/passes/layout/sabre_pre_layout.py b/qiskit/transpiler/passes/layout/sabre_pre_layout.py
index 4a7ea35e3f2a..1fd4f60e254f 100644
--- a/qiskit/transpiler/passes/layout/sabre_pre_layout.py
+++ b/qiskit/transpiler/passes/layout/sabre_pre_layout.py
@@ -31,6 +31,11 @@ class SabrePreLayout(AnalysisPass):
     ``sabre_starting_layouts`` (``list[Layout]``)
         An optional list of :class:`~.Layout` objects to use for additional Sabre layout trials.
 
+    **References:**
+
+    [1] Henry Zou and Matthew Treinish and Kevin Hartman and Alexander Ivrii and Jake Lishman.
+    "LightSABRE: A Lightweight and Enhanced SABRE Algorithm"
+    `arXiv:2409.08368 <https://doi.org/10.48550/arXiv.2409.08368>`__
     """
 
     def __init__(
diff --git a/qiskit/transpiler/passes/routing/sabre_swap.py b/qiskit/transpiler/passes/routing/sabre_swap.py
index 9edd1ceee445..238444067168 100644
--- a/qiskit/transpiler/passes/routing/sabre_swap.py
+++ b/qiskit/transpiler/passes/routing/sabre_swap.py
@@ -41,8 +41,9 @@ class SabreSwap(TransformationPass):
     r"""Map input circuit onto a backend topology via insertion of SWAPs.
 
     Implementation of the SWAP-based heuristic search from the SABRE qubit
-    mapping paper [1] (Algorithm 1). The heuristic aims to minimize the number
-    of lossy SWAPs inserted and the depth of the circuit.
+    mapping paper [2] (Algorithm 1) with the modifications from the LightSABRE
+    paper [1]. The heuristic aims to minimize the number of lossy SWAPs inserted
+    and the depth of the circuit.
 
     This algorithm starts from an initial layout of virtual qubits onto physical
     qubits, and iterates over the circuit DAG until all gates are exhausted,
@@ -69,7 +70,10 @@ class SabreSwap(TransformationPass):
 
     **References:**
 
-    [1] Li, Gushu, Yufei Ding, and Yuan Xie. "Tackling the qubit mapping problem
+    [1] Henry Zou and Matthew Treinish and Kevin Hartman and Alexander Ivrii and Jake Lishman.
+    "LightSABRE: A Lightweight and Enhanced SABRE Algorithm"
+    `arXiv:2409.08368 <https://doi.org/10.48550/arXiv.2409.08368>`__
+    [2] Li, Gushu, Yufei Ding, and Yuan Xie. "Tackling the qubit mapping problem
     for NISQ-era quantum devices." ASPLOS 2019.
     `arXiv:1809.02573 <https://arxiv.org/pdf/1809.02573.pdf>`_
     """

From c68e80329cafbf00639e85c92e2d455462be0b2c Mon Sep 17 00:00:00 2001
From: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>
Date: Tue, 17 Sep 2024 17:55:21 -0400
Subject: [PATCH 84/85] Add rust-native `apply_operation` methods (#13143)

* Initial: Add rust-native `apply_operation_front` and `apply_operation_back methods.
- These methods allow rust users to add an operation to either the front or the back of the circuit without needing to have valid interned indices for the Qargs/Qargs of said operations.
- Leverage the new methods in the existing python variants of them.

* Fix: Remove extra blank space

* Fix: Revert changes to python `apply_op` methods.
- To avoid an ownership issue, usage of the new methods from the Python variants has been removed.
- As requested, the insertion check in the rust `apply_op` has been removed.

* Fix: Adapt to new `ExtraInstructionProperties` infrastructure.

* Format: Change redundant iteration statement for params
---
 crates/circuit/src/dag_circuit.rs | 111 +++++++++++++++++++++++++++++-
 1 file changed, 110 insertions(+), 1 deletion(-)

diff --git a/crates/circuit/src/dag_circuit.rs b/crates/circuit/src/dag_circuit.rs
index 5b218b2de818..54f270b30558 100644
--- a/crates/circuit/src/dag_circuit.rs
+++ b/crates/circuit/src/dag_circuit.rs
@@ -13,6 +13,7 @@
 use std::hash::{Hash, Hasher};
 
 use ahash::RandomState;
+use smallvec::SmallVec;
 
 use crate::bit_data::BitData;
 use crate::circuit_data::CircuitData;
@@ -26,7 +27,7 @@ use crate::error::DAGCircuitError;
 use crate::imports;
 use crate::interner::{Interned, Interner};
 use crate::operations::{Operation, OperationRef, Param, PyInstruction, StandardGate};
-use crate::packed_instruction::PackedInstruction;
+use crate::packed_instruction::{PackedInstruction, PackedOperation};
 use crate::rustworkx_core_vnext::isomorphism;
 use crate::{BitType, Clbit, Qubit, TupleLikeArg};
 
@@ -5192,6 +5193,114 @@ impl DAGCircuit {
         Ok(new_node)
     }
 
+    /// Apply a [PackedOperation] to the back of the circuit.
+    pub fn apply_operation_back(
+        &mut self,
+        py: Python,
+        op: PackedOperation,
+        qargs: &[Qubit],
+        cargs: &[Clbit],
+        params: Option<SmallVec<[Param; 3]>>,
+        extra_attrs: ExtraInstructionAttributes,
+        #[cfg(feature = "cache_pygates")] py_op: Option<PyObject>,
+    ) -> PyResult<NodeIndex> {
+        self.inner_apply_op(
+            py,
+            op,
+            qargs,
+            cargs,
+            params,
+            extra_attrs,
+            #[cfg(feature = "cache_pygates")]
+            py_op,
+            false,
+        )
+    }
+
+    /// Apply a [PackedOperation] to the front of the circuit.
+    pub fn apply_operation_front(
+        &mut self,
+        py: Python,
+        op: PackedOperation,
+        qargs: &[Qubit],
+        cargs: &[Clbit],
+        params: Option<SmallVec<[Param; 3]>>,
+        extra_attrs: ExtraInstructionAttributes,
+        #[cfg(feature = "cache_pygates")] py_op: Option<PyObject>,
+    ) -> PyResult<NodeIndex> {
+        self.inner_apply_op(
+            py,
+            op,
+            qargs,
+            cargs,
+            params,
+            extra_attrs,
+            #[cfg(feature = "cache_pygates")]
+            py_op,
+            true,
+        )
+    }
+
+    #[inline]
+    #[allow(clippy::too_many_arguments)]
+    fn inner_apply_op(
+        &mut self,
+        py: Python,
+        op: PackedOperation,
+        qargs: &[Qubit],
+        cargs: &[Clbit],
+        params: Option<SmallVec<[Param; 3]>>,
+        extra_attrs: ExtraInstructionAttributes,
+        #[cfg(feature = "cache_pygates")] py_op: Option<PyObject>,
+        front: bool,
+    ) -> PyResult<NodeIndex> {
+        // Check that all qargs are within an acceptable range
+        qargs.iter().try_for_each(|qarg| {
+            if qarg.0 as usize >= self.num_qubits() {
+                return Err(PyValueError::new_err(format!(
+                    "Qubit index {} is out of range. This DAGCircuit currently has only {} qubits.",
+                    qarg.0,
+                    self.num_qubits()
+                )));
+            }
+            Ok(())
+        })?;
+
+        // Check that all cargs are within an acceptable range
+        cargs.iter().try_for_each(|carg| {
+            if carg.0 as usize >= self.num_clbits() {
+                return Err(PyValueError::new_err(format!(
+                    "Clbit index {} is out of range. This DAGCircuit currently has only {} clbits.",
+                    carg.0,
+                    self.num_clbits()
+                )));
+            }
+            Ok(())
+        })?;
+
+        #[cfg(feature = "cache_pygates")]
+        let py_op = if let Some(py_op) = py_op {
+            py_op.into()
+        } else {
+            OnceCell::new()
+        };
+        let packed_instruction = PackedInstruction {
+            op,
+            qubits: self.qargs_interner.insert(qargs),
+            clbits: self.cargs_interner.insert(cargs),
+            params: params.map(Box::new),
+            extra_attrs,
+            #[cfg(feature = "cache_pygates")]
+            py_op,
+        };
+
+        if front {
+            self.push_front(py, packed_instruction)
+        } else {
+            self.push_back(py, packed_instruction)
+        }
+    }
+
     fn sort_key(&self, node: NodeIndex) -> SortKeyType {
         match &self.dag[node] {
             NodeType::Operation(packed) => (

From f091cf291a0a478cf808d90287a45c8a1b786134 Mon Sep 17 00:00:00 2001
From: Jake Lishman <jake.lishman@ibm.com>
Date: Wed, 18 Sep 2024 08:33:56 +0100
Subject: [PATCH 85/85] Add example of `qasm2.CustomInstruction` (#13167)

We didn't have an explicit usage example of this in the documentation
before, and several people seem to have been confused by it.
---
 qiskit/qasm2/parse.py | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/qiskit/qasm2/parse.py b/qiskit/qasm2/parse.py
index a40270a99b8c..6cdb0f70bba0 100644
--- a/qiskit/qasm2/parse.py
+++ b/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