diff --git a/Cargo.lock b/Cargo.lock
index aefa3c932a04..454823748e8d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -307,9 +307,9 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
 
 [[package]]
 name = "faer"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91ef9e1a4098a9e3a03c47bc5061406c04820552d869fd0fcd92587d07b271f0"
+checksum = "41543c4de4bfb32efdffdd75cbcca5ef41b800e8a811ea4a41fb9393c6ef3bc0"
 dependencies = [
  "bytemuck",
  "coe-rs",
diff --git a/constraints.txt b/constraints.txt
index d3985581d362..6681de226d93 100644
--- a/constraints.txt
+++ b/constraints.txt
@@ -3,6 +3,10 @@
 # https://github.com/Qiskit/qiskit-terra/issues/10345 for current details.
 scipy<1.11; python_version<'3.12'
 
+# Temporary pin to avoid CI issues caused by scipy 1.14.0
+# See https://github.com/Qiskit/qiskit/issues/12655 for current details.
+scipy==1.13.1; python_version=='3.12'
+
 # z3-solver from 4.12.3 onwards upped the minimum macOS API version for its
 # wheels to 11.7. The Azure VM images contain pre-built CPythons, of which at
 # least CPython 3.8 was compiled for an older macOS, so does not match a
diff --git a/crates/accelerate/Cargo.toml b/crates/accelerate/Cargo.toml
index d9865d545437..b377a9b38a6d 100644
--- a/crates/accelerate/Cargo.toml
+++ b/crates/accelerate/Cargo.toml
@@ -20,7 +20,7 @@ num-traits = "0.2"
 num-complex.workspace = true
 num-bigint = "0.4"
 rustworkx-core = "0.14"
-faer = "0.19.0"
+faer = "0.19.1"
 itertools = "0.13.0"
 qiskit-circuit.workspace = true
 
diff --git a/crates/accelerate/src/lib.rs b/crates/accelerate/src/lib.rs
index 5eca831dab9f..314fa5ff7c58 100644
--- a/crates/accelerate/src/lib.rs
+++ b/crates/accelerate/src/lib.rs
@@ -23,12 +23,12 @@ pub mod isometry;
 pub mod nlayout;
 pub mod optimize_1q_gates;
 pub mod pauli_exp_val;
-pub mod permutation;
 pub mod results;
 pub mod sabre;
 pub mod sampled_exp_val;
 pub mod sparse_pauli_op;
 pub mod stochastic_swap;
+pub mod synthesis;
 pub mod target_transpiler;
 pub mod two_qubit_decompose;
 pub mod uc_gate;
diff --git a/crates/accelerate/src/synthesis/mod.rs b/crates/accelerate/src/synthesis/mod.rs
new file mode 100644
index 000000000000..f1a720459211
--- /dev/null
+++ b/crates/accelerate/src/synthesis/mod.rs
@@ -0,0 +1,22 @@
+// 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.
+
+mod permutation;
+
+use pyo3::prelude::*;
+use pyo3::wrap_pymodule;
+
+#[pymodule]
+pub fn synthesis(m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_wrapped(wrap_pymodule!(permutation::permutation))?;
+    Ok(())
+}
diff --git a/crates/accelerate/src/synthesis/permutation/mod.rs b/crates/accelerate/src/synthesis/permutation/mod.rs
new file mode 100644
index 000000000000..bf0ff97848f2
--- /dev/null
+++ b/crates/accelerate/src/synthesis/permutation/mod.rs
@@ -0,0 +1,68 @@
+// 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::PyArrayLike1;
+use smallvec::smallvec;
+
+use pyo3::prelude::*;
+use pyo3::wrap_pyfunction;
+
+use qiskit_circuit::circuit_data::CircuitData;
+use qiskit_circuit::operations::{Param, StandardGate};
+use qiskit_circuit::Qubit;
+
+mod utils;
+
+/// Checks whether an array of size N is a permutation of 0, 1, ..., N - 1.
+#[pyfunction]
+#[pyo3(signature = (pattern))]
+pub fn _validate_permutation(py: Python, pattern: PyArrayLike1<i64>) -> PyResult<PyObject> {
+    let view = pattern.as_array();
+    utils::validate_permutation(&view)?;
+    Ok(py.None())
+}
+
+/// Finds inverse of a permutation pattern.
+#[pyfunction]
+#[pyo3(signature = (pattern))]
+pub fn _inverse_pattern(py: Python, pattern: PyArrayLike1<i64>) -> PyResult<PyObject> {
+    let view = pattern.as_array();
+    let inverse_i64: Vec<i64> = utils::invert(&view).iter().map(|&x| x as i64).collect();
+    Ok(inverse_i64.to_object(py))
+}
+
+#[pyfunction]
+#[pyo3(signature = (pattern))]
+pub fn _synth_permutation_basic(py: Python, pattern: PyArrayLike1<i64>) -> PyResult<CircuitData> {
+    let view = pattern.as_array();
+    let num_qubits = view.len();
+    CircuitData::from_standard_gates(
+        py,
+        num_qubits as u32,
+        utils::get_ordered_swap(&view).iter().map(|(i, j)| {
+            (
+                StandardGate::SwapGate,
+                smallvec![],
+                smallvec![Qubit(*i as u32), Qubit(*j as u32)],
+            )
+        }),
+        Param::Float(0.0),
+    )
+}
+
+#[pymodule]
+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)?)?;
+    Ok(())
+}
diff --git a/crates/accelerate/src/permutation.rs b/crates/accelerate/src/synthesis/permutation/utils.rs
similarity index 66%
rename from crates/accelerate/src/permutation.rs
rename to crates/accelerate/src/synthesis/permutation/utils.rs
index 31ba433ddd30..a78088bfbfa9 100644
--- a/crates/accelerate/src/permutation.rs
+++ b/crates/accelerate/src/synthesis/permutation/utils.rs
@@ -11,12 +11,11 @@
 // that they have been altered from the originals.
 
 use ndarray::{Array1, ArrayView1};
-use numpy::PyArrayLike1;
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 use std::vec::Vec;
 
-fn validate_permutation(pattern: &ArrayView1<i64>) -> PyResult<()> {
+pub fn validate_permutation(pattern: &ArrayView1<i64>) -> PyResult<()> {
     let n = pattern.len();
     let mut seen: Vec<bool> = vec![false; n];
 
@@ -47,7 +46,7 @@ fn validate_permutation(pattern: &ArrayView1<i64>) -> PyResult<()> {
     Ok(())
 }
 
-fn invert(pattern: &ArrayView1<i64>) -> Array1<usize> {
+pub fn invert(pattern: &ArrayView1<i64>) -> Array1<usize> {
     let mut inverse: Array1<usize> = Array1::zeros(pattern.len());
     pattern.iter().enumerate().for_each(|(ii, &jj)| {
         inverse[jj as usize] = ii;
@@ -55,7 +54,16 @@ fn invert(pattern: &ArrayView1<i64>) -> Array1<usize> {
     inverse
 }
 
-fn get_ordered_swap(pattern: &ArrayView1<i64>) -> Vec<(i64, i64)> {
+/// Sorts the input permutation by iterating through the permutation list
+/// and putting each element to its correct position via a SWAP (if it's not
+/// at the correct position already). If ``n`` is the length of the input
+/// permutation, this requires at most ``n`` SWAPs.
+///
+/// More precisely, if the input permutation is a cycle of length ``m``,
+/// then this creates a quantum circuit with ``m-1`` SWAPs (and of depth ``m-1``);
+/// if the input  permutation consists of several disjoint cycles, then each cycle
+/// is essentially treated independently.
+pub fn get_ordered_swap(pattern: &ArrayView1<i64>) -> Vec<(i64, i64)> {
     let mut permutation: Vec<usize> = pattern.iter().map(|&x| x as usize).collect();
     let mut index_map = invert(pattern);
 
@@ -76,45 +84,3 @@ fn get_ordered_swap(pattern: &ArrayView1<i64>) -> Vec<(i64, i64)> {
     swaps[..].reverse();
     swaps
 }
-
-/// Checks whether an array of size N is a permutation of 0, 1, ..., N - 1.
-#[pyfunction]
-#[pyo3(signature = (pattern))]
-fn _validate_permutation(py: Python, pattern: PyArrayLike1<i64>) -> PyResult<PyObject> {
-    let view = pattern.as_array();
-    validate_permutation(&view)?;
-    Ok(py.None())
-}
-
-/// Finds inverse of a permutation pattern.
-#[pyfunction]
-#[pyo3(signature = (pattern))]
-fn _inverse_pattern(py: Python, pattern: PyArrayLike1<i64>) -> PyResult<PyObject> {
-    let view = pattern.as_array();
-    let inverse_i64: Vec<i64> = invert(&view).iter().map(|&x| x as i64).collect();
-    Ok(inverse_i64.to_object(py))
-}
-
-/// Sorts the input permutation by iterating through the permutation list
-/// and putting each element to its correct position via a SWAP (if it's not
-/// at the correct position already). If ``n`` is the length of the input
-/// permutation, this requires at most ``n`` SWAPs.
-///
-/// More precisely, if the input permutation is a cycle of length ``m``,
-/// then this creates a quantum circuit with ``m-1`` SWAPs (and of depth ``m-1``);
-/// if the input  permutation consists of several disjoint cycles, then each cycle
-/// is essentially treated independently.
-#[pyfunction]
-#[pyo3(signature = (permutation_in))]
-fn _get_ordered_swap(py: Python, permutation_in: PyArrayLike1<i64>) -> PyResult<PyObject> {
-    let view = permutation_in.as_array();
-    Ok(get_ordered_swap(&view).to_object(py))
-}
-
-#[pymodule]
-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!(_get_ordered_swap, m)?)?;
-    Ok(())
-}
diff --git a/crates/accelerate/src/target_transpiler/mod.rs b/crates/accelerate/src/target_transpiler/mod.rs
index d2732d7a5088..5d545536459a 100644
--- a/crates/accelerate/src/target_transpiler/mod.rs
+++ b/crates/accelerate/src/target_transpiler/mod.rs
@@ -127,17 +127,9 @@ impl IntoPy<PyObject> for NormalOperation {
 
 impl ToPyObject for NormalOperation {
     fn to_object(&self, py: Python<'_>) -> PyObject {
-        operation_type_and_data_to_py(
-            py,
-            &self.operation,
-            &self.params,
-            &None,
-            &None,
-            &None,
-            &None,
-        )
-        .ok()
-        .to_object(py)
+        operation_type_and_data_to_py(py, &self.operation, &self.params, None, None, None, None)
+            .ok()
+            .to_object(py)
     }
 }
 
diff --git a/crates/circuit/src/circuit_data.rs b/crates/circuit/src/circuit_data.rs
index da35787e3207..07f4579a4cd3 100644
--- a/crates/circuit/src/circuit_data.rs
+++ b/crates/circuit/src/circuit_data.rs
@@ -10,10 +10,13 @@
 // 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::RefCell;
+
 use crate::bit_data::BitData;
 use crate::circuit_instruction::{
-    convert_py_to_operation_type, operation_type_and_data_to_py, CircuitInstruction,
-    ExtraInstructionAttributes, OperationInput, PackedInstruction,
+    convert_py_to_operation_type, CircuitInstruction, ExtraInstructionAttributes, OperationInput,
+    PackedInstruction,
 };
 use crate::imports::{BUILTIN_LIST, QUBIT};
 use crate::interner::{IndexedInterner, Interner, InternerKey};
@@ -489,66 +492,40 @@ impl CircuitData {
                 .getattr(intern!(py, "deepcopy"))?;
             for inst in &mut res.data {
                 match &mut inst.op {
-                    OperationType::Standard(_) => {
-                        #[cfg(feature = "cache_pygates")]
-                        {
-                            inst.py_op = None;
-                        }
-                    }
+                    OperationType::Standard(_) => {}
                     OperationType::Gate(ref mut op) => {
                         op.gate = deepcopy.call1((&op.gate,))?.unbind();
-                        #[cfg(feature = "cache_pygates")]
-                        {
-                            inst.py_op = None;
-                        }
                     }
                     OperationType::Instruction(ref mut op) => {
                         op.instruction = deepcopy.call1((&op.instruction,))?.unbind();
-                        #[cfg(feature = "cache_pygates")]
-                        {
-                            inst.py_op = None;
-                        }
                     }
                     OperationType::Operation(ref mut op) => {
                         op.operation = deepcopy.call1((&op.operation,))?.unbind();
-                        #[cfg(feature = "cache_pygates")]
-                        {
-                            inst.py_op = None;
-                        }
                     }
                 };
+                #[cfg(feature = "cache_pygates")]
+                {
+                    *inst.py_op.borrow_mut() = None;
+                }
             }
         } else if copy_instructions {
             for inst in &mut res.data {
                 match &mut inst.op {
-                    OperationType::Standard(_) => {
-                        #[cfg(feature = "cache_pygates")]
-                        {
-                            inst.py_op = None;
-                        }
-                    }
+                    OperationType::Standard(_) => {}
                     OperationType::Gate(ref mut op) => {
                         op.gate = op.gate.call_method0(py, intern!(py, "copy"))?;
-                        #[cfg(feature = "cache_pygates")]
-                        {
-                            inst.py_op = None;
-                        }
                     }
                     OperationType::Instruction(ref mut op) => {
                         op.instruction = op.instruction.call_method0(py, intern!(py, "copy"))?;
-                        #[cfg(feature = "cache_pygates")]
-                        {
-                            inst.py_op = None;
-                        }
                     }
                     OperationType::Operation(ref mut op) => {
                         op.operation = op.operation.call_method0(py, intern!(py, "copy"))?;
-                        #[cfg(feature = "cache_pygates")]
-                        {
-                            inst.py_op = None;
-                        }
                     }
                 };
+                #[cfg(feature = "cache_pygates")]
+                {
+                    *inst.py_op.borrow_mut() = None;
+                }
             }
         }
         Ok(res)
@@ -589,87 +566,10 @@ impl CircuitData {
     /// Args:
     ///     func (Callable[[:class:`~.Operation`], None]):
     ///         The callable to invoke.
-    #[cfg(not(feature = "cache_pygates"))]
     #[pyo3(signature = (func))]
     pub fn foreach_op(&self, py: Python<'_>, func: &Bound<PyAny>) -> PyResult<()> {
         for inst in self.data.iter() {
-            let label;
-            let duration;
-            let unit;
-            let condition;
-            match &inst.extra_attrs {
-                Some(extra_attrs) => {
-                    label = &extra_attrs.label;
-                    duration = &extra_attrs.duration;
-                    unit = &extra_attrs.unit;
-                    condition = &extra_attrs.condition;
-                }
-                None => {
-                    label = &None;
-                    duration = &None;
-                    unit = &None;
-                    condition = &None;
-                }
-            }
-
-            let op = operation_type_and_data_to_py(
-                py,
-                &inst.op,
-                &inst.params,
-                label,
-                duration,
-                unit,
-                condition,
-            )?;
-            func.call1((op,))?;
-        }
-        Ok(())
-    }
-
-    /// Invokes callable ``func`` with each instruction's operation.
-    ///
-    /// Args:
-    ///     func (Callable[[:class:`~.Operation`], None]):
-    ///         The callable to invoke.
-    #[cfg(feature = "cache_pygates")]
-    #[pyo3(signature = (func))]
-    pub fn foreach_op(&mut self, py: Python<'_>, func: &Bound<PyAny>) -> PyResult<()> {
-        for inst in self.data.iter_mut() {
-            let op = match &inst.py_op {
-                Some(op) => op.clone_ref(py),
-                None => {
-                    let label;
-                    let duration;
-                    let unit;
-                    let condition;
-                    match &inst.extra_attrs {
-                        Some(extra_attrs) => {
-                            label = &extra_attrs.label;
-                            duration = &extra_attrs.duration;
-                            unit = &extra_attrs.unit;
-                            condition = &extra_attrs.condition;
-                        }
-                        None => {
-                            label = &None;
-                            duration = &None;
-                            unit = &None;
-                            condition = &None;
-                        }
-                    }
-                    let new_op = operation_type_and_data_to_py(
-                        py,
-                        &inst.op,
-                        &inst.params,
-                        label,
-                        duration,
-                        unit,
-                        condition,
-                    )?;
-                    inst.py_op = Some(new_op.clone_ref(py));
-                    new_op
-                }
-            };
-            func.call1((op,))?;
+            func.call1((inst.unpack_py_op(py)?,))?;
         }
         Ok(())
     }
@@ -680,88 +580,10 @@ impl CircuitData {
     /// Args:
     ///     func (Callable[[int, :class:`~.Operation`], None]):
     ///         The callable to invoke.
-    #[cfg(not(feature = "cache_pygates"))]
     #[pyo3(signature = (func))]
     pub fn foreach_op_indexed(&self, py: Python<'_>, func: &Bound<PyAny>) -> PyResult<()> {
         for (index, inst) in self.data.iter().enumerate() {
-            let label;
-            let duration;
-            let unit;
-            let condition;
-            match &inst.extra_attrs {
-                Some(extra_attrs) => {
-                    label = &extra_attrs.label;
-                    duration = &extra_attrs.duration;
-                    unit = &extra_attrs.unit;
-                    condition = &extra_attrs.condition;
-                }
-                None => {
-                    label = &None;
-                    duration = &None;
-                    unit = &None;
-                    condition = &None;
-                }
-            }
-
-            let op = operation_type_and_data_to_py(
-                py,
-                &inst.op,
-                &inst.params,
-                label,
-                duration,
-                unit,
-                condition,
-            )?;
-            func.call1((index, op))?;
-        }
-        Ok(())
-    }
-
-    /// Invokes callable ``func`` with the positional index and operation
-    /// of each instruction.
-    ///
-    /// Args:
-    ///     func (Callable[[int, :class:`~.Operation`], None]):
-    ///         The callable to invoke.
-    #[cfg(feature = "cache_pygates")]
-    #[pyo3(signature = (func))]
-    pub fn foreach_op_indexed(&mut self, py: Python<'_>, func: &Bound<PyAny>) -> PyResult<()> {
-        for (index, inst) in self.data.iter_mut().enumerate() {
-            let op = match &inst.py_op {
-                Some(op) => op.clone_ref(py),
-                None => {
-                    let label;
-                    let duration;
-                    let unit;
-                    let condition;
-                    match &inst.extra_attrs {
-                        Some(extra_attrs) => {
-                            label = &extra_attrs.label;
-                            duration = &extra_attrs.duration;
-                            unit = &extra_attrs.unit;
-                            condition = &extra_attrs.condition;
-                        }
-                        None => {
-                            label = &None;
-                            duration = &None;
-                            unit = &None;
-                            condition = &None;
-                        }
-                    }
-                    let new_op = operation_type_and_data_to_py(
-                        py,
-                        &inst.op,
-                        &inst.params,
-                        label,
-                        duration,
-                        unit,
-                        condition,
-                    )?;
-                    inst.py_op = Some(new_op.clone_ref(py));
-                    new_op
-                }
-            };
-            func.call1((index, op))?;
+            func.call1((index, inst.unpack_py_op(py)?))?;
         }
         Ok(())
     }
@@ -779,49 +601,23 @@ impl CircuitData {
     ///     func (Callable[[:class:`~.Operation`], :class:`~.Operation`]):
     ///         A callable used to map original operation to their
     ///         replacements.
-    #[cfg(not(feature = "cache_pygates"))]
     #[pyo3(signature = (func))]
     pub fn map_ops(&mut self, py: Python<'_>, func: &Bound<PyAny>) -> PyResult<()> {
         for inst in self.data.iter_mut() {
-            let old_op = match &inst.op {
-                OperationType::Standard(op) => {
-                    let label;
-                    let duration;
-                    let unit;
-                    let condition;
-                    match &inst.extra_attrs {
-                        Some(extra_attrs) => {
-                            label = &extra_attrs.label;
-                            duration = &extra_attrs.duration;
-                            unit = &extra_attrs.unit;
-                            condition = &extra_attrs.condition;
-                        }
-                        None => {
-                            label = &None;
-                            duration = &None;
-                            unit = &None;
-                            condition = &None;
-                        }
-                    }
-                    if condition.is_some() {
-                        operation_type_and_data_to_py(
-                            py,
-                            &inst.op,
-                            &inst.params,
-                            label,
-                            duration,
-                            unit,
-                            condition,
-                        )?
-                    } else {
-                        op.into_py(py)
+            let py_op = {
+                if let OperationType::Standard(op) = inst.op {
+                    match inst.extra_attrs.as_deref() {
+                        None
+                        | Some(ExtraInstructionAttributes {
+                            condition: None, ..
+                        }) => op.into_py(py),
+                        _ => inst.unpack_py_op(py)?,
                     }
+                } else {
+                    inst.unpack_py_op(py)?
                 }
-                OperationType::Gate(op) => op.gate.clone_ref(py),
-                OperationType::Instruction(op) => op.instruction.clone_ref(py),
-                OperationType::Operation(op) => op.operation.clone_ref(py),
             };
-            let result: OperationInput = func.call1((old_op,))?.extract()?;
+            let result: OperationInput = func.call1((py_op,))?.extract()?;
             match result {
                 OperationInput::Standard(op) => {
                     inst.op = OperationType::Standard(op);
@@ -836,7 +632,7 @@ impl CircuitData {
                     inst.op = OperationType::Operation(op);
                 }
                 OperationInput::Object(new_op) => {
-                    let new_inst_details = convert_py_to_operation_type(py, new_op)?;
+                    let new_inst_details = convert_py_to_operation_type(py, new_op.clone_ref(py))?;
                     inst.op = new_inst_details.operation;
                     inst.params = new_inst_details.params;
                     if new_inst_details.label.is_some()
@@ -851,103 +647,10 @@ impl CircuitData {
                             condition: new_inst_details.condition,
                         }))
                     }
-                }
-            }
-        }
-        Ok(())
-    }
-
-    /// Invokes callable ``func`` with each instruction's operation,
-    /// replacing the operation with the result.
-    ///
-    /// .. note::
-    ///
-    ///     This is only to be used by map_vars() in quantumcircuit.py it
-    ///     assumes that a full Python instruction will only be returned from
-    ///     standard gates iff a condition is set.
-    ///
-    /// Args:
-    ///     func (Callable[[:class:`~.Operation`], :class:`~.Operation`]):
-    ///         A callable used to map original operation to their
-    ///         replacements.
-    #[cfg(feature = "cache_pygates")]
-    #[pyo3(signature = (func))]
-    pub fn map_ops(&mut self, py: Python<'_>, func: &Bound<PyAny>) -> PyResult<()> {
-        for inst in self.data.iter_mut() {
-            let old_op = match &inst.py_op {
-                Some(op) => op.clone_ref(py),
-                None => match &inst.op {
-                    OperationType::Standard(op) => {
-                        let label;
-                        let duration;
-                        let unit;
-                        let condition;
-                        match &inst.extra_attrs {
-                            Some(extra_attrs) => {
-                                label = &extra_attrs.label;
-                                duration = &extra_attrs.duration;
-                                unit = &extra_attrs.unit;
-                                condition = &extra_attrs.condition;
-                            }
-                            None => {
-                                label = &None;
-                                duration = &None;
-                                unit = &None;
-                                condition = &None;
-                            }
-                        }
-                        if condition.is_some() {
-                            let new_op = operation_type_and_data_to_py(
-                                py,
-                                &inst.op,
-                                &inst.params,
-                                label,
-                                duration,
-                                unit,
-                                condition,
-                            )?;
-                            inst.py_op = Some(new_op.clone_ref(py));
-                            new_op
-                        } else {
-                            op.into_py(py)
-                        }
-                    }
-                    OperationType::Gate(op) => op.gate.clone_ref(py),
-                    OperationType::Instruction(op) => op.instruction.clone_ref(py),
-                    OperationType::Operation(op) => op.operation.clone_ref(py),
-                },
-            };
-            let result: OperationInput = func.call1((old_op,))?.extract()?;
-            match result {
-                OperationInput::Standard(op) => {
-                    inst.op = OperationType::Standard(op);
-                }
-                OperationInput::Gate(op) => {
-                    inst.op = OperationType::Gate(op);
-                }
-                OperationInput::Instruction(op) => {
-                    inst.op = OperationType::Instruction(op);
-                }
-                OperationInput::Operation(op) => {
-                    inst.op = OperationType::Operation(op);
-                }
-                OperationInput::Object(new_op) => {
-                    let new_inst_details = convert_py_to_operation_type(py, new_op.clone_ref(py))?;
-                    inst.op = new_inst_details.operation;
-                    inst.params = new_inst_details.params;
-                    if new_inst_details.label.is_some()
-                        || new_inst_details.duration.is_some()
-                        || new_inst_details.unit.is_some()
-                        || new_inst_details.condition.is_some()
+                    #[cfg(feature = "cache_pygates")]
                     {
-                        inst.extra_attrs = Some(Box::new(ExtraInstructionAttributes {
-                            label: new_inst_details.label,
-                            duration: new_inst_details.duration,
-                            unit: new_inst_details.unit,
-                            condition: new_inst_details.condition,
-                        }))
+                        *inst.py_op.borrow_mut() = Some(new_op);
                     }
-                    inst.py_op = Some(new_op);
                 }
             }
         }
@@ -1537,7 +1240,7 @@ impl CircuitData {
             params: inst.params.clone(),
             extra_attrs: inst.extra_attrs.clone(),
             #[cfg(feature = "cache_pygates")]
-            py_op: inst.py_op.clone(),
+            py_op: RefCell::new(inst.py_op.clone()),
         })
     }
 
@@ -1557,7 +1260,7 @@ impl CircuitData {
             params: inst.params.clone(),
             extra_attrs: inst.extra_attrs.clone(),
             #[cfg(feature = "cache_pygates")]
-            py_op: inst.py_op.clone(),
+            py_op: RefCell::new(inst.py_op.clone()),
         })
     }
 }
diff --git a/crates/circuit/src/circuit_instruction.rs b/crates/circuit/src/circuit_instruction.rs
index f95bdb0981b4..16545394a95f 100644
--- a/crates/circuit/src/circuit_instruction.rs
+++ b/crates/circuit/src/circuit_instruction.rs
@@ -10,8 +10,11 @@
 // 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::RefCell;
+
 use pyo3::basic::CompareOp;
-use pyo3::exceptions::PyValueError;
+use pyo3::exceptions::{PyDeprecationWarning, PyValueError};
 use pyo3::prelude::*;
 use pyo3::types::{IntoPyDict, PyList, PyTuple, PyType};
 use pyo3::{intern, IntoPy, PyObject, PyResult};
@@ -19,7 +22,7 @@ use smallvec::{smallvec, SmallVec};
 
 use crate::imports::{
     get_std_gate_class, populate_std_gate_map, GATE, INSTRUCTION, OPERATION,
-    SINGLETON_CONTROLLED_GATE, SINGLETON_GATE,
+    SINGLETON_CONTROLLED_GATE, SINGLETON_GATE, WARNINGS_WARN,
 };
 use crate::interner::Index;
 use crate::operations::{OperationType, Param, PyGate, PyInstruction, PyOperation, StandardGate};
@@ -47,8 +50,61 @@ pub(crate) struct PackedInstruction {
     pub clbits_id: Index,
     pub params: SmallVec<[Param; 3]>,
     pub extra_attrs: Option<Box<ExtraInstructionAttributes>>,
+
     #[cfg(feature = "cache_pygates")]
-    pub py_op: Option<PyObject>,
+    /// This is hidden in a `RefCell` because, while that has additional memory-usage implications
+    /// while we're still building with the feature enabled, we intend to remove the feature in the
+    /// future, and hiding the cache within a `RefCell` lets us keep the cache transparently in our
+    /// interfaces, without needing various functions to unnecessarily take `&mut` references.
+    pub py_op: RefCell<Option<PyObject>>,
+}
+
+impl PackedInstruction {
+    /// 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.
+    ///
+    /// A standard-gate operation object returned by this function is disconnected from the
+    /// containing circuit; updates to its label, duration, unit and condition will not be
+    /// propagated back.
+    pub fn unpack_py_op(&self, py: Python) -> PyResult<Py<PyAny>> {
+        #[cfg(feature = "cache_pygates")]
+        {
+            if let Some(cached_op) = self.py_op.borrow().as_ref() {
+                return Ok(cached_op.clone_ref(py));
+            }
+        }
+        let (label, duration, unit, condition) = match self.extra_attrs.as_deref() {
+            Some(ExtraInstructionAttributes {
+                label,
+                duration,
+                unit,
+                condition,
+            }) => (
+                label.as_deref(),
+                duration.as_ref(),
+                unit.as_deref(),
+                condition.as_ref(),
+            ),
+            None => (None, None, None, None),
+        };
+        let out = operation_type_and_data_to_py(
+            py,
+            &self.op,
+            &self.params,
+            label,
+            duration,
+            unit,
+            condition,
+        )?;
+        #[cfg(feature = "cache_pygates")]
+        {
+            if let Ok(mut cell) = self.py_op.try_borrow_mut() {
+                cell.get_or_insert_with(|| out.clone_ref(py));
+            }
+        }
+        Ok(out)
+    }
 }
 
 /// A single instruction in a :class:`.QuantumCircuit`, comprised of the :attr:`operation` and
@@ -486,7 +542,11 @@ impl CircuitInstruction {
 
         Ok(PyTuple::new_bound(
             py,
-            [op, self.qubits.to_object(py), self.clbits.to_object(py)],
+            [
+                op,
+                self.qubits.bind(py).to_list().into(),
+                self.clbits.bind(py).to_list().into(),
+            ],
         ))
     }
 
@@ -502,32 +562,41 @@ impl CircuitInstruction {
         };
         Ok(PyTuple::new_bound(
             py,
-            [op, self.qubits.to_object(py), self.clbits.to_object(py)],
+            [
+                op,
+                self.qubits.bind(py).to_list().into(),
+                self.clbits.bind(py).to_list().into(),
+            ],
         ))
     }
 
     #[cfg(not(feature = "cache_pygates"))]
     pub fn __getitem__(&self, py: Python<'_>, key: &Bound<PyAny>) -> PyResult<PyObject> {
+        warn_on_legacy_circuit_instruction_iteration(py)?;
         Ok(self._legacy_format(py)?.as_any().get_item(key)?.into_py(py))
     }
 
     #[cfg(feature = "cache_pygates")]
     pub fn __getitem__(&mut self, py: Python<'_>, key: &Bound<PyAny>) -> PyResult<PyObject> {
+        warn_on_legacy_circuit_instruction_iteration(py)?;
         Ok(self._legacy_format(py)?.as_any().get_item(key)?.into_py(py))
     }
 
     #[cfg(not(feature = "cache_pygates"))]
     pub fn __iter__(&self, py: Python<'_>) -> PyResult<PyObject> {
+        warn_on_legacy_circuit_instruction_iteration(py)?;
         Ok(self._legacy_format(py)?.as_any().iter()?.into_py(py))
     }
 
     #[cfg(feature = "cache_pygates")]
     pub fn __iter__(&mut self, py: Python<'_>) -> PyResult<PyObject> {
+        warn_on_legacy_circuit_instruction_iteration(py)?;
         Ok(self._legacy_format(py)?.as_any().iter()?.into_py(py))
     }
 
-    pub fn __len__(&self) -> usize {
-        3
+    pub fn __len__(&self, py: Python) -> PyResult<usize> {
+        warn_on_legacy_circuit_instruction_iteration(py)?;
+        Ok(3)
     }
 
     pub fn __richcmp__(
@@ -663,20 +732,20 @@ pub fn operation_type_to_py(py: Python, circuit_inst: &CircuitInstruction) -> Py
     let (label, duration, unit, condition) = match &circuit_inst.extra_attrs {
         None => (None, None, None, None),
         Some(extra_attrs) => (
-            extra_attrs.label.clone(),
-            extra_attrs.duration.clone(),
-            extra_attrs.unit.clone(),
-            extra_attrs.condition.clone(),
+            extra_attrs.label.as_deref(),
+            extra_attrs.duration.as_ref(),
+            extra_attrs.unit.as_deref(),
+            extra_attrs.condition.as_ref(),
         ),
     };
     operation_type_and_data_to_py(
         py,
         &circuit_inst.operation,
         &circuit_inst.params,
-        &label,
-        &duration,
-        &unit,
-        &condition,
+        label,
+        duration,
+        unit,
+        condition,
     )
 }
 
@@ -689,10 +758,10 @@ pub fn operation_type_and_data_to_py(
     py: Python,
     operation: &OperationType,
     params: &[Param],
-    label: &Option<String>,
-    duration: &Option<PyObject>,
-    unit: &Option<String>,
-    condition: &Option<PyObject>,
+    label: Option<&str>,
+    duration: Option<&PyObject>,
+    unit: Option<&str>,
+    condition: Option<&PyObject>,
 ) -> PyResult<PyObject> {
     match &operation {
         OperationType::Standard(op) => {
@@ -872,3 +941,29 @@ pub fn convert_py_to_operation_type(
     }
     Err(PyValueError::new_err(format!("Invalid input: {}", py_op)))
 }
+
+/// Issue a Python `DeprecationWarning` about using the legacy tuple-like interface to
+/// `CircuitInstruction`.
+///
+/// Beware the `stacklevel` here doesn't work quite the same way as it does in Python as Rust-space
+/// calls are completely transparent to Python.
+#[inline]
+fn warn_on_legacy_circuit_instruction_iteration(py: Python) -> PyResult<()> {
+    WARNINGS_WARN
+        .get_bound(py)
+        .call1((
+            intern!(
+                py,
+                concat!(
+                    "Treating CircuitInstruction as an iterable is deprecated legacy behavior",
+                    " since Qiskit 1.2, and will be removed in Qiskit 2.0.",
+                    " Instead, use the `operation`, `qubits` and `clbits` named attributes."
+                )
+            ),
+            py.get_type_bound::<PyDeprecationWarning>(),
+            // Stack level.  Compared to Python-space calls to `warn`, this is unusually low
+            // beacuse all our internal call structure is now Rust-space and invisible to Python.
+            1,
+        ))
+        .map(|_| ())
+}
diff --git a/crates/circuit/src/gate_matrix.rs b/crates/circuit/src/gate_matrix.rs
index ad8c918e73bc..2e5f55d6ddcb 100644
--- a/crates/circuit/src/gate_matrix.rs
+++ b/crates/circuit/src/gate_matrix.rs
@@ -212,6 +212,7 @@ pub static ISWAP_GATE: [[Complex64; 4]; 4] = [
 ];
 
 pub static S_GATE: [[Complex64; 2]; 2] = [[c64(1., 0.), c64(0., 0.)], [c64(0., 0.), c64(0., 1.)]];
+
 pub static SDG_GATE: [[Complex64; 2]; 2] =
     [[c64(1., 0.), c64(0., 0.)], [c64(0., 0.), c64(0., -1.)]];
 
@@ -219,6 +220,7 @@ pub static T_GATE: [[Complex64; 2]; 2] = [
     [c64(1., 0.), c64(0., 0.)],
     [c64(0., 0.), c64(FRAC_1_SQRT_2, FRAC_1_SQRT_2)],
 ];
+
 pub static TDG_GATE: [[Complex64; 2]; 2] = [
     [c64(1., 0.), c64(0., 0.)],
     [c64(0., 0.), c64(FRAC_1_SQRT_2, -FRAC_1_SQRT_2)],
@@ -246,3 +248,79 @@ pub fn u_gate(theta: f64, phi: f64, lam: f64) -> [[Complex64; 2]; 2] {
         [c64(0., phi).exp() * sin, c64(0., phi + lam).exp() * cos],
     ]
 }
+
+#[inline]
+pub fn xx_minus_yy_gate(theta: f64, beta: f64) -> [[Complex64; 4]; 4] {
+    let cos = (theta / 2.).cos();
+    let sin = (theta / 2.).sin();
+    [
+        [
+            c64(cos, 0.),
+            c64(0., 0.),
+            c64(0., 0.),
+            c64(0., -sin) * c64(0., -beta).exp(),
+        ],
+        [c64(0., 0.), c64(1., 0.), c64(0., 0.), c64(0., 0.)],
+        [c64(0., 0.), c64(0., 0.), c64(1., 0.), c64(0., 0.)],
+        [
+            c64(0., -sin) * c64(0., beta).exp(),
+            c64(0., 0.),
+            c64(0., 0.),
+            c64(cos, 0.),
+        ],
+    ]
+}
+
+#[inline]
+pub fn u1_gate(lam: f64) -> [[Complex64; 2]; 2] {
+    [
+        [c64(1., 0.), c64(0., 0.)],
+        [c64(0., 0.), c64(0., lam).exp()],
+    ]
+}
+
+#[inline]
+pub fn u2_gate(phi: f64, lam: f64) -> [[Complex64; 2]; 2] {
+    [
+        [
+            c64(FRAC_1_SQRT_2, 0.),
+            (-c64(0., lam).exp()) * FRAC_1_SQRT_2,
+        ],
+        [
+            c64(0., phi).exp() * FRAC_1_SQRT_2,
+            c64(0., phi + lam).exp() * FRAC_1_SQRT_2,
+        ],
+    ]
+}
+
+#[inline]
+pub fn u3_gate(theta: f64, phi: f64, lam: f64) -> [[Complex64; 2]; 2] {
+    let cos = (theta / 2.).cos();
+    let sin = (theta / 2.).sin();
+    [
+        [c64(cos, 0.), -(c64(0., lam).exp()) * sin],
+        [c64(0., phi).exp() * sin, c64(0., phi + lam).exp() * cos],
+    ]
+}
+
+#[inline]
+pub fn xx_plus_yy_gate(theta: f64, beta: f64) -> [[Complex64; 4]; 4] {
+    let cos = (theta / 2.).cos();
+    let sin = (theta / 2.).sin();
+    [
+        [c64(1., 0.), c64(0., 0.), c64(0., 0.), c64(0., 0.)],
+        [
+            c64(0., 0.),
+            c64(cos, 0.),
+            c64(0., -sin) * c64(0., -beta).exp(),
+            c64(0., 0.),
+        ],
+        [
+            c64(0., 0.),
+            c64(0., -sin) * c64(0., beta).exp(),
+            c64(cos, 0.),
+            c64(0., 0.),
+        ],
+        [c64(0., 0.), c64(0., 0.), c64(0., 0.), c64(1., 0.)],
+    ]
+}
diff --git a/crates/circuit/src/imports.rs b/crates/circuit/src/imports.rs
index 8db3b88fd7d2..92700f3274e7 100644
--- a/crates/circuit/src/imports.rs
+++ b/crates/circuit/src/imports.rs
@@ -72,6 +72,8 @@ pub static SINGLETON_GATE: ImportOnceCell =
 pub static SINGLETON_CONTROLLED_GATE: ImportOnceCell =
     ImportOnceCell::new("qiskit.circuit.singleton", "SingletonControlledGate");
 
+pub static WARNINGS_WARN: ImportOnceCell = ImportOnceCell::new("warnings", "warn");
+
 /// 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
 /// when a gate is added directly via the StandardGate path and there isn't a Python object
@@ -79,6 +81,7 @@ pub static SINGLETON_CONTROLLED_GATE: ImportOnceCell =
 ///
 /// NOTE: the order here is significant, the StandardGate variant's number must match
 /// index of it's entry in this table. This is all done statically for performance
+// TODO: replace placeholders with actual implementation
 static STDGATE_IMPORT_PATHS: [[&str; 2]; STANDARD_GATE_SIZE] = [
     // ZGate = 0
     ["qiskit.circuit.library.standard_gates.z", "ZGate"],
@@ -124,13 +127,77 @@ static STDGATE_IMPORT_PATHS: [[&str; 2]; STANDARD_GATE_SIZE] = [
     // SdgGate = 19
     ["qiskit.circuit.library.standard_gates.s", "SdgGate"],
     // TGate = 20
-    ["qiskit.circuit.library.standard_gates.s", "TGate"],
+    ["qiskit.circuit.library.standard_gates.t", "TGate"],
     // TdgGate = 21
-    ["qiskit.circuit.library.standard_gates.s", "TdgGate"],
+    ["qiskit.circuit.library.standard_gates.t", "TdgGate"],
     // SXdgGate = 22
     ["qiskit.circuit.library.standard_gates.sx", "SXdgGate"],
     // iSWAPGate = 23
     ["qiskit.circuit.library.standard_gates.iswap", "iSwapGate"],
+    // XXMinusYYGate = 24
+    [
+        "qiskit.circuit.library.standard_gates.xx_minus_yy",
+        "XXMinusYYGate",
+    ],
+    // XXPlusYYGate = 25
+    [
+        "qiskit.circuit.library.standard_gates.xx_plus_yy",
+        "XXPlusYYGate",
+    ],
+    // U1Gate = 26
+    ["qiskit.circuit.library.standard_gates.u1", "U1Gate"],
+    // U2Gate = 27
+    ["qiskit.circuit.library.standard_gates.u2", "U2Gate"],
+    // U3Gate = 28
+    ["qiskit.circuit.library.standard_gates.u3", "U3Gate"],
+    // CRXGate = 29
+    ["placeholder", "placeholder"],
+    // CRYGate = 30
+    ["placeholder", "placeholder"],
+    // CRZGate = 31
+    ["placeholder", "placeholder"],
+    // RGate 32
+    ["placeholder", "placeholder"],
+    // CHGate = 33
+    ["qiskit.circuit.library.standard_gates.h", "CHGate"],
+    // CPhaseGate = 34
+    ["qiskit.circuit.library.standard_gates.p", "CPhaseGate"],
+    // CSGate = 35
+    ["qiskit.circuit.library.standard_gates.s", "CSGate"],
+    // CSdgGate = 36
+    ["qiskit.circuit.library.standard_gates.s", "CSdgGate"],
+    // CSXGate = 37
+    ["qiskit.circuit.library.standard_gates.sx", "CSXGate"],
+    // CSwapGate = 38
+    ["qiskit.circuit.library.standard_gates.swap", "CSwapGate"],
+    // CUGate = 39
+    ["qiskit.circuit.library.standard_gates.u", "CUGate"],
+    // CU1Gate = 40
+    ["qiskit.circuit.library.standard_gates.u1", "CU1Gate"],
+    // CU3Gate = 41
+    ["qiskit.circuit.library.standard_gates.u3", "CU3Gate"],
+    // C3XGate = 42
+    ["placeholder", "placeholder"],
+    // C3SXGate = 43
+    ["placeholder", "placeholder"],
+    // C4XGate = 44
+    ["placeholder", "placeholder"],
+    // DCXGate = 45
+    ["placeholder", "placeholder"],
+    // CCZGate = 46
+    ["placeholder", "placeholder"],
+    // RCCXGate = 47
+    ["placeholder", "placeholder"],
+    // RC3XGate = 48
+    ["placeholder", "placeholder"],
+    // RXXGate = 49
+    ["placeholder", "placeholder"],
+    // RYYGate = 50
+    ["placeholder", "placeholder"],
+    // RZZGate = 51
+    ["placeholder", "placeholder"],
+    // RZXGate = 52
+    ["placeholder", "placeholder"],
 ];
 
 /// A mapping from the enum variant in crate::operations::StandardGate to the python object for the
diff --git a/crates/circuit/src/operations.rs b/crates/circuit/src/operations.rs
index 7a6484786918..ad7627430ef8 100644
--- a/crates/circuit/src/operations.rs
+++ b/crates/circuit/src/operations.rs
@@ -240,41 +240,111 @@ pub enum StandardGate {
     TdgGate = 21,
     SXdgGate = 22,
     ISwapGate = 23,
+    XXMinusYYGate = 24,
+    XXPlusYYGate = 25,
+    U1Gate = 26,
+    U2Gate = 27,
+    U3Gate = 28,
+    CRXGate = 29,
+    CRYGate = 30,
+    CRZGate = 31,
+    RGate = 32,
+    CHGate = 33,
+    CPhaseGate = 34,
+    CSGate = 35,
+    CSdgGate = 36,
+    CSXGate = 37,
+    CSwapGate = 38,
+    CUGate = 39,
+    CU1Gate = 40,
+    CU3Gate = 41,
+    C3XGate = 42,
+    C3SXGate = 43,
+    C4XGate = 44,
+    DCXGate = 45,
+    CCZGate = 46,
+    RCCXGate = 47,
+    RC3XGate = 48,
+    RXXGate = 49,
+    RYYGate = 50,
+    RZZGate = 51,
+    RZXGate = 52,
 }
 
+// TODO: replace all 34s (placeholders) with actual number
 static STANDARD_GATE_NUM_QUBITS: [u32; STANDARD_GATE_SIZE] = [
-    1, 1, 1, 2, 2, 2, 3, 1, 1, 1, 2, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
+    1, 1, 1, 2, 2, 2, 3, 1, 1, 1, // 0-9
+    2, 2, 1, 0, 1, 1, 1, 1, 1, 1, // 10-19
+    1, 1, 1, 2, 2, 2, 1, 1, 1, 34, // 20-29
+    34, 34, 34, 2, 2, 2, 2, 2, 3, 2, // 30-39
+    2, 2, 34, 34, 34, 34, 34, 34, 34, 34, // 40-49
+    34, 34, 34, // 50-52
 ];
 
+// TODO: replace all 34s (placeholders) with actual number
 static STANDARD_GATE_NUM_PARAMS: [u32; STANDARD_GATE_SIZE] = [
-    0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 3, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 1, 1, 1, // 0-9
+    0, 0, 0, 1, 0, 0, 1, 3, 0, 0, // 10-19
+    0, 0, 0, 0, 2, 2, 1, 2, 3, 34, // 20-29
+    34, 34, 34, 0, 1, 0, 0, 0, 0, 3, // 30-39
+    1, 3, 34, 34, 34, 34, 34, 34, 34, 34, // 40-49
+    34, 34, 34, // 50-52
 ];
 
 static STANDARD_GATE_NAME: [&str; STANDARD_GATE_SIZE] = [
-    "z",
-    "y",
-    "x",
-    "cz",
-    "cy",
-    "cx",
-    "ccx",
-    "rx",
-    "ry",
-    "rz",
-    "ecr",
-    "swap",
-    "sx",
-    "global_phase",
-    "id",
-    "h",
-    "p",
-    "u",
-    "s",
-    "sdg",
-    "t",
-    "tdg",
-    "sxdg",
-    "iswap",
+    "z",            // 0
+    "y",            // 1
+    "x",            // 2
+    "cz",           // 3
+    "cy",           // 4
+    "cx",           // 5
+    "ccx",          // 6
+    "rx",           // 7
+    "ry",           // 8
+    "rz",           // 9
+    "ecr",          // 10
+    "swap",         // 11
+    "sx",           // 12
+    "global_phase", // 13
+    "id",           // 14
+    "h",            // 15
+    "p",            // 16
+    "u",            // 17
+    "s",            // 18
+    "sdg",          // 19
+    "t",            // 20
+    "tdg",          // 21
+    "sxdg",         // 22
+    "iswap",        // 23
+    "xx_minus_yy",  // 24
+    "xx_plus_yy",   // 25
+    "u1",           // 26
+    "u2",           // 27
+    "u3",           // 28
+    "crx",          // 29
+    "cry",          // 30
+    "crz",          // 31
+    "r",            // 32
+    "ch",           // 33
+    "cp",           // 34
+    "cs",           // 35
+    "csdg",         // 36
+    "csx",          // 37
+    "cswap",        // 38
+    "cu",           // 39
+    "cu1",          // 40
+    "cu3",          // 41
+    "c3x",          // 42
+    "c3sx",         // 43
+    "c4x",          // 44
+    "dcx",          // 45
+    "ccz",          // 46
+    "rccx",         // 47
+    "rc3x",         // 48
+    "rxx",          // 49
+    "ryy",          // 50
+    "rzz",          // 51
+    "rzx",          // 52
 ];
 
 #[pymethods]
@@ -323,8 +393,7 @@ impl StandardGate {
 //
 // Remove this when std::mem::variant_count() is stabilized (see
 // https://github.com/rust-lang/rust/issues/73662 )
-
-pub const STANDARD_GATE_SIZE: usize = 24;
+pub const STANDARD_GATE_SIZE: usize = 53;
 
 impl Operation for StandardGate {
     fn name(&self) -> &str {
@@ -453,6 +522,49 @@ impl Operation for StandardGate {
                 [] => Some(aview2(&gate_matrix::ISWAP_GATE).to_owned()),
                 _ => None,
             },
+            Self::XXMinusYYGate => match params {
+                [Param::Float(theta), Param::Float(beta)] => {
+                    Some(aview2(&gate_matrix::xx_minus_yy_gate(*theta, *beta)).to_owned())
+                }
+                _ => None,
+            },
+            Self::XXPlusYYGate => match params {
+                [Param::Float(theta), Param::Float(beta)] => {
+                    Some(aview2(&gate_matrix::xx_plus_yy_gate(*theta, *beta)).to_owned())
+                }
+                _ => None,
+            },
+            Self::U1Gate => match params[0] {
+                Param::Float(val) => Some(aview2(&gate_matrix::u1_gate(val)).to_owned()),
+                _ => None,
+            },
+            Self::U2Gate => match params {
+                [Param::Float(phi), Param::Float(lam)] => {
+                    Some(aview2(&gate_matrix::u2_gate(*phi, *lam)).to_owned())
+                }
+                _ => None,
+            },
+            Self::U3Gate => match params {
+                [Param::Float(theta), Param::Float(phi), Param::Float(lam)] => {
+                    Some(aview2(&gate_matrix::u3_gate(*theta, *phi, *lam)).to_owned())
+                }
+                _ => None,
+            },
+            Self::CRXGate | Self::CRYGate | Self::CRZGate => todo!(),
+            Self::RGate => todo!(),
+            Self::CHGate => todo!(),
+            Self::CPhaseGate => todo!(),
+            Self::CSGate => todo!(),
+            Self::CSdgGate => todo!(),
+            Self::CSXGate => todo!(),
+            Self::CSwapGate => todo!(),
+            Self::CUGate | Self::CU1Gate | Self::CU3Gate => todo!(),
+            Self::C3XGate | Self::C3SXGate | Self::C4XGate => todo!(),
+            Self::DCXGate => todo!(),
+            Self::CCZGate => todo!(),
+            Self::RCCXGate | Self::RC3XGate => todo!(),
+            Self::RXXGate | Self::RYYGate | Self::RZZGate => todo!(),
+            Self::RZXGate => todo!(),
         }
     }
 
@@ -539,6 +651,7 @@ impl Operation for StandardGate {
             }),
             Self::CXGate => None,
             Self::CCXGate => Python::with_gil(|py| -> Option<CircuitData> {
+                let q0 = smallvec![Qubit(0)];
                 let q1 = smallvec![Qubit(1)];
                 let q2 = smallvec![Qubit(2)];
                 let q0_1 = smallvec![Qubit(0), Qubit(1)];
@@ -561,7 +674,7 @@ impl Operation for StandardGate {
                             (Self::TGate, smallvec![], q2.clone()),
                             (Self::HGate, smallvec![], q2),
                             (Self::CXGate, smallvec![], q0_1.clone()),
-                            (Self::TGate, smallvec![], smallvec![Qubit(0)]),
+                            (Self::TGate, smallvec![], q0),
                             (Self::TdgGate, smallvec![], q1),
                             (Self::CXGate, smallvec![], q0_1),
                         ],
@@ -573,39 +686,20 @@ impl Operation for StandardGate {
             Self::RXGate => todo!("Add when we have R"),
             Self::RYGate => todo!("Add when we have R"),
             Self::RZGate => Python::with_gil(|py| -> Option<CircuitData> {
-                match &params[0] {
-                    Param::Float(theta) => Some(
-                        CircuitData::from_standard_gates(
-                            py,
-                            1,
-                            [(
-                                Self::PhaseGate,
-                                smallvec![Param::Float(*theta)],
-                                smallvec![Qubit(0)],
-                            )],
-                            Param::Float(-0.5 * theta),
-                        )
-                        .expect("Unexpected Qiskit python bug"),
-                    ),
-                    Param::ParameterExpression(theta) => Some(
-                        CircuitData::from_standard_gates(
-                            py,
-                            1,
-                            [(
-                                Self::PhaseGate,
-                                smallvec![Param::ParameterExpression(theta.clone_ref(py))],
-                                smallvec![Qubit(0)],
-                            )],
-                            Param::ParameterExpression(
-                                theta
-                                    .call_method1(py, intern!(py, "__rmul__"), (-0.5,))
-                                    .expect("Parameter expression for global phase failed"),
-                            ),
-                        )
-                        .expect("Unexpected Qiskit python bug"),
-                    ),
-                    Param::Obj(_) => unreachable!(),
-                }
+                let theta = &params[0];
+                Some(
+                    CircuitData::from_standard_gates(
+                        py,
+                        1,
+                        [(
+                            Self::PhaseGate,
+                            smallvec![theta.clone()],
+                            smallvec![Qubit(0)],
+                        )],
+                        multiply_param(theta, -0.5, py),
+                    )
+                    .expect("Unexpected Qiskit python bug"),
+                )
             }),
             Self::ECRGate => todo!("Add when we have RZX"),
             Self::SwapGate => Python::with_gil(|py| -> Option<CircuitData> {
@@ -706,6 +800,21 @@ impl Operation for StandardGate {
                     .expect("Unexpected Qiskit python bug"),
                 )
             }),
+            Self::U1Gate => Python::with_gil(|py| -> Option<CircuitData> {
+                Some(
+                    CircuitData::from_standard_gates(
+                        py,
+                        1,
+                        [(
+                            Self::PhaseGate,
+                            params.iter().cloned().collect(),
+                            smallvec![Qubit(0)],
+                        )],
+                        FLOAT_ZERO,
+                    )
+                    .expect("Unexpected Qiskit python bug"),
+                )
+            }),
             Self::SdgGate => Python::with_gil(|py| -> Option<CircuitData> {
                 Some(
                     CircuitData::from_standard_gates(
@@ -721,6 +830,21 @@ impl Operation for StandardGate {
                     .expect("Unexpected Qiskit python bug"),
                 )
             }),
+            Self::U2Gate => Python::with_gil(|py| -> Option<CircuitData> {
+                Some(
+                    CircuitData::from_standard_gates(
+                        py,
+                        1,
+                        [(
+                            Self::UGate,
+                            smallvec![Param::Float(PI / 2.), params[0].clone(), params[1].clone()],
+                            smallvec![Qubit(0)],
+                        )],
+                        FLOAT_ZERO,
+                    )
+                    .expect("Unexpected Qiskit python bug"),
+                )
+            }),
             Self::TGate => Python::with_gil(|py| -> Option<CircuitData> {
                 Some(
                     CircuitData::from_standard_gates(
@@ -736,6 +860,21 @@ impl Operation for StandardGate {
                     .expect("Unexpected Qiskit python bug"),
                 )
             }),
+            Self::U3Gate => Python::with_gil(|py| -> Option<CircuitData> {
+                Some(
+                    CircuitData::from_standard_gates(
+                        py,
+                        1,
+                        [(
+                            Self::UGate,
+                            params.iter().cloned().collect(),
+                            smallvec![Qubit(0)],
+                        )],
+                        FLOAT_ZERO,
+                    )
+                    .expect("Unexpected Qiskit python bug"),
+                )
+            }),
             Self::TdgGate => Python::with_gil(|py| -> Option<CircuitData> {
                 Some(
                     CircuitData::from_standard_gates(
@@ -769,6 +908,105 @@ impl Operation for StandardGate {
                     .expect("Unexpected Qiskit python bug"),
                 )
             }),
+            Self::XXMinusYYGate => Python::with_gil(|py| -> Option<CircuitData> {
+                let q0 = smallvec![Qubit(0)];
+                let q1 = smallvec![Qubit(1)];
+                let q0_1 = smallvec![Qubit(0), Qubit(1)];
+                let theta = &params[0];
+                let beta = &params[1];
+                Some(
+                    CircuitData::from_standard_gates(
+                        py,
+                        2,
+                        [
+                            (
+                                Self::RZGate,
+                                smallvec![multiply_param(beta, -1.0, py)],
+                                q1.clone(),
+                            ),
+                            (Self::RZGate, smallvec![Param::Float(-PI2)], q0.clone()),
+                            (Self::SXGate, smallvec![], q0.clone()),
+                            (Self::RZGate, smallvec![Param::Float(PI2)], q0.clone()),
+                            (Self::SGate, smallvec![], q1.clone()),
+                            (Self::CXGate, smallvec![], q0_1.clone()),
+                            (
+                                Self::RYGate,
+                                smallvec![multiply_param(theta, 0.5, py)],
+                                q0.clone(),
+                            ),
+                            (
+                                Self::RYGate,
+                                smallvec![multiply_param(theta, -0.5, py)],
+                                q1.clone(),
+                            ),
+                            (Self::CXGate, smallvec![], q0_1),
+                            (Self::SdgGate, smallvec![], q1.clone()),
+                            (Self::RZGate, smallvec![Param::Float(-PI2)], q0.clone()),
+                            (Self::SXdgGate, smallvec![], q0.clone()),
+                            (Self::RZGate, smallvec![Param::Float(PI2)], q0),
+                            (Self::RZGate, smallvec![beta.clone()], q1),
+                        ],
+                        FLOAT_ZERO,
+                    )
+                    .expect("Unexpected Qiskit python bug"),
+                )
+            }),
+            Self::XXPlusYYGate => Python::with_gil(|py| -> Option<CircuitData> {
+                let q0 = smallvec![Qubit(0)];
+                let q1 = smallvec![Qubit(1)];
+                let q1_0 = smallvec![Qubit(1), Qubit(0)];
+                let theta = &params[0];
+                let beta = &params[1];
+                Some(
+                    CircuitData::from_standard_gates(
+                        py,
+                        2,
+                        [
+                            (Self::RZGate, smallvec![beta.clone()], q0.clone()),
+                            (Self::RZGate, smallvec![Param::Float(-PI2)], q1.clone()),
+                            (Self::SXGate, smallvec![], q1.clone()),
+                            (Self::RZGate, smallvec![Param::Float(PI2)], q1.clone()),
+                            (Self::SGate, smallvec![], q0.clone()),
+                            (Self::CXGate, smallvec![], q1_0.clone()),
+                            (
+                                Self::RYGate,
+                                smallvec![multiply_param(theta, -0.5, py)],
+                                q1.clone(),
+                            ),
+                            (
+                                Self::RYGate,
+                                smallvec![multiply_param(theta, -0.5, py)],
+                                q0.clone(),
+                            ),
+                            (Self::CXGate, smallvec![], q1_0),
+                            (Self::SdgGate, smallvec![], q0.clone()),
+                            (Self::RZGate, smallvec![Param::Float(-PI2)], q1.clone()),
+                            (Self::SXdgGate, smallvec![], q1.clone()),
+                            (Self::RZGate, smallvec![Param::Float(PI2)], q1),
+                            (Self::RZGate, smallvec![multiply_param(beta, -1.0, py)], q0),
+                        ],
+                        FLOAT_ZERO,
+                    )
+                    .expect("Unexpected Qiskit python bug"),
+                )
+            }),
+            Self::CRXGate | Self::CRYGate | Self::CRZGate => todo!(),
+            Self::RGate => todo!(),
+            Self::CHGate => todo!(),
+            Self::CPhaseGate => todo!(),
+            Self::CSGate => todo!(),
+            Self::CSdgGate => todo!(),
+            Self::CSXGate => todo!(),
+            Self::CSwapGate => todo!(),
+            Self::CUGate => todo!(),
+            Self::CU1Gate => todo!(),
+            Self::CU3Gate => todo!(),
+            Self::C3XGate | Self::C3SXGate | Self::C4XGate => todo!(),
+            Self::DCXGate => todo!(),
+            Self::CCZGate => todo!(),
+            Self::RCCXGate | Self::RC3XGate => todo!(),
+            Self::RXXGate | Self::RYYGate | Self::RZZGate => todo!(),
+            Self::RZXGate => todo!(),
         }
     }
 
@@ -779,6 +1017,19 @@ impl Operation for StandardGate {
 
 const FLOAT_ZERO: Param = Param::Float(0.0);
 
+fn multiply_param(param: &Param, mult: f64, py: Python) -> Param {
+    match param {
+        Param::Float(theta) => Param::Float(*theta * mult),
+        Param::ParameterExpression(theta) => Param::ParameterExpression(
+            theta
+                .clone_ref(py)
+                .call_method1(py, intern!(py, "__rmul__"), (mult,))
+                .expect("Parameter expression for global phase failed"),
+        ),
+        Param::Obj(_) => unreachable!(),
+    }
+}
+
 /// This class is used to wrap a Python side Instruction that is not in the standard library
 #[derive(Clone, Debug)]
 #[pyclass(freelist = 20, module = "qiskit._accelerate.circuit")]
diff --git a/crates/pyext/src/lib.rs b/crates/pyext/src/lib.rs
index 6623aa7f3129..6af99ff04a8d 100644
--- a/crates/pyext/src/lib.rs
+++ b/crates/pyext/src/lib.rs
@@ -17,11 +17,10 @@ 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, permutation::permutation, results::results, sabre::sabre,
-    sampled_exp_val::sampled_exp_val, sparse_pauli_op::sparse_pauli_op,
-    stochastic_swap::stochastic_swap, target_transpiler::target,
-    two_qubit_decompose::two_qubit_decompose, uc_gate::uc_gate, utils::utils,
-    vf2_layout::vf2_layout,
+    pauli_exp_val::pauli_expval, results::results, sabre::sabre, sampled_exp_val::sampled_exp_val,
+    sparse_pauli_op::sparse_pauli_op, 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,
 };
 
 #[pymodule]
@@ -37,7 +36,7 @@ fn _accelerate(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pymodule!(nlayout))?;
     m.add_wrapped(wrap_pymodule!(optimize_1q_gates))?;
     m.add_wrapped(wrap_pymodule!(pauli_expval))?;
-    m.add_wrapped(wrap_pymodule!(permutation))?;
+    m.add_wrapped(wrap_pymodule!(synthesis))?;
     m.add_wrapped(wrap_pymodule!(results))?;
     m.add_wrapped(wrap_pymodule!(sabre))?;
     m.add_wrapped(wrap_pymodule!(sampled_exp_val))?;
diff --git a/qiskit/__init__.py b/qiskit/__init__.py
index 766386dc7daf..b36bb4c468c1 100644
--- a/qiskit/__init__.py
+++ b/qiskit/__init__.py
@@ -81,7 +81,7 @@
 sys.modules["qiskit._accelerate.target"] = _accelerate.target
 sys.modules["qiskit._accelerate.two_qubit_decompose"] = _accelerate.two_qubit_decompose
 sys.modules["qiskit._accelerate.vf2_layout"] = _accelerate.vf2_layout
-sys.modules["qiskit._accelerate.permutation"] = _accelerate.permutation
+sys.modules["qiskit._accelerate.synthesis.permutation"] = _accelerate.synthesis.permutation
 
 from qiskit.exceptions import QiskitError, MissingOptionalLibraryError
 
diff --git a/qiskit/circuit/library/generalized_gates/permutation.py b/qiskit/circuit/library/generalized_gates/permutation.py
index 776c69d94f01..b2d17d2bed23 100644
--- a/qiskit/circuit/library/generalized_gates/permutation.py
+++ b/qiskit/circuit/library/generalized_gates/permutation.py
@@ -80,15 +80,13 @@ def __init__(
 
         name = "permutation_" + np.array_str(pattern).replace(" ", ",")
 
-        circuit = QuantumCircuit(num_qubits, name=name)
-
         super().__init__(num_qubits, name=name)
 
         # pylint: disable=cyclic-import
-        from qiskit.synthesis.permutation.permutation_utils import _get_ordered_swap
+        from qiskit.synthesis.permutation import synth_permutation_basic
 
-        for i, j in _get_ordered_swap(pattern):
-            circuit.swap(i, j)
+        circuit = synth_permutation_basic(pattern)
+        circuit.name = name
 
         all_qubits = self.qubits
         self.append(circuit.to_gate(), all_qubits)
@@ -184,10 +182,11 @@ def inverse(self, annotated: bool = False):
 
     def _qasm2_decomposition(self):
         # pylint: disable=cyclic-import
-        from qiskit.synthesis.permutation.permutation_utils import _get_ordered_swap
+        from qiskit.synthesis.permutation import synth_permutation_basic
 
         name = f"permutation__{'_'.join(str(n) for n in self.pattern)}_"
-        out = QuantumCircuit(self.num_qubits, name=name)
-        for i, j in _get_ordered_swap(self.pattern):
-            out.swap(i, j)
+
+        out = synth_permutation_basic(self.pattern)
+        out.name = name
+
         return out.to_gate()
diff --git a/qiskit/circuit/library/standard_gates/u1.py b/qiskit/circuit/library/standard_gates/u1.py
index 1d59cabae1f6..f141146b72dc 100644
--- a/qiskit/circuit/library/standard_gates/u1.py
+++ b/qiskit/circuit/library/standard_gates/u1.py
@@ -19,6 +19,7 @@
 from qiskit.circuit.parameterexpression import ParameterValueType
 from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit._utils import _ctrl_state_to_int
+from qiskit._accelerate.circuit import StandardGate
 
 
 class U1Gate(Gate):
@@ -92,6 +93,8 @@ class U1Gate(Gate):
         `1612.00858 <https://arxiv.org/abs/1612.00858>`_
     """
 
+    _standard_gate = StandardGate.U1Gate
+
     def __init__(
         self, theta: ParameterValueType, label: str | None = None, *, duration=None, unit="dt"
     ):
diff --git a/qiskit/circuit/library/standard_gates/u2.py b/qiskit/circuit/library/standard_gates/u2.py
index c8e4de96efec..9e59cd4c5bbd 100644
--- a/qiskit/circuit/library/standard_gates/u2.py
+++ b/qiskit/circuit/library/standard_gates/u2.py
@@ -18,6 +18,7 @@
 from qiskit.circuit.gate import Gate
 from qiskit.circuit.parameterexpression import ParameterValueType
 from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit._accelerate.circuit import StandardGate
 
 
 class U2Gate(Gate):
@@ -86,6 +87,8 @@ class U2Gate(Gate):
         using two X90 pulses.
     """
 
+    _standard_gate = StandardGate.U2Gate
+
     def __init__(
         self,
         phi: ParameterValueType,
diff --git a/qiskit/circuit/library/standard_gates/u3.py b/qiskit/circuit/library/standard_gates/u3.py
index 0eef2518a85a..f191609ea8f1 100644
--- a/qiskit/circuit/library/standard_gates/u3.py
+++ b/qiskit/circuit/library/standard_gates/u3.py
@@ -19,6 +19,7 @@
 from qiskit.circuit.gate import Gate
 from qiskit.circuit.parameterexpression import ParameterValueType
 from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit._accelerate.circuit import StandardGate
 
 
 class U3Gate(Gate):
@@ -80,6 +81,8 @@ class U3Gate(Gate):
         U3(\theta, 0, 0) = RY(\theta)
     """
 
+    _standard_gate = StandardGate.U3Gate
+
     def __init__(
         self,
         theta: ParameterValueType,
diff --git a/qiskit/circuit/library/standard_gates/xx_minus_yy.py b/qiskit/circuit/library/standard_gates/xx_minus_yy.py
index 4bf4ab80eca2..db3c3dc89153 100644
--- a/qiskit/circuit/library/standard_gates/xx_minus_yy.py
+++ b/qiskit/circuit/library/standard_gates/xx_minus_yy.py
@@ -27,6 +27,7 @@
 from qiskit.circuit.parameterexpression import ParameterValueType
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit._accelerate.circuit import StandardGate
 
 
 class XXMinusYYGate(Gate):
@@ -91,6 +92,8 @@ class XXMinusYYGate(Gate):
             \end{pmatrix}
     """
 
+    _standard_gate = StandardGate.XXMinusYYGate
+
     def __init__(
         self,
         theta: ParameterValueType,
diff --git a/qiskit/circuit/library/standard_gates/xx_plus_yy.py b/qiskit/circuit/library/standard_gates/xx_plus_yy.py
index a82316ed7b09..7920454d0b98 100644
--- a/qiskit/circuit/library/standard_gates/xx_plus_yy.py
+++ b/qiskit/circuit/library/standard_gates/xx_plus_yy.py
@@ -21,6 +21,7 @@
 from qiskit.circuit.gate import Gate
 from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit.parameterexpression import ParameterValueType
+from qiskit._accelerate.circuit import StandardGate
 
 
 class XXPlusYYGate(Gate):
@@ -87,6 +88,8 @@ class XXPlusYYGate(Gate):
                 \end{pmatrix}
     """
 
+    _standard_gate = StandardGate.XXPlusYYGate
+
     def __init__(
         self,
         theta: ParameterValueType,
diff --git a/qiskit/circuit/parametervector.py b/qiskit/circuit/parametervector.py
index 151e3e7fea73..7b32395e1430 100644
--- a/qiskit/circuit/parametervector.py
+++ b/qiskit/circuit/parametervector.py
@@ -87,7 +87,7 @@ def __str__(self):
         return f"{self.name}, {[str(item) for item in self.params]}"
 
     def __repr__(self):
-        return f"{self.__class__.__name__}(name={self.name}, length={len(self)})"
+        return f"{self.__class__.__name__}(name={repr(self.name)}, length={len(self)})"
 
     def resize(self, length):
         """Resize the parameter vector.  If necessary, new elements are generated.
diff --git a/qiskit/circuit/quantumcircuit.py b/qiskit/circuit/quantumcircuit.py
index a88dfd43ea4b..8b3ff7bf1979 100644
--- a/qiskit/circuit/quantumcircuit.py
+++ b/qiskit/circuit/quantumcircuit.py
@@ -1161,9 +1161,9 @@ def __init__(
     def _from_circuit_data(cls, data: CircuitData) -> typing.Self:
         """A private constructor from rust space circuit data."""
         out = QuantumCircuit()
-        out.add_bits(data.qubits)
-        out.add_bits(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
@@ -3674,6 +3674,8 @@ def copy_empty_like(
         cpy._data = CircuitData(
             self._data.qubits, self._data.clbits, global_phase=self._data.global_phase
         )
+        # Invalidate parameters caching.
+        cpy._parameters = None
 
         cpy._calibrations = _copy.deepcopy(self._calibrations)
         cpy._metadata = _copy.deepcopy(self._metadata)
diff --git a/qiskit/providers/fake_provider/generic_backend_v2.py b/qiskit/providers/fake_provider/generic_backend_v2.py
index 1ac0484d775d..214754080e57 100644
--- a/qiskit/providers/fake_provider/generic_backend_v2.py
+++ b/qiskit/providers/fake_provider/generic_backend_v2.py
@@ -375,6 +375,11 @@ def _build_generic_target(self):
                     f"in the standard qiskit circuit library."
                 )
             gate = self._supported_gates[name]
+            if self.num_qubits < gate.num_qubits:
+                raise QiskitError(
+                    f"Provided basis gate {name} needs more qubits than {self.num_qubits}, "
+                    f"which is the size of the backend."
+                )
             noise_params = self._get_noise_defaults(name, gate.num_qubits)
             self._add_noisy_instruction_to_target(gate, noise_params, calibration_inst_map)
 
diff --git a/qiskit/synthesis/discrete_basis/generate_basis_approximations.py b/qiskit/synthesis/discrete_basis/generate_basis_approximations.py
index 672d0eb9e8ef..da9708c24559 100644
--- a/qiskit/synthesis/discrete_basis/generate_basis_approximations.py
+++ b/qiskit/synthesis/discrete_basis/generate_basis_approximations.py
@@ -156,7 +156,7 @@ def generate_basic_approximations(
         data = {}
         for sequence in sequences:
             gatestring = sequence.name
-            data[gatestring] = sequence.product
+            data[gatestring] = (sequence.product, sequence.global_phase)
 
         np.save(filename, data)
 
diff --git a/qiskit/synthesis/discrete_basis/solovay_kitaev.py b/qiskit/synthesis/discrete_basis/solovay_kitaev.py
index 2e5cfeafcecd..f367f6c0f0b5 100644
--- a/qiskit/synthesis/discrete_basis/solovay_kitaev.py
+++ b/qiskit/synthesis/discrete_basis/solovay_kitaev.py
@@ -16,8 +16,6 @@
 
 import numpy as np
 
-from qiskit.circuit.gate import Gate
-
 from .gate_sequence import GateSequence
 from .commutator_decompose import commutator_decompose
 from .generate_basis_approximations import generate_basic_approximations, _1q_gates, _1q_inverses
@@ -53,14 +51,19 @@ def __init__(
 
         self.basic_approximations = self.load_basic_approximations(basic_approximations)
 
-    def load_basic_approximations(self, data: list | str | dict) -> list[GateSequence]:
+    @staticmethod
+    def load_basic_approximations(data: list | str | dict) -> list[GateSequence]:
         """Load basic approximations.
 
         Args:
             data: If a string, specifies the path to the file from where to load the data.
-                If a dictionary, directly specifies the decompositions as ``{gates: matrix}``.
-                There ``gates`` are the names of the gates producing the SO(3) matrix ``matrix``,
-                e.g. ``{"h t": np.array([[0, 0.7071, -0.7071], [0, -0.7071, -0.7071], [-1, 0, 0]]}``.
+                If a dictionary, directly specifies the decompositions as ``{gates: matrix}``
+                or ``{gates: (matrix, global_phase)}``. There, ``gates`` are the names of the gates
+                producing the SO(3) matrix ``matrix``, e.g.
+                ``{"h t": np.array([[0, 0.7071, -0.7071], [0, -0.7071, -0.7071], [-1, 0, 0]]}``
+                and the ``global_phase`` can be given to account for a global phase difference
+                between the U(2) matrix of the quantum gates and the stored SO(3) matrix.
+                If not given, the ``global_phase`` will be assumed to be 0.
 
         Returns:
             A list of basic approximations as type ``GateSequence``.
@@ -74,13 +77,20 @@ def load_basic_approximations(self, data: list | str | dict) -> list[GateSequenc
 
         # if a file, load the dictionary
         if isinstance(data, str):
-            data = np.load(data, allow_pickle=True)
+            data = np.load(data, allow_pickle=True).item()
 
         sequences = []
-        for gatestring, matrix in data.items():
+        for gatestring, matrix_and_phase in data.items():
+            if isinstance(matrix_and_phase, tuple):
+                matrix, global_phase = matrix_and_phase
+            else:
+                matrix, global_phase = matrix_and_phase, 0
+
             sequence = GateSequence()
             sequence.gates = [_1q_gates[element] for element in gatestring.split()]
+            sequence.labels = [gate.name for gate in sequence.gates]
             sequence.product = np.asarray(matrix)
+            sequence.global_phase = global_phase
             sequences.append(sequence)
 
         return sequences
@@ -157,14 +167,14 @@ def _recurse(self, sequence: GateSequence, n: int, check_input: bool = True) ->
         w_n1 = self._recurse(w_n, n - 1, check_input=check_input)
         return v_n1.dot(w_n1).dot(v_n1.adjoint()).dot(w_n1.adjoint()).dot(u_n1)
 
-    def find_basic_approximation(self, sequence: GateSequence) -> Gate:
-        """Finds gate in ``self._basic_approximations`` that best represents ``sequence``.
+    def find_basic_approximation(self, sequence: GateSequence) -> GateSequence:
+        """Find ``GateSequence`` in ``self._basic_approximations`` that approximates ``sequence``.
 
         Args:
-            sequence: The gate to find the approximation to.
+            sequence: ``GateSequence`` to find the approximation to.
 
         Returns:
-            Gate in basic approximations that is closest to ``sequence``.
+            ``GateSequence`` in ``self._basic_approximations`` that approximates ``sequence``.
         """
         # TODO explore using a k-d tree here
 
diff --git a/qiskit/synthesis/permutation/permutation_full.py b/qiskit/synthesis/permutation/permutation_full.py
index ff014cb3a051..c280065c2a57 100644
--- a/qiskit/synthesis/permutation/permutation_full.py
+++ b/qiskit/synthesis/permutation/permutation_full.py
@@ -16,8 +16,8 @@
 
 import numpy as np
 from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit._accelerate.synthesis.permutation import _synth_permutation_basic
 from .permutation_utils import (
-    _get_ordered_swap,
     _inverse_pattern,
     _pattern_to_cycles,
     _decompose_cycles,
@@ -44,17 +44,7 @@ def synth_permutation_basic(pattern: list[int] | np.ndarray[int]) -> QuantumCirc
     Returns:
         The synthesized quantum circuit.
     """
-    # This is the very original Qiskit algorithm for synthesizing permutations.
-
-    num_qubits = len(pattern)
-    qc = QuantumCircuit(num_qubits)
-
-    swaps = _get_ordered_swap(pattern)
-
-    for swap in swaps:
-        qc.swap(swap[0], swap[1])
-
-    return qc
+    return QuantumCircuit._from_circuit_data(_synth_permutation_basic(pattern))
 
 
 def synth_permutation_acg(pattern: list[int] | np.ndarray[int]) -> QuantumCircuit:
diff --git a/qiskit/synthesis/permutation/permutation_utils.py b/qiskit/synthesis/permutation/permutation_utils.py
index dbd73bfe8111..4520e18f4d06 100644
--- a/qiskit/synthesis/permutation/permutation_utils.py
+++ b/qiskit/synthesis/permutation/permutation_utils.py
@@ -13,9 +13,8 @@
 """Utility functions for handling permutations."""
 
 # pylint: disable=unused-import
-from qiskit._accelerate.permutation import (
+from qiskit._accelerate.synthesis.permutation import (
     _inverse_pattern,
-    _get_ordered_swap,
     _validate_permutation,
 )
 
diff --git a/releasenotes/notes/deprecate-legacy-circuit-instruction-8a332ab09de73766.yaml b/releasenotes/notes/deprecate-legacy-circuit-instruction-8a332ab09de73766.yaml
new file mode 100644
index 000000000000..d656ee5cb823
--- /dev/null
+++ b/releasenotes/notes/deprecate-legacy-circuit-instruction-8a332ab09de73766.yaml
@@ -0,0 +1,23 @@
+---
+deprecations_circuits:
+  - |
+    Treating :class:`.CircuitInstruction` as a tuple-like iterable is deprecated, and this legacy
+    path way will be removed in Qiskit 2.0.  You should use the attribute-access fields
+    :attr:`~.CircuitInstruction.operation`, :attr:`~.CircuitInstruction.qubits`, and 
+    :attr:`~.CircuitInstruction.clbits` instead.  For example::
+
+      from qiskit.circuit import QuantumCircuit
+
+      qc = QuantumCircuit(2, 2)
+      qc.h(0)
+      qc.cx(0, 1)
+      qc.measure([0, 1], [0, 1])
+
+      # Deprecated.
+      for op, qubits, clbits in qc.data:
+          pass
+      # New style.
+      for instruction in qc.data:
+          op = instruction.operation
+          qubits = instruction.qubits
+          clbits = instruction.clbits
diff --git a/releasenotes/notes/fix-parameter-cache-05eac2f24477ccb8.yaml b/releasenotes/notes/fix-parameter-cache-05eac2f24477ccb8.yaml
new file mode 100644
index 000000000000..05ac759569f7
--- /dev/null
+++ b/releasenotes/notes/fix-parameter-cache-05eac2f24477ccb8.yaml
@@ -0,0 +1,7 @@
+---
+fixes:
+  - |
+    The :attr:`.QuantumCircuit.parameters` attribute will now correctly be empty
+    when using :meth:`.QuantumCircuit.copy_empty_like` on a parametric circuit.
+    Previously, an internal cache would be copied over without invalidation.
+    Fix `#12617 <https://github.com/Qiskit/qiskit/issues/12617>`__.
diff --git a/releasenotes/notes/fix-sk-load-from-file-02c6eabbbd7fcda3.yaml b/releasenotes/notes/fix-sk-load-from-file-02c6eabbbd7fcda3.yaml
new file mode 100644
index 000000000000..d995af06bccb
--- /dev/null
+++ b/releasenotes/notes/fix-sk-load-from-file-02c6eabbbd7fcda3.yaml
@@ -0,0 +1,10 @@
+---
+fixes:
+  - |
+    Fix the :class:`.SolovayKitaev` transpiler pass when loading basic
+    approximations from an exising ``.npy`` file. Previously, loading
+    a stored approximation which allowed for further reductions (e.g. due
+    to gate cancellations) could cause a runtime failure.
+    Additionally, the global phase difference of the U(2) gate product
+    and SO(3) representation was lost during a save-reload procedure.
+    Fixes `Qiskit/qiskit#12576 <https://github.com/Qiskit/qiskit/issues/12576>`_.
diff --git a/releasenotes/notes/fixes_GenericBackendV2-668e40596e1f070d.yaml b/releasenotes/notes/fixes_GenericBackendV2-668e40596e1f070d.yaml
new file mode 100644
index 000000000000..9d297125e3c2
--- /dev/null
+++ b/releasenotes/notes/fixes_GenericBackendV2-668e40596e1f070d.yaml
@@ -0,0 +1,4 @@
+---
+fixes:
+  - |
+    The constructor :class:`.GenericBackendV2` was allowing to create malformed backends because it accepted basis gates that couldn't be allocated in the backend size . That is, a backend with a single qubit should not accept a basis with two-qubit gates.
diff --git a/releasenotes/notes/oxidize-permbasic-be27578187ac472f.yaml b/releasenotes/notes/oxidize-permbasic-be27578187ac472f.yaml
new file mode 100644
index 000000000000..e770aa1ca31b
--- /dev/null
+++ b/releasenotes/notes/oxidize-permbasic-be27578187ac472f.yaml
@@ -0,0 +1,4 @@
+---
+upgrade_synthesis:
+  - |
+    Port :func:`.synth_permutation_basic`, used to synthesize qubit permutations, to Rust.
diff --git a/test/python/circuit/test_circuit_data.py b/test/python/circuit/test_circuit_data.py
index 6fc6e8e72bd7..55028c8e883e 100644
--- a/test/python/circuit/test_circuit_data.py
+++ b/test/python/circuit/test_circuit_data.py
@@ -403,6 +403,26 @@ class TestQuantumCircuitInstructionData(QiskitTestCase):
     # but are included as tests to maintain compatability with the previous
     # list interface of circuit.data.
 
+    def test_iteration_of_data_entry(self):
+        """Verify that the base types of the legacy tuple iteration are correct, since they're
+        different to attribute access."""
+        qc = QuantumCircuit(3, 3)
+        qc.h(0)
+        qc.cx(0, 1)
+        qc.cx(1, 2)
+        qc.measure([0, 1, 2], [0, 1, 2])
+
+        def to_legacy(instruction):
+            return (instruction.operation, list(instruction.qubits), list(instruction.clbits))
+
+        expected = [to_legacy(instruction) for instruction in qc.data]
+
+        with self.assertWarnsRegex(
+            DeprecationWarning, "Treating CircuitInstruction as an iterable is deprecated"
+        ):
+            actual = [tuple(instruction) for instruction in qc.data]
+        self.assertEqual(actual, expected)
+
     def test_getitem_by_insertion_order(self):
         """Verify one can get circuit.data items in insertion order."""
         qr = QuantumRegister(2)
diff --git a/test/python/circuit/test_parameters.py b/test/python/circuit/test_parameters.py
index 0095f87be9ae..f580416eccf5 100644
--- a/test/python/circuit/test_parameters.py
+++ b/test/python/circuit/test_parameters.py
@@ -203,6 +203,29 @@ def test_parameters_property_by_index(self):
         for i, vi in enumerate(v):
             self.assertEqual(vi, qc.parameters[i])
 
+    def test_parameters_property_independent_after_copy(self):
+        """Test that any `parameters` property caching is invalidated after a copy operation."""
+        a = Parameter("a")
+        b = Parameter("b")
+        c = Parameter("c")
+
+        qc1 = QuantumCircuit(1)
+        qc1.rz(a, 0)
+        self.assertEqual(set(qc1.parameters), {a})
+
+        qc2 = qc1.copy_empty_like()
+        self.assertEqual(set(qc2.parameters), set())
+
+        qc3 = qc1.copy()
+        self.assertEqual(set(qc3.parameters), {a})
+        qc3.rz(b, 0)
+        self.assertEqual(set(qc3.parameters), {a, b})
+        self.assertEqual(set(qc1.parameters), {a})
+
+        qc1.rz(c, 0)
+        self.assertEqual(set(qc1.parameters), {a, c})
+        self.assertEqual(set(qc3.parameters), {a, b})
+
     def test_get_parameter(self):
         """Test the `get_parameter` method."""
         x = Parameter("x")
@@ -1375,6 +1398,21 @@ def test_parametervector_resize(self):
             self.assertEqual(element, vec[1])
             self.assertListEqual([param.name for param in vec], _paramvec_names("x", 3))
 
+    def test_parametervector_repr(self):
+        """Test the __repr__ method of the parameter vector."""
+        vec = ParameterVector("x", 2)
+        self.assertEqual(repr(vec), "ParameterVector(name='x', length=2)")
+
+    def test_parametervector_str(self):
+        """Test the __str__ method of the parameter vector."""
+        vec = ParameterVector("x", 2)
+        self.assertEqual(str(vec), "x, ['x[0]', 'x[1]']")
+
+    def test_parametervector_index(self):
+        """Test the index method of the parameter vector."""
+        vec = ParameterVector("x", 2)
+        self.assertEqual(vec.index(vec[1]), 1)
+
     def test_raise_if_sub_unknown_parameters(self):
         """Verify we raise if asked to sub a parameter not in self."""
         x = Parameter("x")
diff --git a/test/python/circuit/test_rust_equivalence.py b/test/python/circuit/test_rust_equivalence.py
index bb09ae4caf3f..8d6d159c0b64 100644
--- a/test/python/circuit/test_rust_equivalence.py
+++ b/test/python/circuit/test_rust_equivalence.py
@@ -79,12 +79,23 @@ def test_definitions(self):
                             )
                         # Rust uses P but python still uses u1
                         elif rs_inst.operation.name == "p":
-                            self.assertEqual(py_inst.operation.name, "u1")
-                            self.assertEqual(rs_inst.operation.params, py_inst.operation.params)
-                            self.assertEqual(
-                                [py_def.find_bit(x).index for x in py_inst.qubits],
-                                [rs_def.find_bit(x).index for x in rs_inst.qubits],
-                            )
+                            if py_inst.operation.name == "u1":
+                                self.assertEqual(py_inst.operation.name, "u1")
+                                self.assertEqual(rs_inst.operation.params, py_inst.operation.params)
+                                self.assertEqual(
+                                    [py_def.find_bit(x).index for x in py_inst.qubits],
+                                    [rs_def.find_bit(x).index for x in rs_inst.qubits],
+                                )
+                            else:
+                                self.assertEqual(py_inst.operation.name, "u3")
+                                self.assertEqual(
+                                    rs_inst.operation.params[0], py_inst.operation.params[2]
+                                )
+                                self.assertEqual(
+                                    [py_def.find_bit(x).index for x in py_inst.qubits],
+                                    [rs_def.find_bit(x).index for x in rs_inst.qubits],
+                                )
+
                         else:
                             self.assertEqual(py_inst.operation.name, rs_inst.operation.name)
                             self.assertEqual(rs_inst.operation.params, py_inst.operation.params)
@@ -102,7 +113,7 @@ def test_matrix(self):
                 continue
 
             with self.subTest(name=name):
-                params = [pi] * standard_gate._num_params()
+                params = [0.1] * 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)
diff --git a/test/python/providers/fake_provider/test_generic_backend_v2.py b/test/python/providers/fake_provider/test_generic_backend_v2.py
index b4fbe944c332..cd7c611b2212 100644
--- a/test/python/providers/fake_provider/test_generic_backend_v2.py
+++ b/test/python/providers/fake_provider/test_generic_backend_v2.py
@@ -35,6 +35,16 @@ def test_supported_basis_gates(self):
         with self.assertRaises(QiskitError):
             GenericBackendV2(num_qubits=8, basis_gates=["cx", "id", "rz", "sx", "zz"])
 
+    def test_cx_1Q(self):
+        """Test failing with a backend with single qubit but with a two-qubit basis gate"""
+        with self.assertRaises(QiskitError):
+            GenericBackendV2(num_qubits=1, basis_gates=["cx", "id"])
+
+    def test_ccx_2Q(self):
+        """Test failing with a backend with two qubits but with a three-qubit basis gate"""
+        with self.assertRaises(QiskitError):
+            GenericBackendV2(num_qubits=2, basis_gates=["ccx", "id"])
+
     def test_operation_names(self):
         """Test that target basis gates include "delay", "measure" and "reset" even
         if not provided by user."""
diff --git a/test/python/qasm3/test_export.py b/test/python/qasm3/test_export.py
index 048c5d7852b4..6df041420882 100644
--- a/test/python/qasm3/test_export.py
+++ b/test/python/qasm3/test_export.py
@@ -2018,65 +2018,63 @@ def test_teleportation(self):
         qc.z(2).c_if(qc.clbits[0], 1)
 
         transpiled = transpile(qc, initial_layout=[0, 1, 2])
-        first_h = transpiled.data[0].operation
-        u2 = first_h.definition.data[0].operation
-        u3_1 = u2.definition.data[0].operation
-        first_x = transpiled.data[-2].operation
-        u3_2 = first_x.definition.data[0].operation
-        first_z = transpiled.data[-1].operation
-        u1 = first_z.definition.data[0].operation
-        u3_3 = u1.definition.data[0].operation
+        id_len = len(str(id(transpiled.data[0].operation)))
 
-        expected_qasm = "\n".join(
-            [
-                "OPENQASM 3.0;",
-                f"gate u3_{id(u3_1)}(_gate_p_0, _gate_p_1, _gate_p_2) _gate_q_0 {{",
-                "  U(pi/2, 0, pi) _gate_q_0;",
-                "}",
-                f"gate u2_{id(u2)}(_gate_p_0, _gate_p_1) _gate_q_0 {{",
-                f"  u3_{id(u3_1)}(pi/2, 0, pi) _gate_q_0;",
-                "}",
-                "gate h _gate_q_0 {",
-                f"  u2_{id(u2)}(0, pi) _gate_q_0;",
-                "}",
-                "gate cx c, t {",
-                "  ctrl @ U(pi, 0, pi) c, t;",
-                "}",
-                f"gate u3_{id(u3_2)}(_gate_p_0, _gate_p_1, _gate_p_2) _gate_q_0 {{",
-                "  U(pi, 0, pi) _gate_q_0;",
-                "}",
-                "gate x _gate_q_0 {",
-                f"  u3_{id(u3_2)}(pi, 0, pi) _gate_q_0;",
-                "}",
-                f"gate u3_{id(u3_3)}(_gate_p_0, _gate_p_1, _gate_p_2) _gate_q_0 {{",
-                "  U(0, 0, pi) _gate_q_0;",
-                "}",
-                f"gate u1_{id(u1)}(_gate_p_0) _gate_q_0 {{",
-                f"  u3_{id(u3_3)}(0, 0, pi) _gate_q_0;",
-                "}",
-                "gate z _gate_q_0 {",
-                f"  u1_{id(u1)}(pi) _gate_q_0;",
-                "}",
-                "bit[2] c;",
-                "h $1;",
-                "cx $1, $2;",
-                "barrier $0, $1, $2;",
-                "cx $0, $1;",
-                "h $0;",
-                "barrier $0, $1, $2;",
-                "c[0] = measure $0;",
-                "c[1] = measure $1;",
-                "barrier $0, $1, $2;",
-                "if (c[1]) {",
-                "  x $2;",
-                "}",
-                "if (c[0]) {",
-                "  z $2;",
-                "}",
-                "",
-            ]
-        )
-        self.assertEqual(Exporter(includes=[]).dumps(transpiled), expected_qasm)
+        expected_qasm = [
+            "OPENQASM 3.0;",
+            re.compile(r"gate u3_\d{%s}\(_gate_p_0, _gate_p_1, _gate_p_2\) _gate_q_0 \{" % id_len),
+            "  U(pi/2, 0, pi) _gate_q_0;",
+            "}",
+            re.compile(r"gate u2_\d{%s}\(_gate_p_0, _gate_p_1\) _gate_q_0 \{" % id_len),
+            re.compile(r"  u3_\d{%s}\(pi/2, 0, pi\) _gate_q_0;" % id_len),
+            "}",
+            "gate h _gate_q_0 {",
+            re.compile(r"  u2_\d{%s}\(0, pi\) _gate_q_0;" % id_len),
+            "}",
+            "gate cx c, t {",
+            "  ctrl @ U(pi, 0, pi) c, t;",
+            "}",
+            re.compile(r"gate u3_\d{%s}\(_gate_p_0, _gate_p_1, _gate_p_2\) _gate_q_0 \{" % id_len),
+            "  U(pi, 0, pi) _gate_q_0;",
+            "}",
+            "gate x _gate_q_0 {",
+            re.compile(r"  u3_\d{%s}\(pi, 0, pi\) _gate_q_0;" % id_len),
+            "}",
+            re.compile(r"gate u3_\d{%s}\(_gate_p_0, _gate_p_1, _gate_p_2\) _gate_q_0 \{" % id_len),
+            "  U(0, 0, pi) _gate_q_0;",
+            "}",
+            re.compile(r"gate u1_\d{%s}\(_gate_p_0\) _gate_q_0 \{" % id_len),
+            re.compile(r"  u3_\d{%s}\(0, 0, pi\) _gate_q_0;" % id_len),
+            "}",
+            "gate z _gate_q_0 {",
+            re.compile(r"  u1_\d{%s}\(pi\) _gate_q_0;" % id_len),
+            "}",
+            "bit[2] c;",
+            "h $1;",
+            "cx $1, $2;",
+            "barrier $0, $1, $2;",
+            "cx $0, $1;",
+            "h $0;",
+            "barrier $0, $1, $2;",
+            "c[0] = measure $0;",
+            "c[1] = measure $1;",
+            "barrier $0, $1, $2;",
+            "if (c[1]) {",
+            "  x $2;",
+            "}",
+            "if (c[0]) {",
+            "  z $2;",
+            "}",
+            "",
+        ]
+        res = Exporter(includes=[]).dumps(transpiled).splitlines()
+        for result, expected in zip(res, expected_qasm):
+            if isinstance(expected, str):
+                self.assertEqual(result, expected)
+            else:
+                self.assertTrue(
+                    expected.search(result), f"Line {result} doesn't match regex: {expected}"
+                )
 
     def test_custom_gate_with_params_bound_main_call(self):
         """Custom gate with unbound parameters that are bound in the main circuit"""
diff --git a/test/python/synthesis/test_permutation_synthesis.py b/test/python/synthesis/test_permutation_synthesis.py
index 050df5a3fe1c..b6a1ca9e1857 100644
--- a/test/python/synthesis/test_permutation_synthesis.py
+++ b/test/python/synthesis/test_permutation_synthesis.py
@@ -27,7 +27,6 @@
 )
 from qiskit.synthesis.permutation.permutation_utils import (
     _inverse_pattern,
-    _get_ordered_swap,
     _validate_permutation,
 )
 from test import QiskitTestCase  # pylint: disable=wrong-import-order
@@ -47,19 +46,6 @@ def test_inverse_pattern(self, width):
             for ii, jj in enumerate(pattern):
                 self.assertTrue(inverse[jj] == ii)
 
-    @data(4, 5, 10, 15, 20)
-    def test_get_ordered_swap(self, width):
-        """Test _get_ordered_swap function produces correct swap list."""
-        np.random.seed(1)
-        for _ in range(5):
-            pattern = np.random.permutation(width)
-            swap_list = _get_ordered_swap(pattern)
-            output = list(range(width))
-            for i, j in swap_list:
-                output[i], output[j] = output[j], output[i]
-            self.assertTrue(np.array_equal(pattern, output))
-            self.assertLess(len(swap_list), width)
-
     @data(10, 20)
     def test_invalid_permutations(self, width):
         """Check that _validate_permutation raises exceptions when the
diff --git a/test/python/transpiler/test_optimize_1q_gates.py b/test/python/transpiler/test_optimize_1q_gates.py
index 9253130bedbf..e5483dd47499 100644
--- a/test/python/transpiler/test_optimize_1q_gates.py
+++ b/test/python/transpiler/test_optimize_1q_gates.py
@@ -19,7 +19,7 @@
 from qiskit.transpiler import PassManager
 from qiskit.transpiler.passes import Optimize1qGates, BasisTranslator
 from qiskit.converters import circuit_to_dag
-from qiskit.circuit import Parameter
+from qiskit.circuit import Parameter, Gate
 from qiskit.circuit.library import U1Gate, U2Gate, U3Gate, UGate, PhaseGate
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.transpiler.target import Target
@@ -323,9 +323,24 @@ def test_parameterized_expressions_in_circuits(self):
 
     def test_global_phase_u3_on_left(self):
         """Check proper phase accumulation with instruction with no definition."""
+
+        class CustomGate(Gate):
+            """Custom u1 gate definition."""
+
+            def __init__(self, lam):
+                super().__init__("u1", 1, [lam])
+
+            def _define(self):
+                qc = QuantumCircuit(1)
+                qc.p(*self.params, 0)
+                self.definition = qc
+
+            def _matrix(self):
+                return U1Gate(*self.params).to_matrix()
+
         qr = QuantumRegister(1)
         qc = QuantumCircuit(qr)
-        u1 = U1Gate(0.1)
+        u1 = CustomGate(0.1)
         u1.definition.global_phase = np.pi / 2
         qc.append(u1, [0])
         qc.global_phase = np.pi / 3
@@ -337,9 +352,24 @@ def test_global_phase_u3_on_left(self):
 
     def test_global_phase_u_on_left(self):
         """Check proper phase accumulation with instruction with no definition."""
+
+        class CustomGate(Gate):
+            """Custom u1 gate."""
+
+            def __init__(self, lam):
+                super().__init__("u1", 1, [lam])
+
+            def _define(self):
+                qc = QuantumCircuit(1)
+                qc.p(*self.params, 0)
+                self.definition = qc
+
+            def _matrix(self):
+                return U1Gate(*self.params).to_matrix()
+
         qr = QuantumRegister(1)
         qc = QuantumCircuit(qr)
-        u1 = U1Gate(0.1)
+        u1 = CustomGate(0.1)
         u1.definition.global_phase = np.pi / 2
         qc.append(u1, [0])
         qc.global_phase = np.pi / 3
diff --git a/test/python/transpiler/test_solovay_kitaev.py b/test/python/transpiler/test_solovay_kitaev.py
index e15a080f6f03..62b811c8e3bd 100644
--- a/test/python/transpiler/test_solovay_kitaev.py
+++ b/test/python/transpiler/test_solovay_kitaev.py
@@ -12,8 +12,10 @@
 
 """Test the Solovay Kitaev transpilation pass."""
 
+import os
 import unittest
 import math
+import tempfile
 import numpy as np
 import scipy
 
@@ -230,6 +232,35 @@ def test_u_gates_work(self):
         included_gates = set(discretized.count_ops().keys())
         self.assertEqual(set(basis_gates), included_gates)
 
+    def test_load_from_file(self):
+        """Test loading basic approximations from a file works.
+
+        Regression test of Qiskit/qiskit#12576.
+        """
+        filename = "approximations.npy"
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            fullpath = os.path.join(tmp_dir, filename)
+
+            # dump approximations to file
+            generate_basic_approximations(basis_gates=["h", "s", "sdg"], depth=3, filename=fullpath)
+
+            # circuit to decompose and reference decomp
+            circuit = QuantumCircuit(1)
+            circuit.rx(0.8, 0)
+
+            reference = QuantumCircuit(1, global_phase=3 * np.pi / 4)
+            reference.h(0)
+            reference.s(0)
+            reference.h(0)
+
+            # load the decomp and compare to reference
+            skd = SolovayKitaev(basic_approximations=fullpath)
+            # skd = SolovayKitaev(basic_approximations=filename)
+            discretized = skd(circuit)
+
+        self.assertEqual(discretized, reference)
+
 
 @ddt
 class TestGateSequence(QiskitTestCase):
diff --git a/test/utils/base.py b/test/utils/base.py
index 63a8bf4384f0..bebf03008858 100644
--- a/test/utils/base.py
+++ b/test/utils/base.py
@@ -215,6 +215,15 @@ def setUpClass(cls):
             module=r"seaborn(\..*)?",
         )
 
+        # Safe to remove once https://github.com/Qiskit/qiskit-aer/pull/2179 is in a release version
+        # of Aer.
+        warnings.filterwarnings(
+            "default",
+            category=DeprecationWarning,
+            message="Treating CircuitInstruction as an iterable is deprecated",
+            module=r"qiskit_aer(\.[a-zA-Z0-9_]+)*",
+        )
+
         allow_DeprecationWarning_modules = [
             "test.python.pulse.test_builder",
             "test.python.pulse.test_block",
diff --git a/test/visual/mpl/graph/test_graph_matplotlib_drawer.py b/test/visual/mpl/graph/test_graph_matplotlib_drawer.py
index ae69f212f89c..20fae107d30d 100644
--- a/test/visual/mpl/graph/test_graph_matplotlib_drawer.py
+++ b/test/visual/mpl/graph/test_graph_matplotlib_drawer.py
@@ -389,7 +389,7 @@ def test_plot_1_qubit_gate_map(self):
         """Test plot_gate_map using 1 qubit backend"""
         # getting the mock backend from FakeProvider
 
-        backend = GenericBackendV2(num_qubits=1)
+        backend = GenericBackendV2(num_qubits=1, basis_gates=["id", "rz", "sx", "x"])
 
         fname = "1_qubit_gate_map.png"
         self.graph_plot_gate_map(backend=backend, filename=fname)