diff --git a/.github/dependabot.yaml b/.github/dependabot.yml
similarity index 100%
rename from .github/dependabot.yaml
rename to .github/dependabot.yml
diff --git a/.github/workflows/python-publish-pypi.yaml b/.github/workflows/python-publish-pypi.yml
similarity index 84%
rename from .github/workflows/python-publish-pypi.yaml
rename to .github/workflows/python-publish-pypi.yml
index 66da8ce..e1f3027 100644
--- a/.github/workflows/python-publish-pypi.yaml
+++ b/.github/workflows/python-publish-pypi.yml
@@ -14,7 +14,10 @@ on:
 jobs:
   build:
     name: Build distribution 📦
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
+    strategy:
+        matrix:
+            os: [ubuntu-latest, windows-latest, macos-latest]
     permissions:
       attestations: write
       id-token: write
@@ -32,7 +35,10 @@ jobs:
     name: Publish Python 🐍 distribution 📦 to PyPI
     needs: build
     if: ${{ github.event.action == 'published' }}
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
+    strategy:
+        matrix:
+            os: [ubuntu-latest, windows-latest, macos-latest]
     environment:
       name: pypi
       url: https://pypi.org/project/quick-core/${{ github.ref_name }}
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index ba5fdaf..58bfae5 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -9,8 +9,9 @@ jobs:
     test:
         runs-on: ${{ matrix.os }}
         strategy:
+            fail-fast: false
             matrix:
-                os: [ubuntu-latest]
+                os: [ubuntu-latest, windows-latest, macos-latest]
                 python-version: ["3.10", "3.11", "3.12"]
 
         steps:
diff --git a/pyproject.toml b/pyproject.toml
index 0c01e05..9a75de2 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -8,17 +8,17 @@ version = "0.0.0"
 dependencies = [
     "cirq-core == 1.4.1",
     "genQC == 0.1.0",
-    "numpy >= 1.23,< 3.0",
+    "numpy >= 1.23",
     "pennylane == 0.39.0",
-    "pytket == 1.37.0",
-    "pytket-qiskit == 0.62.0",
-    "pytket-cirq == 0.39.0",
-    "qiskit == 1.3.1",
-    "qiskit_aer == 0.16.0",
-    "qiskit_ibm_runtime == 0.34.0",
-    "qiskit-transpiler-service == 0.4.14",
+    "pytket == 2.4.1",
+    "pytket-qiskit == 0.68.0",
+    "pytket-cirq == 0.40.0",
+    "qiskit == 2.0.1",
+    "qiskit_aer == 0.17.0",
+    "qiskit_ibm_runtime == 0.39.0",
+    "qiskit-ibm-transpiler == 0.11.0",
     "quimb == 1.10.0",
-    "tket2 == 0.6.0"
+    "tket2 == 0.10.0"
 ]
 requires-python = ">=3.10, <3.13"
 authors = [
diff --git a/quick/backend/backend.py b/quick/backend/backend.py
index 9eec55a..f2c0028 100644
--- a/quick/backend/backend.py
+++ b/quick/backend/backend.py
@@ -58,7 +58,7 @@ class Backend(ABC):
     """
     def __init__(
             self,
-            device: str="CPU"
+            device: str = "CPU"
         ) -> None:
         """ Initialize a `quick.backend.Backend` instance.
         """
@@ -176,7 +176,7 @@ def get_operator(
     def get_counts(
             self,
             circuit: Circuit,
-            num_shots: int=1024
+            num_shots: int = 1024
         ) -> dict[str, int]:
         """ Get the counts of the backend.
 
@@ -331,7 +331,7 @@ def __init__(
             self,
             single_qubit_error: float,
             two_qubit_error: float,
-            device: str="CPU"
+            device: str = "CPU"
         ) -> None:
         """ Initialize a `quick.backend.NoisyBackend` instance.
         """
@@ -380,7 +380,7 @@ class FakeBackend(Backend, ABC):
     """
     def __init__(
             self,
-            device: str="CPU"
+            device: str = "CPU"
         ) -> None:
         """ Initialize a `quick.backend.FakeBackend` instance.
         """
@@ -451,7 +451,7 @@ def get_operator(
     def get_counts(
             self,
             circuit: Circuit,
-            num_shots: int=1024
+            num_shots: int = 1024
         ) -> dict[str, int]:
         """ Get the counts of the backend.
 
diff --git a/quick/backend/qiskit_backends/aer_backend.py b/quick/backend/qiskit_backends/aer_backend.py
index ba08866..7d17be9 100644
--- a/quick/backend/qiskit_backends/aer_backend.py
+++ b/quick/backend/qiskit_backends/aer_backend.py
@@ -87,9 +87,9 @@ class AerBackend(NoisyBackend):
     """
     def __init__(
             self,
-            single_qubit_error: float=0.0,
-            two_qubit_error: float=0.0,
-            device: str="CPU"
+            single_qubit_error: float = 0.0,
+            two_qubit_error: float = 0.0,
+            device: str = "CPU"
         ) -> None:
 
         super().__init__(
@@ -189,7 +189,7 @@ def get_operator(
     def get_counts(
             self,
             circuit: Circuit,
-            num_shots: int=1024
+            num_shots: int = 1024
         ) -> dict[str, int]:
 
         if len(circuit.measured_qubits) == 0:
diff --git a/quick/backend/qiskit_backends/fake_ibm_backend.py b/quick/backend/qiskit_backends/fake_ibm_backend.py
index 1f1a4e6..e78d3d9 100644
--- a/quick/backend/qiskit_backends/fake_ibm_backend.py
+++ b/quick/backend/qiskit_backends/fake_ibm_backend.py
@@ -89,7 +89,7 @@ def __init__(
             self,
             hardware_name: str,
             qiskit_runtime: QiskitRuntimeService,
-            device: str="CPU"
+            device: str = "CPU"
         ) -> None:
 
         super().__init__(device=device)
@@ -161,7 +161,7 @@ def get_operator(
     def get_counts(
             self,
             circuit: Circuit,
-            num_shots: int=1024
+            num_shots: int = 1024
         ) -> dict[str, int]:
 
         result = self._counts_backend.run([circuit.circuit], shots=num_shots).result()
diff --git a/quick/circuit/circuit.py b/quick/circuit/circuit.py
index a94be3f..b0de8e0 100644
--- a/quick/circuit/circuit.py
+++ b/quick/circuit/circuit.py
@@ -20,7 +20,7 @@
 __all__ = ["Circuit"]
 
 from abc import ABC, abstractmethod
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from contextlib import contextmanager
 import copy
 import cmath
@@ -29,19 +29,22 @@
 from numpy.typing import NDArray
 from types import NotImplementedType
 from typing import (
-    Any, Callable, Literal, overload, SupportsFloat, SupportsIndex, TYPE_CHECKING
+    Any, Literal, overload, SupportsFloat, SupportsIndex, TYPE_CHECKING
 )
 
 import qiskit # type: ignore
 import cirq # type: ignore
 import pennylane as qml # type: ignore
-import pytket
+import pytket # type: ignore
 import quimb.tensor as qtn # type: ignore
 
 if TYPE_CHECKING:
     from quick.backend import Backend
 from quick.circuit.circuit_utils import (
-    multiplexed_rz_angles, decompose_multiplexor_rotations, extract_single_qubits_and_diagonal, simplify
+    multiplexed_rz_angles,
+    decompose_multiplexor_rotations,
+    extract_single_qubits_and_diagonal,
+    simplify
 )
 from quick.circuit.dag import DAGCircuit
 from quick.circuit.from_framework import FromCirq, FromPennyLane, FromQiskit, FromTKET
@@ -53,7 +56,7 @@
     UnitaryPreparation, ShannonDecomposition, QiskitUnitaryTranspiler
 )
 
-EPSILON = 1e-10
+EPSILON = 1e-15
 
 """ Set the frozensets for the keys to be used:
 - Decorator `Circuit.gatemethod()`
@@ -4654,7 +4657,7 @@ def _Diagonal(
 
         # Repeatedly apply the decomposition of Theorem 7 from [1]
         while num_diagonal_entries >= 2:
-            rz_angles = []
+            rz_angles: list[float] = []
 
             # Extract the RZ angles and the relative phase
             # between the two diagonal entries
@@ -4715,8 +4718,8 @@ def Multiplexor(
             single_qubit_gates: list[NDArray[np.complex128]],
             control_indices: int | Sequence[int],
             target_index: int,
-            up_to_diagonal: bool=False,
-            multiplexor_simplification: bool=True,
+            up_to_diagonal: bool = False,
+            multiplexor_simplification: bool = True,
             control_state: str | None = None
         ) -> None:
         """ Apply a multiplexed/uniformly controlled gate to the circuit.
@@ -4785,6 +4788,12 @@ def Multiplexor(
         ...             [[0, 1],
         ...              [1, 0]]], multiplexor_simplification=False, control_state="01")
         """
+        # If there are no control indices, we use the ZYZ decomposition
+        # to apply the single qubit gate
+        if not control_indices:
+            self.unitary(single_qubit_gates[0], target_index)
+            return
+
         if isinstance(control_indices, int):
             control_indices = [control_indices]
 
@@ -4793,17 +4802,22 @@ def Multiplexor(
                 raise ValueError(f"The dimension of a gate is not equal to 2x2. Received {gate.shape}.")
 
         # Check if number of gates in gate_list is a positive power of two
-        num_control = np.log2(len(single_qubit_gates))
-        if num_control < 0 or not int(num_control) == num_control:
+        num_controls = int(
+            np.log2(
+                len(single_qubit_gates)
+            )
+        )
+
+        if num_controls < 0 or not int(num_controls) == num_controls:
             raise ValueError(
                 "The number of single-qubit gates is not a non-negative power of 2."
             )
 
-        if not num_control == len(control_indices):
+        if not num_controls == len(control_indices):
             raise ValueError(
                 "The number of control qubits passed must be equal to the number of gates. "
                 f"Received {len(control_indices)}. "
-                f"Expected {int(num_control)}."
+                f"Expected {int(num_controls)}."
             )
 
         # Check if the single-qubit gates are unitaries
@@ -4816,23 +4830,19 @@ def Multiplexor(
         # If the multiplexor simplification is enabled, we simplify the multiplexor
         # based on [2]
         if multiplexor_simplification:
-            new_controls, single_qubit_gates = simplify(single_qubit_gates, int(num_control))
-            control_indices = [qubits[len(control_indices) + 1 - i] for i in new_controls]
+            new_controls, single_qubit_gates = simplify(single_qubit_gates, num_controls)
+            control_indices = [qubits[num_controls + 1 - i] for i in new_controls]
             control_indices.reverse()
 
-        # If there are no control indices, we use the ZYZ decomposition
-        # to apply the single qubit gate
-        if not control_indices:
-            self.unitary(single_qubit_gates[0], target_index)
-            return
-
         # If there is at least one control qubit, we decompose the multiplexor
         # into a sequence of single-qubit gates and CX gates
-        (single_qubit_gates, diagonal) = extract_single_qubits_and_diagonal(
+        single_qubit_gates, diagonal = extract_single_qubits_and_diagonal(
             single_qubit_gates,
             len(control_indices) + 1
         )
 
+        num_single_qubit_gates = len(single_qubit_gates)
+
         # Now, it is easy to place the CX gates and some Hadamards and RZ(pi/2) gates
         # which are absorbed into the single-qubit unitaries to get back the full decomposition
         # of the multiplexor
@@ -4842,7 +4852,7 @@ def Multiplexor(
                     self.unitary(gate, target_index)
                     self.H(target_index)
 
-                elif i == len(single_qubit_gates) - 1:
+                elif i == num_single_qubit_gates - 1:
                     self.H(target_index)
                     self.RZ(-PI2, target_index)
                     self.unitary(gate, target_index)
@@ -4859,12 +4869,10 @@ def Multiplexor(
                 num_trailing_zeros = len(binary_rep) - len(binary_rep.rstrip("0"))
                 control_index = num_trailing_zeros
 
-                # Apply the CX gate
-                if not i == len(single_qubit_gates) - 1:
+                if not i == num_single_qubit_gates - 1:
                     self.CX(control_indices[control_index], target_index)
                     self.GlobalPhase(-PI4)
 
-            # If `up_to_diagonal` is False, we apply the diagonal gate
             if not up_to_diagonal:
                 self.Diagonal(diagonal, qubit_indices=[target_index] + list(control_indices))
 
@@ -4905,9 +4913,9 @@ def merge_global_phases(self) -> None:
     def QFT(
             self,
             qubit_indices: int | Sequence[int],
-            do_swaps: bool=True,
-            approximation_degree: int=0,
-            inverse: bool=False
+            do_swaps: bool = True,
+            approximation_degree: int = 0,
+            inverse: bool = False
         ) -> None:
         r""" Apply the Quantum Fourier Transform to the circuit.
 
@@ -5081,7 +5089,7 @@ def vertical_reverse(self) -> None:
     @staticmethod
     def _horizontal_reverse(
             circuit_log: list[dict[str, Any]],
-            adjoint: bool=True
+            adjoint: bool = True
         ) -> list[dict[str, Any]]:
         """ Perform a horizontal reverse operation.
 
@@ -5135,7 +5143,7 @@ def _horizontal_reverse(
 
     def horizontal_reverse(
             self,
-            adjoint: bool=True
+            adjoint: bool = True
         ) -> None:
         """ Perform a horizontal reverse operation. This is equivalent
         to the adjoint of the circuit if `adjoint=True`. Otherwise, it
@@ -5360,7 +5368,7 @@ def get_unitary(self) -> NDArray[np.complex128]:
 
     def get_instructions(
             self,
-            include_measurements: bool=True
+            include_measurements: bool = True
         ) -> list[dict]:
         """ Get the instructions of the circuit.
 
@@ -5577,7 +5585,7 @@ def remove_measurements(
 
     def remove_measurements(
             self,
-            inplace: bool=False
+            inplace: bool = False
         ) -> Circuit | None:
         """ Remove the measurement instructions from the circuit.
 
@@ -5604,8 +5612,8 @@ def remove_measurements(
 
     def decompose(
             self,
-            reps: int=1,
-            full: bool=False
+            reps: int = 1,
+            full: bool = False
         ) -> Circuit:
         """ Decompose the gates in the circuit to their implementation gates.
 
@@ -5676,7 +5684,7 @@ def decompose(
 
     def transpile(
             self,
-            direct_transpile: bool=True,
+            direct_transpile: bool = True,
             synthesis_method: UnitaryPreparation | None = None
         ) -> None:
         """ Transpile the circuit to U3 and CX gates.
@@ -5945,7 +5953,7 @@ def update(self) -> None:
     @abstractmethod
     def to_qasm(
             self,
-            qasm_version: int=2
+            qasm_version: int = 2
         ) -> str:
         """ Convert the circuit to QASM.
 
@@ -6207,7 +6215,7 @@ def draw(self):
 
     def plot_histogram(
             self,
-            non_zeros_only: bool=False
+            non_zeros_only: bool = False
         ) -> plt.Figure:
         """ Plot the histogram of the circuit.
 
@@ -6243,6 +6251,107 @@ def plot_histogram(
 
         return figure
 
+    def __mul__(
+            self,
+            multiplier: int
+        ) -> Circuit:
+        """ Multiply the circuit by an integer to repeat the circuit.
+
+        Parameters
+        ----------
+        `multiplier` : int
+            The number of times to repeat the circuit.
+
+        Returns
+        -------
+        `new_circuit` : quick.circuit.Circuit
+            The new circuit with the repeated operations.
+
+        Raises
+        ------
+        TypeError
+            - The multiplier must be an integer.
+
+        Usage
+        -----
+        >>> new_circuit = circuit * 3
+        """
+        if not isinstance(multiplier, int):
+            raise TypeError("The multiplier must be an integer.")
+
+        new_circuit = type(self)(self.num_qubits)
+        for _ in range(multiplier):
+            new_circuit.add(self, list(range(self.num_qubits)))
+
+        return new_circuit
+
+    def __rmul__(
+            self,
+            multiplier: int
+        ) -> Circuit:
+        """ Multiply the circuit by an integer to repeat the circuit.
+        This is the right-hand side multiplication, allowing for
+        the syntax `3 * circuit`.
+
+        Parameters
+        ----------
+        `multiplier` : int
+            The number of times to repeat the circuit.
+
+        Returns
+        -------
+        `new_circuit` : quick.circuit.Circuit
+            The new circuit with the repeated operations.
+
+        Raises
+        ------
+        TypeError
+            - The multiplier must be an integer.
+
+        Usage
+        -----
+        >>> new_circuit = 3 * circuit
+        """
+        return self.__mul__(multiplier)
+
+    def __matmul__(
+            self,
+            other_circuit: Circuit
+        ) -> Circuit:
+        """ Tensor product two circuits together. This is
+        done by putting the circuits side by side.
+
+        Parameters
+        ----------
+        `other_circuit` : quick.circuit.Circuit
+            The circuit to tensor product with.
+
+        Returns
+        -------
+        `new_circuit` : quick.circuit.Circuit
+            The tensor product circuit.
+
+        Raises
+        ------
+        TypeError
+            - The other circuit must be a `quick.circuit.Circuit`.
+
+        Usage
+        -----
+        >>> new_circuit = circuit @ other_circuit
+        """
+        if not isinstance(other_circuit, Circuit):
+            raise TypeError("The other circuit must be a `quick.circuit.Circuit`.")
+
+        new_circuit = type(self)(self.num_qubits + other_circuit.num_qubits)
+        new_circuit.add(self, list(range(self.num_qubits)))
+        new_circuit.add(
+            other_circuit,
+            list(range(self.num_qubits, self.num_qubits + other_circuit.num_qubits))
+        )
+
+        return new_circuit
+
     def __getitem__(
             self,
             index: int | slice
@@ -6330,8 +6439,8 @@ def __eq__(
     def is_equivalent(
             self,
             other_circuit: Circuit,
-            check_unitary: bool=True,
-            check_dag: bool=False
+            check_unitary: bool = True,
+            check_dag: bool = False
         ) -> bool:
         """ Check if the circuit is equivalent to another circuit.
 
diff --git a/quick/circuit/circuit_utils.py b/quick/circuit/circuit_utils.py
index 46070ce..ef3721f 100644
--- a/quick/circuit/circuit_utils.py
+++ b/quick/circuit/circuit_utils.py
@@ -22,7 +22,6 @@
     "multiplexed_rz_angles",
     "extract_uvr_matrices",
     "extract_single_qubits_and_diagonal",
-    "multiplexor_diagonal_matrix",
     "simplify",
     "repetition_search",
     "repetition_verify",
@@ -39,13 +38,15 @@
 """
 SQRT2 = 1/np.sqrt(2)
 
-RZ_PI2_00 = complex(
-    SQRT2, SQRT2
+RZ_PI2_00 = np.complex128(
+    SQRT2 + SQRT2 * 1j
 )
-RZ_PI2_11 = complex(
-    SQRT2, -SQRT2
+RZ_PI2_11 = np.complex128(
+    SQRT2 - SQRT2 * 1j
 )
 
+EPSILON = 1e-10
+
 # Type hint for nested lists of floats
 Params = list[list[float] | float] | list[float]
 
@@ -185,7 +186,7 @@ def extract_uvr_matrices(
         The diagonal matrix r.
     """
     # Hermitian conjugate of b (Eq 6)
-    X = a @ np.conj(b).T
+    X = a @ b.conj().T
 
     # Determinant and phase of x
     det_X = np.linalg.det(X)
@@ -207,20 +208,24 @@ def extract_uvr_matrices(
     # Eigendecomposition of r @ x @ r (Eq 8)
     # This is done via reforming Eq 6 to be similar to an eigenvalue decomposition
     rxr = r @ X @ r
-    eigenvalues, u = np.linalg.eig(rxr)
 
-    # Put the eigenvalues into a diagonal form
-    diagonal = np.diag(np.sqrt(eigenvalues))
+    eigenvalues, u = np.linalg.eig(rxr) # type: ignore
 
-    # Handle specific case where the eigenvalue is near -i
-    if np.abs(diagonal[0, 0] + 1j) < 1e-10:
-        diagonal = np.flipud(diagonal)
+    # Handle specific case where the first eigenvalue is near -i
+    # This is done by interchanging the eigenvalues and eigenvectors (Eq 13)
+    if abs(eigenvalues[0] + 1j) < EPSILON:
+        eigenvalues = np.flipud(eigenvalues)
         u = np.fliplr(u)
 
+    diagonal = np.array([
+        [RZ_PI2_00, 0],
+        [0, RZ_PI2_11]
+    ])
+
     # Calculate v based on the decomposition (Eq 7)
-    v = diagonal @ np.conj(u).T @ np.conj(r).T @ b
+    v = diagonal @ u.conj().T @ r.conj().T @ b
 
-    return v, u, r
+    return v, u, r # type: ignore
 
 def extract_single_qubits_and_diagonal(
         single_qubit_gates: list[NDArray[np.complex128]],
@@ -284,7 +289,7 @@ def extract_single_qubits_and_diagonal(
                 single_qubit_gates[shift + len_multiplexor // 2 + i] = u
 
                 # Decompose D gates per figure 3
-                r_dagger = np.conj(r).T
+                r_dagger = r.conj().T
 
                 if multiplexor_index < num_multiplexors - 1:
                     k = shift + len_multiplexor + i
@@ -305,46 +310,6 @@ def extract_single_qubits_and_diagonal(
 
     return single_qubit_gates, diagonal
 
-def multiplexor_diagonal_matrix(
-        single_qubit_gates: list[NDArray[np.complex128]],
-        num_qubits: int,
-        simplified_controls: set[int]
-    ) -> NDArray[np.complex128]:
-    """ Get the diagonal matrix arising in the decomposition of multiplexor
-    gates given in the paper by Bergholm et al.
-
-    Notes
-    -----
-    This function to extract the diagonal matrix arising in the decomposition
-    of multiplexed gates based on the paper by Bergholm et al.
-
-    Parameters
-    ----------
-    `single_qubit_gates` : list[NDArray[np.complex128]]
-        The list of single qubit gates.
-    `num_qubits` : int
-        The number of qubits.
-
-    Returns
-    -------
-    NDArray[np.complex128]
-        The diagonal matrix.
-    """
-    _, diagonal = extract_single_qubits_and_diagonal(single_qubit_gates, num_qubits)
-
-    # Simplify the diagonal to minimize the number of controlled gates
-    # needed to implement the diagonal gate
-    if simplified_controls:
-        control_qubits = sorted([num_qubits - i for i in simplified_controls], reverse=True)
-        for i in range(num_qubits):
-            if i not in [0] + control_qubits:
-                step = 2**i
-                diagonal = np.repeat(diagonal, 2, axis=0)
-                for j in range(step, len(diagonal), 2 * step):
-                    diagonal[j:j + step] = diagonal[j - step:j]
-
-    return diagonal
-
 def simplify(
         single_qubit_gates: list[NDArray[np.complex128]],
         num_controls: int
@@ -371,29 +336,28 @@ def simplify(
     -------
     `new_controls` : set[int]
         The new set of controls.
-    `new_mux` : list[NDArray[np.complex128]]
+    `mux_copy` : list[NDArray[np.complex128]]
         The new list of single qubit gates.
     """
-    c: set[int] = set()
-    nc: set[int] = set()
+    multiplexer_controls: set[int] = set()
+    removed_control_indices: set[int] = set()
     mux_copy = single_qubit_gates.copy()
 
     # Add the position of the multiplexer controls to the set c
     for i in range(num_controls):
-        c.add(i + 1)
+        multiplexer_controls.add(i + 1)
 
     # Identify repetitions in the array and return the unnecessary
     # controls and a copy of the array, marking the repeated operators
     # as null
     if len(single_qubit_gates) > 1:
-        nc, mux_copy = repetition_search(single_qubit_gates, num_controls)
+        removed_control_indices, mux_copy = repetition_search(single_qubit_gates, num_controls)
 
     # Remove the unnecessary controls and the marked operators, creating
     # a new set of controls and a new array representing the simplified multiplexer
-    controls_tree = {x for x in c if x not in nc}
-    mux_tree = [gate for gate in mux_copy if gate is not None]
+    controls_tree = {x for x in multiplexer_controls if x not in removed_control_indices}
 
-    return controls_tree, mux_tree
+    return controls_tree, mux_copy
 
 def repetition_search(
         multiplexor: list[NDArray[np.complex128]],
@@ -419,13 +383,13 @@ def repetition_search(
 
     Returns
     -------
-    `nc` : set[int]
+    `removed_control_indices` : set[int]
         The set of removed controls.
     `mux_copy` : list[NDArray[np.complex128]]
         The new list of gates.
     """
     mux_copy = multiplexor.copy()
-    nc = set()
+    removed_control_indices = set()
     d = 1
 
     # The positions of the multiplexer whose indices are a power of two
@@ -468,16 +432,16 @@ def repetition_search(
         # and add it to the set of unnecessary controls
         if disentanglement:
             removed_control_index = level - np.log2(d)
-            nc.add(removed_control_index)
+            removed_control_indices.add(removed_control_index)
         d *= 2
 
-    return nc, mux_copy
+    return removed_control_indices, mux_copy
 
 def repetition_verify(
-        base,
-        d,
-        multiplexor,
-        mux_copy
+        base: int,
+        d: int,
+        multiplexor: list[NDArray[np.complex128]],
+        mux_copy: list[NDArray[np.complex128]]
     ) -> tuple[bool, list[NDArray[np.complex128]]]:
     """ Verify if the repetitions are valid. This is done by comparing each
     pair of operators with a distance d between them.
@@ -489,7 +453,7 @@ def repetition_verify(
     Notes
     -----
     The implementation of this simplification is based on the paper
-    by by de Carvalho et al. [1]. The pseudocode is provided in Algorithm 3.
+    by de Carvalho et al. [1]. The pseudocode is provided in Algorithm 3.
 
     [1] de Carvalho, Batista, de Veras, Araujo, da Silva,
     Quantum multiplexer simplification for state preparation (2024).
@@ -519,9 +483,11 @@ def repetition_verify(
     while i < d:
         if not np.allclose(multiplexor[base], multiplexor[next_base]):
             return False, mux_copy
-        mux_copy[next_base] = None
+        mux_copy[next_base] = None # type: ignore
         base, next_base, i = base + 1, next_base + 1, i + 1
 
+    mux_copy = [gate for gate in mux_copy if gate is not None]
+
     return True, mux_copy
 
 def flatten(array: Params) -> tuple[list[float], Params]: # pragma: no cover
@@ -530,14 +496,14 @@ def flatten(array: Params) -> tuple[list[float], Params]: # pragma: no cover
 
     Parameters
     ----------
-    `array` : Tree
+    `array` : Params
         The nested list of floats.
 
     Returns
     -------
     `flattened` : list[float]
         The flattened list of parameters.
-    `shape` : Tree
+    `shape` : Params
         The shape of the original array.
     """
     flattened: list[float] = []
@@ -562,7 +528,6 @@ def flatten(array: Params) -> tuple[list[float], Params]: # pragma: no cover
 
     return flattened, shape
 
-
 def reshape(
         flattened: list[float],
         shape: Params
@@ -573,12 +538,12 @@ def reshape(
     ----------
     `flattened` : list[float]
         The flat list of floats.
-    `shape` : Tree
+    `shape` : Params
         The shape instruction.
 
     Returns
     -------
-    `reshaped` : Tree
+    `reshaped` : Params
         The reshaped list of floats.
     """
     reshaped: Params = []
diff --git a/quick/circuit/cirqcircuit.py b/quick/circuit/cirqcircuit.py
index b140a48..ec49b23 100644
--- a/quick/circuit/cirqcircuit.py
+++ b/quick/circuit/cirqcircuit.py
@@ -19,10 +19,10 @@
 
 __all__ = ["CirqCircuit"]
 
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 import numpy as np
 from numpy.typing import NDArray
-from typing import Callable, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 import cirq
 from cirq.ops import Rx, Ry, Rz, X, Y, Z, H, S, T, I
@@ -310,7 +310,7 @@ def reset_qubit(
 
     def to_qasm(
             self,
-            qasm_version: int=2
+            qasm_version: int = 2
         ) -> str:
 
         from quick.circuit import QiskitCircuit
diff --git a/quick/circuit/from_framework/from_tket.py b/quick/circuit/from_framework/from_tket.py
index 5cd1249..98027c6 100644
--- a/quick/circuit/from_framework/from_tket.py
+++ b/quick/circuit/from_framework/from_tket.py
@@ -20,10 +20,10 @@
 __all__ = ["FromTKET"]
 
 import numpy as np
-from pytket import Circuit as TKCircuit
-from pytket._tket.circuit import Command
-from pytket import OpType
-from pytket.passes import AutoRebase
+from pytket import Circuit as TKCircuit # type: ignore
+from pytket._tket.circuit import Command # type: ignore
+from pytket import OpType # type: ignore
+from pytket.passes import AutoRebase # type: ignore
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
diff --git a/quick/circuit/pennylanecircuit.py b/quick/circuit/pennylanecircuit.py
index 614214a..fc75bee 100644
--- a/quick/circuit/pennylanecircuit.py
+++ b/quick/circuit/pennylanecircuit.py
@@ -19,11 +19,11 @@
 
 __all__ = ["PennylaneCircuit"]
 
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 import copy
 import numpy as np
 from numpy.typing import NDArray
-from typing import Callable, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 import pennylane as qml # type: ignore
 
@@ -306,7 +306,7 @@ def reset_qubit(
 
     def to_qasm(
             self,
-            qasm_version: int=2
+            qasm_version: int = 2
         ) -> str:
 
         from quick.circuit import QiskitCircuit
diff --git a/quick/circuit/qiskitcircuit.py b/quick/circuit/qiskitcircuit.py
index 4868d1e..d795454 100644
--- a/quick/circuit/qiskitcircuit.py
+++ b/quick/circuit/qiskitcircuit.py
@@ -19,10 +19,10 @@
 
 __all__ = ["QiskitCircuit"]
 
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 import numpy as np
 from numpy.typing import NDArray
-from typing import Callable, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister # type: ignore
 from qiskit.circuit.library import ( # type: ignore
@@ -260,7 +260,7 @@ def reset_qubit(
 
     def to_qasm(
             self,
-            qasm_version: int=2
+            qasm_version: int = 2
         ) -> str:
 
         if qasm_version == 2:
diff --git a/quick/circuit/quimbcircuit.py b/quick/circuit/quimbcircuit.py
index a29b6ec..f1119b1 100644
--- a/quick/circuit/quimbcircuit.py
+++ b/quick/circuit/quimbcircuit.py
@@ -19,10 +19,10 @@
 
 __all__ = ["QuimbCircuit"]
 
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 import numpy as np
 from numpy.typing import NDArray
-from typing import Callable, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 import quimb.tensor as qtn # type: ignore
 from quimb.gates import I, X, Y, Z, H, S, T, RX, RY, RZ, U3 # type: ignore
@@ -279,7 +279,7 @@ def reset_qubit(
 
     def to_qasm(
             self,
-            qasm_version: int=2
+            qasm_version: int = 2
         ) -> str:
 
         from quick.circuit import QiskitCircuit
diff --git a/quick/circuit/tketcircuit.py b/quick/circuit/tketcircuit.py
index da4c257..111948f 100644
--- a/quick/circuit/tketcircuit.py
+++ b/quick/circuit/tketcircuit.py
@@ -19,15 +19,15 @@
 
 __all__ = ["TKETCircuit"]
 
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 import numpy as np
 from numpy.typing import NDArray
-from typing import Callable, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
-from pytket import Circuit as TKCircuit
-from pytket import OpType
-from pytket.circuit import Op, QControlBox
-from pytket.extensions.qiskit import AerBackend, AerStateBackend
+from pytket import Circuit as TKCircuit # type: ignore
+from pytket import OpType # type: ignore
+from pytket.circuit import Op, QControlBox # type: ignore
+from pytket.extensions.qiskit import AerBackend, AerStateBackend # type: ignore
 
 if TYPE_CHECKING:
     from quick.backend import Backend
@@ -273,7 +273,7 @@ def reset_qubit(
 
     def to_qasm(
             self,
-            qasm_version: int=2
+            qasm_version: int = 2
         ) -> str:
 
         from quick.circuit import QiskitCircuit
diff --git a/quick/compiler/compiler.py b/quick/compiler/compiler.py
index 0446928..ba62b03 100644
--- a/quick/compiler/compiler.py
+++ b/quick/compiler/compiler.py
@@ -91,9 +91,9 @@ class Compiler:
     def __init__(
             self,
             circuit_framework: type[Circuit],
-            state_prep: type[StatePreparation]=Isometry,
-            unitary_prep: type[UnitaryPreparation]=ShannonDecomposition,
-            optimizer: Optimizer | None=None
+            state_prep: type[StatePreparation] = Isometry,
+            unitary_prep: type[UnitaryPreparation] = ShannonDecomposition,
+            optimizer: Optimizer | None = None
         ) -> None:
         """ Initialize a `quick.compiler.Compiler` object.
         """
diff --git a/quick/metrics/__init__.py b/quick/metrics/__init__.py
index f496d44..2a80faa 100644
--- a/quick/metrics/__init__.py
+++ b/quick/metrics/__init__.py
@@ -16,6 +16,7 @@
     "calculate_entanglement_range",
     "calculate_shannon_entropy",
     "calculate_entanglement_entropy",
+    "calculate_entanglement_entropy_slope",
     "calculate_hilbert_schmidt_test"
 ]
 
@@ -23,5 +24,6 @@
     calculate_entanglement_range,
     calculate_shannon_entropy,
     calculate_entanglement_entropy,
+    calculate_entanglement_entropy_slope,
     calculate_hilbert_schmidt_test
 )
\ No newline at end of file
diff --git a/quick/metrics/metrics.py b/quick/metrics/metrics.py
index 056fe1d..a6ba4c0 100644
--- a/quick/metrics/metrics.py
+++ b/quick/metrics/metrics.py
@@ -21,83 +21,68 @@
     "calculate_entanglement_range",
     "calculate_shannon_entropy",
     "calculate_entanglement_entropy",
+    "calculate_entanglement_entropy_slope",
     "calculate_hilbert_schmidt_test"
 ]
 
 import numpy as np
 from numpy.typing import NDArray
 import quimb.tensor as qtn # type: ignore
+from qiskit.quantum_info import partial_trace # type: ignore
 
-from quick.predicates import is_unitary_matrix
+from quick.predicates import is_density_matrix, is_statevector, is_unitary_matrix
 
 
-def _get_submps_indices(mps: qtn.MatrixProductState) -> list[tuple[int, int]]:
-    """ Get the indices of contiguous blocks in the MPS. For testing purposes,
-    this method is static.
+def _calculate_1d_entanglement_range(mps: qtn.MatrixProductState) -> list[tuple[int, int]]:
+    """ Get the entanglement range for entangled qubits in a 1D chain
+    by checking the virtual (bond) dimensions of the tensors at each
+    site in the MPS.
 
-    Notes
-    -----
-    Certain sites may not be entangled with the rest, and thus we can simply apply
-    a single qubit gate to them as opposed to a two qubit gate.
-
-    This reduces the overall cost of the circuit for a given layer. If all sites are
-    entangled, then the method will simply return the indices of the MPS, i.e., for
-    10 qubit system [(0, 9)]. If sites 0 and 1 are not entangled at all with the rest,
-    the method will return [(0, 0), (1,1), (2, 9)].
-
-    The implementation is based on the analytical decomposition [1].
-
-    For more information, refer to the publication below:
-    [1] Shi-Ju.
-    Encoding of Matrix Product States into Quantum Circuits of One- and Two-Qubit Gates (2020).
-    https://arxiv.org/abs/1908.07958
+    Parameters
+    ----------
+    `mps` : qtn.MatrixProductState
+        The MPS representation of the quantum state.
 
     Returns
     -------
-    `submps_indices` : list[tuple[int, int]]
-        The indices of the MPS contiguous blocks.
-
-    Usage
-    -----
-    >>> mps.get_submps_indices()
+    `entangled_blocks_indices` : list[tuple[int, int]]
+        The indices of the MPS entangled blocks.
     """
-    sub_mps_indices: list[tuple[int, int]] = []
+    entangled_blocks_indices: list[tuple[int, int]] = []
 
     if mps.L == 1:
         return [(0, 0)]
 
     for site in range(mps.L):
-        # Reset the dimension variables for each iteration
         dim_left, dim_right = 1, 1
 
         # Define the dimensions for each site
         # The first and last sites are connected to only one site
         # as opposed to the other sites in the middle which are connected
         # to two sites to their left and right
-        #
         #  |
         #  ●━━ `dim_right`
         if site == 0:
             _, dim_right = mps[site].shape # type: ignore
-        #
+
         #              |
         # `dim_left` ━━●
         elif site == (mps.L - 1):
             dim_left, _ = mps[site].shape # type: ignore
-        #
+
         #              |
         # `dim_left` ━━●━━ `dim_right`
         else:
             dim_left, _, dim_right = mps[site].shape # type: ignore
 
         if dim_left < 2 and dim_right < 2:
-            sub_mps_indices.append((site, site))
+            entangled_blocks_indices.append((site, site))
         elif dim_left < 2 and dim_right >= 2:
             temp = site
         elif dim_left >= 2 and dim_right < 2:
-            sub_mps_indices.append((temp, site))
+            entangled_blocks_indices.append((temp, site))
 
-    return sub_mps_indices
+    return entangled_blocks_indices
 
 def calculate_entanglement_range(statevector: NDArray[np.complex128]) -> list[tuple[int, int]]:
     """ Get the entanglements of the circuit.
@@ -112,11 +97,18 @@ def calculate_entanglement_range(statevector: NDArray[np.complex128]) -> list[tu
     list[tuple[int, int]]
         The entanglements of the circuit.
 
+    Raises
+    ------
+    ValueError
+        - If the input is not a statevector.
+
     Usage
     -----
     >>> entanglements = get_entanglements(statevector)
     """
-    statevector = statevector.flatten()
+    if not is_statevector(statevector):
+        raise ValueError("The input must be a statevector.")
+
     num_qubits = int(np.log2(statevector.size))
 
     # We need to have the statevector in MSB order for
@@ -127,15 +119,15 @@ def calculate_entanglement_range(statevector: NDArray[np.complex128]) -> list[tu
         .flatten()
     )
 
-    return _get_submps_indices(qtn.MatrixProductState.from_dense(statevector))
+    return _calculate_1d_entanglement_range(qtn.MatrixProductState.from_dense(statevector))
 
-def calculate_shannon_entropy(statevector: NDArray[np.complex128]) -> float:
-    """ Calculate the Shannon entropy.
+def calculate_shannon_entropy(probability_vector: NDArray[np.complex128]) -> float:
+    """ Calculate the Shannon entropy of a probability vector.
 
     Parameters
     ----------
-    `statevector` : NDArray[np.complex128]
-        The statevector of the circuit.
+    `probability_vector` : NDArray[np.complex128]
+        The probability vector.
 
     Returns
     -------
@@ -146,30 +138,124 @@ def calculate_shannon_entropy(statevector: NDArray[np.complex128]) -> float:
     -----
     >>> shannon_entropy = calculate_shannon_entropy(statevector)
     """
-    statevector = statevector[(0 < statevector) & (statevector < 1)]
-    return -np.sum(statevector * np.log2(statevector)).astype(float)
+    probability_vector = probability_vector[(0 < probability_vector) & (probability_vector < 1)]
+    return -np.sum(probability_vector * np.log2(probability_vector)).astype(float)
 
-def calculate_entanglement_entropy(statevector: NDArray[np.complex128]) -> float:
-    """ Calculate the entanglement entropy of the circuit.
+def calculate_entanglement_entropy(data: NDArray[np.complex128]) -> float:
+    """ Calculate the Von Neumann entanglement entropy from the
+    density matrix. In case of statevectors the entropy is simply
+    0.
 
     Parameters
     ----------
-    `statevector` : NDArray[np.complex128]
-        The statevector of the circuit.
+    `data` : NDArray[np.complex128]
+        The data, which can be a statevector or a density matrix.
 
     Returns
     -------
     float
-        The entanglement entropy of the circuit.
+        The entanglement entropy of the data.
+
+    Raises
+    ------
+    ValueError
+        - Input dimension matches a statevector but is not a valid statevector.
+        - The input is not a valid density matrix.
 
     Usage
     -----
-    >>> entanglement_entropy = calculate_entanglement_entropy(statevector)
+    >>> entanglement_entropy = calculate_entanglement_entropy(data)
     """
-    density_matrix = np.outer(statevector, statevector.conj())
-    eigenvalues = np.maximum(np.real(np.linalg.eigvals(density_matrix)), 0.0)
+    # Handle the case of statevectors
+    # and ensure the density matrix is
+    # valid
+    if data.ndim == 1:
+        if is_statevector(data):
+            return 0.0
+        else:
+            raise ValueError(
+                "Input dimension matches a statevector "
+                "but is not a valid statevector."
+            )
+    if data.ndim == 2:
+        if data.shape[1] == 1:
+            if is_statevector(data):
+                return 0.0
+            else:
+                raise ValueError(
+                    "Input dimension matches a statevector "
+                    "but is not a valid statevector."
+                )
+        else:
+            if not is_density_matrix(data):
+                raise ValueError("The input is not a valid density matrix.")
+
+    eigenvalues = np.maximum(np.real(np.linalg.eigvals(data)), 0.0)
     return calculate_shannon_entropy(eigenvalues)
 
+def calculate_entanglement_entropy_slope(statevector: NDArray[np.complex128]) -> float:
+    """ Calculate the slope of the entanglement entropy. This is
+    used to determine whether a state is area-law or volume-law
+    entangled, which is a measure of how the entanglement entropy
+    scales with the number of qubits.
+
+    If the slope is 1, which is a straight line, then the state is
+    volume-law entangled. If the entropy decays after a while and
+    forms a decaying curve, then the state is area-law entangled.
+
+    Parameters
+    ----------
+    `statevector` : NDArray[np.complex128]
+        The statevector of the circuit.
+
+    Returns
+    -------
+    `slope` : float
+        The slope of the entanglement entropy of the circuit.
+
+    Raises
+    ------
+    ValueError
+        - The input must be a statevector.
+
+    Usage
+    -----
+    >>> entanglement_entropy_slope = calculate_entanglement_entropy_slope(statevector)
+    """
+    if not is_statevector(statevector):
+        raise ValueError("The input must be a statevector.")
+
+    num_qubits = int(
+        np.ceil(
+            np.log2(len(statevector))
+        )
+    )
+
+    max_k = num_qubits // 2
+    entropies = np.empty(max_k, dtype=np.float64)
+
+    for k in range(1, max_k + 1):
+        # Trace out rest of the qubits to extract the
+        # reduced density matrix for the first k qubits
+        rho_A = partial_trace(statevector, list(range(k, num_qubits))) # type: ignore
+        S = calculate_entanglement_entropy(rho_A.data)
+        entropies[k - 1] = S
+
+    # We use half of the entropies to calculate the slope
+    # for efficiency
+    entropies = entropies[len(entropies) // 2:]
+    x = np.arange(1, len(entropies) + 1)
+
+    x_mean = np.mean(x)
+    y_mean = np.mean(entropies)
+
+    numerator = np.sum((x - x_mean) * (entropies - y_mean))
+    denominator = np.sum((x - x_mean) ** 2)
+
+    slope = numerator / denominator if denominator != 0 else 0
+
+    return float(slope)
+
 def calculate_hilbert_schmidt_test(
         unitary_1: NDArray[np.complex128],
         unitary_2: NDArray[np.complex128]
diff --git a/quick/optimizer/tket2optimizer.py b/quick/optimizer/tket2optimizer.py
index 89df9f7..efb5105 100644
--- a/quick/optimizer/tket2optimizer.py
+++ b/quick/optimizer/tket2optimizer.py
@@ -19,7 +19,7 @@
 
 __all__ = ["TKET2Optimizer"]
 
-from tket2.passes import badger_pass
+from tket2.passes import badger_pass # type: ignore
 
 from quick.circuit import Circuit, TKETCircuit
 from quick.optimizer.optimizer import Optimizer
diff --git a/quick/predicates/__init__.py b/quick/predicates/__init__.py
index 7f7729e..7423163 100644
--- a/quick/predicates/__init__.py
+++ b/quick/predicates/__init__.py
@@ -21,7 +21,8 @@
     "is_unitary_matrix",
     "is_hermitian_matrix",
     "is_positive_semidefinite_matrix",
-    "is_isometry"
+    "is_isometry",
+    "is_density_matrix"
 ]
 
 from quick.predicates.predicates import (
@@ -33,5 +34,6 @@
     is_unitary_matrix,
     is_hermitian_matrix,
     is_positive_semidefinite_matrix,
-    is_isometry
+    is_isometry,
+    is_density_matrix
 )
\ No newline at end of file
diff --git a/quick/predicates/predicates.py b/quick/predicates/predicates.py
index 396f9d4..c96ed7f 100644
--- a/quick/predicates/predicates.py
+++ b/quick/predicates/predicates.py
@@ -26,7 +26,8 @@
     "is_unitary_matrix",
     "is_hermitian_matrix",
     "is_positive_semidefinite_matrix",
-    "is_isometry"
+    "is_isometry",
+    "is_density_matrix"
 ]
 
 import numpy as np
@@ -60,7 +61,9 @@ def _is_power(
 
 def is_statevector(
         statevector: NDArray[np.complex128],
-        system_size: int=2
+        system_size: int = 2,
+        rtol: float = RTOL_DEFAULT,
+        atol: float = ATOL_DEFAULT
     ) -> bool:
     """ Test if an array is a statevector.
 
@@ -72,6 +75,10 @@ def is_statevector(
         The size of the quantum memory. If the size is 2, then the
         system uses qubits. If the size is 3, then the system uses qutrits,
         and so on.
+    `rtol` : float, optional, default=RTOL_DEFAULT
+        The relative tolerance parameter.
+    `atol` : float, optional, default=ATOL_DEFAULT
+        The absolute tolerance parameter.
 
     Returns
     -------
@@ -93,7 +100,15 @@ def is_statevector(
     if not _is_power(system_size, len(statevector)):
         return False
 
-    return np.linalg.norm(statevector) == 1 and statevector.ndim == 1 and len(statevector) > 1
+    if statevector.ndim == 2:
+        if statevector.shape[1] == 1:
+            statevector = statevector.flatten()
+
+    return (
+        bool(np.isclose(np.linalg.norm(statevector), 1.0, rtol=rtol, atol=atol))
+        and statevector.ndim == 1
+        and len(statevector) > 1
+    )
 
 def is_square_matrix(matrix: NDArray[np.complex128]) -> bool:
     """ Test if an array is a square matrix.
@@ -119,8 +134,8 @@ def is_square_matrix(matrix: NDArray[np.complex128]) -> bool:
 
 def is_diagonal_matrix(
         matrix: NDArray[np.complex128],
-        rtol: float=RTOL_DEFAULT,
-        atol: float=ATOL_DEFAULT
+        rtol: float = RTOL_DEFAULT,
+        atol: float = ATOL_DEFAULT
     ) -> bool:
     """ Test if an array is a diagonal matrix.
 
@@ -149,8 +164,8 @@ def is_diagonal_matrix(
 
 def is_symmetric_matrix(
         matrix: NDArray[np.complex128],
-        rtol: float=RTOL_DEFAULT,
-        atol: float=ATOL_DEFAULT
+        rtol: float = RTOL_DEFAULT,
+        atol: float = ATOL_DEFAULT
     ) -> bool:
     """ Test if an array is a symmetric matrix.
 
@@ -179,9 +194,9 @@ def is_symmetric_matrix(
 
 def is_identity_matrix(
         matrix: NDArray[np.complex128],
-        ignore_phase: bool=False,
-        rtol: float=RTOL_DEFAULT,
-        atol: float=ATOL_DEFAULT
+        ignore_phase: bool = False,
+        rtol: float = RTOL_DEFAULT,
+        atol: float = ATOL_DEFAULT
     ) -> bool:
     """ Test if an array is an identity matrix.
 
@@ -220,8 +235,8 @@ def is_identity_matrix(
 
 def is_unitary_matrix(
         matrix: NDArray[np.complex128],
-        rtol: float=RTOL_DEFAULT,
-        atol: float=ATOL_DEFAULT
+        rtol: float = RTOL_DEFAULT,
+        atol: float = ATOL_DEFAULT
     ) -> bool:
     """ Test if an array is a unitary matrix.
 
@@ -246,13 +261,13 @@ def is_unitary_matrix(
     if not is_square_matrix(matrix):
         return False
 
-    matrix = np.conj(matrix.T).dot(matrix)
+    matrix = matrix.conj().T @ matrix
     return is_identity_matrix(matrix, ignore_phase=False, rtol=rtol, atol=atol)
 
 def is_hermitian_matrix(
         matrix: NDArray[np.complex128],
-        rtol: float=RTOL_DEFAULT,
-        atol: float=ATOL_DEFAULT
+        rtol: float = RTOL_DEFAULT,
+        atol: float = ATOL_DEFAULT
     ) -> bool:
     """ Test if an array is a Hermitian matrix.
 
@@ -277,12 +292,12 @@ def is_hermitian_matrix(
     if not is_square_matrix(matrix):
         return False
 
-    return np.allclose(matrix, np.conj(matrix.T), rtol=rtol, atol=atol)
+    return np.allclose(matrix, matrix.conj().T, rtol=rtol, atol=atol)
 
 def is_positive_semidefinite_matrix(
         matrix: NDArray[np.complex128],
-        rtol: float=RTOL_DEFAULT,
-        atol: float=ATOL_DEFAULT
+        rtol: float = RTOL_DEFAULT,
+        atol: float = ATOL_DEFAULT
     ) -> bool:
     """ Test if a matrix is positive semidefinite.
 
@@ -316,8 +331,8 @@ def is_positive_semidefinite_matrix(
 
 def is_isometry(
         matrix: NDArray[np.complex128],
-        rtol: float=RTOL_DEFAULT,
-        atol: float=ATOL_DEFAULT
+        rtol: float = RTOL_DEFAULT,
+        atol: float = ATOL_DEFAULT
     ) -> bool:
     """ Test if an array is an isometry.
 
@@ -343,5 +358,39 @@ def is_isometry(
         return False
 
     identity = np.eye(matrix.shape[1])
-    matrix = np.conj(matrix.T).dot(matrix)
-    return np.allclose(matrix, identity, rtol=rtol, atol=atol)
\ No newline at end of file
+    matrix = matrix.conj().T @ matrix
+    return np.allclose(matrix, identity, rtol=rtol, atol=atol)
+
+def is_density_matrix(
+        rho: NDArray[np.complex128],
+        rtol: float = RTOL_DEFAULT,
+        atol: float = ATOL_DEFAULT
+    ) -> bool:
+    """ Test if an array is a density matrix.
+
+    Parameters
+    ----------
+    `rho` : NDArray[np.complex128]
+        The input matrix.
+    `rtol` : float, optional, default=RTOL_DEFAULT
+        The relative tolerance parameter.
+    `atol` : float, optional, default=ATOL_DEFAULT
+        The absolute tolerance parameter.
+
+    Returns
+    -------
+    bool
+        True if the matrix is a density matrix, False otherwise.
+
+    Usage
+    -----
+    >>> is_density_matrix(np.eye(2))
+    """
+    if not (
+        is_hermitian_matrix(rho, rtol=rtol, atol=atol)
+        and is_positive_semidefinite_matrix(rho, rtol=rtol, atol=atol)
+        and np.isclose(np.trace(rho), 1.0, rtol=rtol, atol=atol)
+    ):
+        return False
+
+    return True
\ No newline at end of file
diff --git a/quick/random/__init__.py b/quick/random/__init__.py
index b2f6305..ad5e766 100644
--- a/quick/random/__init__.py
+++ b/quick/random/__init__.py
@@ -14,7 +14,12 @@
 
 __all__ = [
     "generate_random_state",
-    "generate_random_unitary"
+    "generate_random_unitary",
+    "generate_random_density_matrix"
 ]
 
-from quick.random.random import generate_random_state, generate_random_unitary
\ No newline at end of file
+from quick.random.random import (
+    generate_random_state,
+    generate_random_unitary,
+    generate_random_density_matrix
+)
\ No newline at end of file
diff --git a/quick/random/random.py b/quick/random/random.py
index d848c93..a37f29d 100644
--- a/quick/random/random.py
+++ b/quick/random/random.py
@@ -16,14 +16,39 @@
 
 __all__ = [
     "generate_random_state",
-    "generate_random_unitary"
+    "generate_random_unitary",
+    "generate_random_density_matrix"
 ]
 
 import numpy as np
 from numpy.typing import NDArray
 from scipy.stats import unitary_group # type: ignore
+from typing import Literal
 
 
+def _generate_ginibre_matrix(
+        num_rows: int,
+        num_columns: int,
+    ) -> NDArray[np.complex128]:
+    """ Return a normally distributed complex random matrix.
+
+    Parameters
+    ----------
+    `num_rows` : int
+        Number of rows in output matrix.
+    `num_columns` : int
+        Number of columns in output matrix.
+
+    Returns
+    -------
+    `ginibre_ensemble` : NDArray[np.complex128]
+        A complex rectangular matrix where each real and imaginary
+        entry is sampled from the normal distribution.
+    """
+    rng = np.random.default_rng()
+    ginibre_ensemble = rng.normal(size=(num_rows, num_columns)) + 1j * rng.normal(size=(num_rows, num_columns))
+    return ginibre_ensemble
+
 def generate_random_state(num_qubits: int) -> NDArray[np.complex128]:
     """ Generate a random state vector for the given number of qubits.
 
@@ -53,4 +78,49 @@ def generate_random_unitary(num_qubits: int) -> NDArray[np.complex128]:
     `NDArray[np.complex128]`
         The random unitary matrix.
     """
-    return unitary_group.rvs(2 ** num_qubits).astype(np.complex128)
\ No newline at end of file
+    return unitary_group.rvs(2 ** num_qubits).astype(np.complex128)
+
+def generate_random_density_matrix(
+        num_qubits: int,
+        rank: int | None = None,
+        generator: Literal["hilbert-schmidt", "bures"] = "hilbert-schmidt"
+    ) -> NDArray[np.complex128]:
+    """ Generate a random density matrix.
+
+    Parameters
+    ----------
+    `num_qubits` : int
+        The number of qubits in the density matrix.
+    `rank` : int, optional, default=None
+        The rank of the density matrix. If None, the matrix is full-rank,
+        where rank is set to the number of qubits.
+    `generator` : Literal["hilbert-schmidt", "bures"], optional, default="hilbert-schmidt"
+        The method to use for generating the density matrix.
+        Options are "hilbert-schmidt" or "bures".
+
+    Returns
+    -------
+    NDArray[np.complex128]
+        The generated random density matrix.
+
+    Raises
+    ------
+    ValueError
+        - If the `generator` is not recognized.
+    """
+    if not rank:
+        rank = num_qubits
+
+    if generator not in ["hilbert-schmidt", "bures"]:
+        raise ValueError(f"Unrecognized generator method: {generator}")
+
+    ginibre_ensemble = _generate_ginibre_matrix(2**num_qubits, 2**rank)
+
+    if generator == "hilbert-schmidt":
+        density_matrix = ginibre_ensemble @ ginibre_ensemble.conj().T
+    elif generator == "bures":
+        density_matrix = np.eye(2**num_qubits) + generate_random_unitary(num_qubits)
+        density_matrix = density_matrix @ ginibre_ensemble
+        density_matrix = density_matrix @ density_matrix.conj().T
+
+    return density_matrix / np.trace(density_matrix)
\ No newline at end of file
diff --git a/quick/synthesis/gate_decompositions/one_qubit_decomposition.py b/quick/synthesis/gate_decompositions/one_qubit_decomposition.py
index 6987b54..d26c9ac 100644
--- a/quick/synthesis/gate_decompositions/one_qubit_decomposition.py
+++ b/quick/synthesis/gate_decompositions/one_qubit_decomposition.py
@@ -68,7 +68,7 @@ class OneQubitDecomposition(UnitaryPreparation):
     def __init__(
             self,
             output_framework: type[Circuit],
-            basis: Literal["zyz", "u3"]="u3"
+            basis: Literal["zyz", "u3"] = "u3"
         ) -> None:
 
         super().__init__(output_framework)
diff --git a/quick/synthesis/gate_decompositions/two_qubit_decomposition/two_qubit_decomposition.py b/quick/synthesis/gate_decompositions/two_qubit_decomposition/two_qubit_decomposition.py
index 7a351bd..e7f6d6d 100644
--- a/quick/synthesis/gate_decompositions/two_qubit_decomposition/two_qubit_decomposition.py
+++ b/quick/synthesis/gate_decompositions/two_qubit_decomposition/two_qubit_decomposition.py
@@ -46,97 +46,97 @@
 Q0L = np.array([
     [0.5+0.5j, 0.5-0.5j],
     [-0.5-0.5j, 0.5-0.5j]
-], dtype=complex)
+], dtype=np.complex128)
 
 Q0R = np.array([
     [-0.5-0.5j, 0.5-0.5j],
     [-0.5-0.5j, -0.5+0.5j]
-], dtype=complex)
+], dtype=np.complex128)
 
 Q1LA = np.array([
     [0.+0.j, -1-1j],
     [1-1j, 0.+0.j]
-], dtype=complex) * SQRT2
+], dtype=np.complex128) * SQRT2
 
 Q1LB = np.array([
     [-0.5+0.5j, -0.5-0.5j],
     [0.5-0.5j, -0.5-0.5j]
-], dtype=complex)
+], dtype=np.complex128)
 
 Q1RA = np.array([
     [1+0.j, 1+0.j],
     [-1+0.j, 1+0.j]
-], dtype=complex) * SQRT2
+], dtype=np.complex128) * SQRT2
 
 Q1RB = np.array([
     [0.5-0.5j, 0.5+0.5j],
     [-0.5+0.5j, 0.5+0.5j]
-], dtype=complex)
+], dtype=np.complex128)
 
 Q2L = np.array([
     [-1+1j, 0.+0.j],
     [0.+0.j, -1-1j]
-], dtype=complex) * SQRT2
+], dtype=np.complex128) * SQRT2
 
 Q2R = np.array([
     [0.+1j, 0.-1j],
     [0.-1j, 0.-1j]
-], dtype=complex) * SQRT2
+], dtype=np.complex128) * SQRT2
 
 U0L: NDArray[np.complex128] = np.array([
     [-1, 1],
     [-1, -1]
-], dtype=complex) * SQRT2
+], dtype=np.complex128) * SQRT2
 
 U0R: NDArray[np.complex128] = np.array([
     [-1j, 1j],
     [1j, 1j]
-], dtype=complex) * SQRT2
+], dtype=np.complex128) * SQRT2
 
 U1L: NDArray[np.complex128] = np.array([
     [-0.5+0.5j, -0.5+0.5j],
     [0.5+0.5j, -0.5-0.5j]
-], dtype=complex)
+], dtype=np.complex128)
 
 U1RA: NDArray[np.complex128] = np.array([
     [0.5-0.5j, -0.5-0.5j],
     [0.5-0.5j, 0.5+0.5j]
-], dtype=complex)
+], dtype=np.complex128)
 
 UR1B: NDArray[np.complex128] = np.array([
     [-1, -1j],
     [-1j, -1]
-], dtype=complex) * SQRT2
+], dtype=np.complex128) * SQRT2
 
 u2la: NDArray[np.complex128] = np.array([
     [0.5+0.5j, 0.5-0.5j],
     [-0.5-0.5j, 0.5-0.5j]
-], dtype=complex)
+], dtype=np.complex128)
 
 U2LB: NDArray[np.complex128] = np.array([
     [-0.5+0.5j, -0.5-0.5j],
     [0.5-0.5j, -0.5-0.5j]
-], dtype=complex)
+], dtype=np.complex128)
 
 U2RA: NDArray[np.complex128] = np.array([
     [-0.5+0.5j, 0.5-0.5j],
     [-0.5-0.5j, -0.5-0.5j]
-], dtype=complex)
+], dtype=np.complex128)
 
 U2RB: NDArray[np.complex128] = np.array([
     [0.5-0.5j, 0.5+0.5j],
     [-0.5+0.5j, 0.5+0.5j]
-], dtype=complex)
+], dtype=np.complex128)
 
 U3L: NDArray[np.complex128] = np.array([
     [-1+1j, 0+0j],
     [0+0j, -1-1j]
-], dtype=complex) * SQRT2
+], dtype=np.complex128) * SQRT2
 
 U3R: NDArray[np.complex128] = np.array([
     [1j, -1j],
     [-1j, -1j]
-], dtype=complex) * SQRT2
+], dtype=np.complex128) * SQRT2
 
 
 class TwoQubitDecomposition(UnitaryPreparation):
diff --git a/quick/synthesis/gate_decompositions/two_qubit_decomposition/weyl.py b/quick/synthesis/gate_decompositions/two_qubit_decomposition/weyl.py
index 56724eb..10032f7 100644
--- a/quick/synthesis/gate_decompositions/two_qubit_decomposition/weyl.py
+++ b/quick/synthesis/gate_decompositions/two_qubit_decomposition/weyl.py
@@ -36,6 +36,7 @@
 import numpy as np
 from numpy.typing import NDArray
 import scipy.linalg # type: ignore
+import warnings
 
 """ Define the M matrix from section III to
 tranform the unitary matrix into the magic basis:
@@ -56,7 +57,7 @@
     [0, 0, 1j, 1],
     [0, 0, 1j, -1],
     [1, -1j, 0, 0]
-], dtype=complex)
+], dtype=np.complex128)
 
 M_UNNORMALIZED_DAGGER = 0.5 * M_UNNORMALIZED.conj().T
 
@@ -64,17 +65,17 @@
 X_MAGIC_BASIS = np.array([
     [0, 1j],
     [1j, 0]
-], dtype=complex)
+], dtype=np.complex128)
 
 Y_MAGIC_BASIS = np.array([
     [0, 1],
     [-1, 0]
-], dtype=complex)
+], dtype=np.complex128)
 
 Z_MAGIC_BASIS = np.array([
     [1j, 0],
     [0, -1j]
-], dtype=complex)
+], dtype=np.complex128)
 
 # Constants
 PI = np.pi
@@ -85,7 +86,7 @@
 
 def transform_to_magic_basis(
         U: NDArray[np.complex128],
-        reverse: bool=False
+        reverse: bool = False
     ) -> NDArray[np.complex128]:
     """ Transform the 4x4 matrix `U` into the magic basis.
 
@@ -185,7 +186,7 @@ def weyl_coordinates(U: NDArray[np.complex128]) -> NDArray[np.float64]:
 
 def partition_eigenvalues(
         eigenvalues: NDArray[np.complex128],
-        atol: float=1e-13
+        atol: float = 1e-13
     ) -> list[list[int]]:
     """ Group the indices of degenerate eigenvalues.
 
@@ -283,7 +284,7 @@ def diagonalize_unitary_complex_symmetric(
     # If there are no degenerate subspaces, we return the eigenvalues and identity matrix
     # as the eigenvectors
     if len(spaces) == 1:
-        return eigenvalues, np.eye(4).astype(complex) # type: ignore
+        return eigenvalues, np.eye(4).astype(np.complex128) # type: ignore
 
     out_vectors = np.empty((4, 4), dtype=np.float64)
     n_done = 0
@@ -298,17 +299,17 @@ def diagonalize_unitary_complex_symmetric(
         # This is the hardest case, because there might not have even one real vector
         a, b = eigenvectors[:, spaces[0]].T
         b_zeros = np.abs(b) <= atol
+
         if np.any(np.abs(a[b_zeros]) > atol):
             # Make `a` real where `b` has zeros.
             a = remove_global_phase(a, index=np.argmax(np.where(b_zeros, np.abs(a), 0)))
-        if np.max(np.abs(a.imag)) <= atol:
-            # `a` is already all real
-            pass
-        else:
+
+        if np.max(np.abs(a.imag)) > atol:
             # We have to solve `(b.imag, b.real) @ (re, im).T = a.imag` for `re`
             # and `im`, which is overspecified
             multiplier, *_ = scipy.linalg.lstsq(np.transpose([b.imag, b.real]), a.imag) # type: ignore
             a = a - complex(*multiplier) * b
+
         a = a.real / scipy.linalg.norm(a.real)
         b = remove_global_phase(b - (a @ b) * a)
         out_vectors[:, :2] = np.transpose([a, b.real])
@@ -362,8 +363,6 @@ def decompose_two_qubit_product_gate(
     -----
     >>> L, R, phase = decompose_two_qubit_product_gate(np.eye(4))
     """
-    special_unitary_matrix = np.asarray(special_unitary_matrix, dtype=complex)
-
     # Extract the right component
     R = special_unitary_matrix[:2, :2].copy()
     R_det = R[0, 0] * R[1, 1] - R[0, 1] * R[1, 0]
@@ -450,7 +449,17 @@ def decompose_unitary(unitary_matrix: NDArray[np.complex128]) -> tuple[
             NDArray[np.complex128],
             float
         ]:
-        """ Decompose a two-qubit unitary matrix into the Weyl coordinates and the product of two single-qubit unitaries.
+        """ Decompose a two-qubit unitary matrix into the Weyl coordinates and the
+        product of two single-qubit unitaries.
+
+        Notes
+        -----
+        M2 diagnolization may be wrong due to floating point errors, but it will work
+        correctly in Linux. Should you encounter a failure in the code, and the result
+        fails to encode the correct unitary matrix, please report it at
+        https://github.com/Qualition/quick/issues/11
+
+        with the unitary matrix that caused the failure.
 
         Parameters
         ----------
@@ -476,33 +485,37 @@ def decompose_unitary(unitary_matrix: NDArray[np.complex128]) -> tuple[
         `global_phase` : float
             The global phase.
 
+        Raises
+        ------
+        ValueError
+            - If the determinant of the right or left component is
+            not in the expected range.
+            - If the decomposition fails due to a deviation from the
+            expected unitary matrix.
+
         Usage
         -----
         >>> a, b, c, K1l, K1r, K2l, K2r, global_phase = TwoQubitWeylDecomposition.decompose_unitary(np.eye(4))
         """
         # Make U be in SU(4)
-        U = np.array(unitary_matrix, dtype=complex, copy=True)
+        U = np.array(unitary_matrix, dtype=np.complex128, copy=True)
         U_det = scipy.linalg.det(U)
         U *= U_det ** (-0.25)
         global_phase = cmath.phase(U_det) / 4
 
-        U_magic_basis = transform_to_magic_basis(U.astype(complex), reverse=True)
-        M2 = U_magic_basis.T.dot(U_magic_basis)
+        U_magic_basis = transform_to_magic_basis(U, reverse=True)
+        M2 = np.round(U_magic_basis.T.dot(U_magic_basis), decimals=15)
 
-        # There is a floating point error in this implementation
-        # for certain U, which depends on OS and Python version
-        # This causes the numpy.linalg.eig() to produce different results
-        # for the same input matrix, leading to a decomposition failure
-        # To contribute to this issue, please refer to:
-        # https://github.com/Qualition/quick/issues/11
+        D, P = diagonalize_unitary_complex_symmetric(M2)
 
-        # Alternatively, you may propose an entirely new implementation
-        # so that we can replace this two qubit decomposition implementation
-        # with a more robust one that doesn't have floating point errors
-        # To contribute to this feature request, please refer to:
-        # https://github.com/Qualition/quick/issues/14
+        # Given P is a real-symmetric unitary matrix we only use transpose
+        if not np.allclose(P.dot(np.diag(D)).dot(P.T), M2, rtol=0, atol=1e-13):
+            warnings.warn(
+                "Failed to diagonalize M2."
+                "Kindly report this at https://github.com/Qualition/quick/issues/11: "
+                f"U: {U}"
+            )
 
-        D, P = diagonalize_unitary_complex_symmetric(M2)
         d = -np.angle(D) / 2
         d[3] = -d[0] - d[1] - d[2]
         weyl_coordinates = np.mod((d[:3] + d[3]) / 2, PI_DOUBLE)
diff --git a/quick/synthesis/statepreparation/isometry.py b/quick/synthesis/statepreparation/isometry.py
index 4a46d76..f406cec 100644
--- a/quick/synthesis/statepreparation/isometry.py
+++ b/quick/synthesis/statepreparation/isometry.py
@@ -88,8 +88,8 @@ def apply_state(
             circuit: Circuit,
             state: NDArray[np.complex128] | Bra | Ket,
             qubit_indices: int | Sequence[int],
-            compression_percentage: float=0.0,
-            index_type: Literal["row", "snake"]="row"
+            compression_percentage: float = 0.0,
+            index_type: Literal["row", "snake"] = "row"
         ) -> Circuit:
 
         if not isinstance(state, (np.ndarray, Bra, Ket)):
diff --git a/quick/synthesis/statepreparation/mottonen.py b/quick/synthesis/statepreparation/mottonen.py
index 16dd907..94c8e09 100644
--- a/quick/synthesis/statepreparation/mottonen.py
+++ b/quick/synthesis/statepreparation/mottonen.py
@@ -72,8 +72,8 @@ def apply_state(
             circuit: Circuit,
             state: NDArray[np.complex128] | Bra | Ket,
             qubit_indices: int | Sequence[int],
-            compression_percentage: float=0.0,
-            index_type: Literal["row", "snake"]="row"
+            compression_percentage: float = 0.0,
+            index_type: Literal["row", "snake"] = "row"
         ) -> Circuit:
 
         if not isinstance(state, (np.ndarray, Bra, Ket)):
diff --git a/quick/synthesis/statepreparation/shende.py b/quick/synthesis/statepreparation/shende.py
index 2f3059e..51ea24a 100644
--- a/quick/synthesis/statepreparation/shende.py
+++ b/quick/synthesis/statepreparation/shende.py
@@ -70,8 +70,8 @@ def apply_state(
             circuit: Circuit,
             state: NDArray[np.complex128] | Bra | Ket,
             qubit_indices: int | Sequence[int],
-            compression_percentage: float=0.0,
-            index_type: Literal["row", "snake"]="row"
+            compression_percentage: float = 0.0,
+            index_type: Literal["row", "snake"] = "row"
         ) -> Circuit:
 
         if not isinstance(state, (np.ndarray, Bra, Ket)):
diff --git a/quick/synthesis/statepreparation/statepreparation.py b/quick/synthesis/statepreparation/statepreparation.py
index 97dbba8..e9d01a0 100644
--- a/quick/synthesis/statepreparation/statepreparation.py
+++ b/quick/synthesis/statepreparation/statepreparation.py
@@ -68,8 +68,8 @@ def __init__(
     def prepare_state(
             self,
             state: NDArray[np.complex128] | Bra | Ket,
-            compression_percentage: float=0.0,
-            index_type: Literal["row", "snake"]="row"
+            compression_percentage: float = 0.0,
+            index_type: Literal["row", "snake"] = "row"
         ) -> Circuit:
         """ Prepare the quantum state.
 
@@ -112,8 +112,8 @@ def apply_state(
             circuit: Circuit,
             state: NDArray[np.complex128] | Bra | Ket,
             qubit_indices: int | Sequence[int],
-            compression_percentage: float=0.0,
-            index_type: Literal["row", "snake"]="row"
+            compression_percentage: float = 0.0,
+            index_type: Literal["row", "snake"] = "row"
         ) -> Circuit:
         """ Apply the quantum state to a quantum circuit.
 
diff --git a/quick/synthesis/statepreparation/statepreparation_utils.py b/quick/synthesis/statepreparation/statepreparation_utils.py
index 7530a1c..401c1a0 100644
--- a/quick/synthesis/statepreparation/statepreparation_utils.py
+++ b/quick/synthesis/statepreparation/statepreparation_utils.py
@@ -522,7 +522,7 @@ def apply_diagonal_gate_to_diag(
     NDArray[np.complex128]
         The diagonal matrix after applying the diagonal gate.
     """
-    if not m_diagonal:
+    if m_diagonal.size == 0:
         return m_diagonal
     for state in product([0, 1], repeat=num_qubits):
         diagonal_index = sum(state[i] << (len(action_qubit_labels) - 1 - idx) for idx, i in enumerate(action_qubit_labels))
diff --git a/quick/synthesis/unitarypreparation/diffusion.py b/quick/synthesis/unitarypreparation/diffusion.py
index 6e8de97..4dfd21c 100644
--- a/quick/synthesis/unitarypreparation/diffusion.py
+++ b/quick/synthesis/unitarypreparation/diffusion.py
@@ -19,14 +19,15 @@
 
 __all__ = ["Diffusion"]
 
+from collections.abc import Sequence
 from genQC.pipeline.diffusion_pipeline import DiffusionPipeline # type: ignore
 from genQC.inference.infer_compilation import generate_comp_tensors, convert_tensors_to_circuits # type: ignore
 import genQC.util as util # type: ignore
 import numpy as np
 from numpy.typing import NDArray
 from qiskit.quantum_info import Operator as QiskitOperator # type: ignore
-import torch
-from typing import Sequence, SupportsIndex, TYPE_CHECKING
+import torch # type: ignore
+from typing import SupportsIndex, TYPE_CHECKING
 
 import quick
 if TYPE_CHECKING:
@@ -98,11 +99,11 @@ class Diffusion(UnitaryPreparation):
     def __init__(
             self,
             output_framework: type[Circuit],
-            model: str="Floki00/qc_unitary_3qubit",
-            prompt: str="Compile using: ['h', 'cx', 'z', 'ccx', 'swap']",
-            max_num_gates: int=12,
-            num_samples: int=128,
-            min_fidelity: float=0.99
+            model: str = "Floki00/qc_unitary_3qubit",
+            prompt: str = "Compile using: ['h', 'cx', 'z', 'ccx', 'swap']",
+            max_num_gates: int = 12,
+            num_samples: int = 128,
+            min_fidelity: float = 0.99
         ) -> None:
 
         super().__init__(output_framework)
diff --git a/quick/synthesis/unitarypreparation/qiskit_unitary_transpiler.py b/quick/synthesis/unitarypreparation/qiskit_unitary_transpiler.py
index 371c8ee..12684a2 100644
--- a/quick/synthesis/unitarypreparation/qiskit_unitary_transpiler.py
+++ b/quick/synthesis/unitarypreparation/qiskit_unitary_transpiler.py
@@ -28,7 +28,7 @@
 from qiskit import QuantumCircuit, transpile # type: ignore
 from qiskit.transpiler.passes import unitary_synthesis_plugin_names # type: ignore
 from qiskit_ibm_runtime import QiskitRuntimeService # type: ignore
-from qiskit_transpiler_service.transpiler_service import TranspilerService # type: ignore
+from qiskit_ibm_transpiler.transpiler_service import TranspilerService # type: ignore
 
 if TYPE_CHECKING:
     from quick.circuit import Circuit
@@ -97,8 +97,8 @@ class QiskitUnitaryTranspiler(UnitaryPreparation):
     def __init__(
             self,
             output_framework: type[Circuit],
-            ai_transpilation: bool=False,
-            unitary_synthesis_plugin: str="default",
+            ai_transpilation: bool = False,
+            unitary_synthesis_plugin: str = "default",
             service: QiskitRuntimeService | None = None,
             backend_name: str | None = None
         ) -> None:
diff --git a/quick/synthesis/unitarypreparation/shannon_decomposition.py b/quick/synthesis/unitarypreparation/shannon_decomposition.py
index 6df9dcf..e5fccbb 100644
--- a/quick/synthesis/unitarypreparation/shannon_decomposition.py
+++ b/quick/synthesis/unitarypreparation/shannon_decomposition.py
@@ -142,7 +142,7 @@ def quantum_shannon_decomposition(
                 circuit: Circuit,
                 qubit_indices: list[int],
                 unitary: NDArray[np.complex128],
-                recursion_depth: int=0
+                recursion_depth: int = 0
             ) -> None:
             """ Decompose n-qubit unitary into CX/RY/RZ/CX gates, preserving global phase.
 
@@ -226,7 +226,7 @@ def demultiplexor(
                 demux_qubits: list[int],
                 unitary_1: NDArray[np.complex128],
                 unitary_2: NDArray[np.complex128],
-                recursion_depth: int=0
+                recursion_depth: int = 0
             ) -> None:
             """ Decompose a multiplexor defined by a pair of unitary matrices operating on
             the same subspace per Theorem 12.
@@ -291,8 +291,8 @@ def demultiplexor(
             # Take the square root of the eigenvalues to obtain the singular values
             # This is necessary because the singular values provide a more convenient form
             # for constructing the diagonal matrix D, which is used in the final decomposition
-            # We need to use `np.emath.sqrt` to handle negative eigenvalues
-            eigenvalues_sqrt = np.emath.sqrt(eigenvalues)
+            # We need to use `np.lib.scimath.sqrt` to handle negative eigenvalues
+            eigenvalues_sqrt = np.lib.scimath.sqrt(eigenvalues)
 
             # Create a diagonal matrix D from the singular values
             # The diagonal matrix D is used to scale the eigenvectors appropriately in the final step
diff --git a/tests/backend/qiskit_backends/test_ibm_backend.py b/tests/backend/qiskit_backends/test_ibm_backend.py
index c7f73bd..b6380fe 100644
--- a/tests/backend/qiskit_backends/test_ibm_backend.py
+++ b/tests/backend/qiskit_backends/test_ibm_backend.py
@@ -97,7 +97,7 @@ def get_operator(
     def get_counts(
             self,
             circuit: Circuit,
-            num_shots: int=1024
+            num_shots: int = 1024
         ) -> dict[str, int]:
 
         # Create a copy of the circuit as measurement is applied inplace
diff --git a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_no_simplification_3qubits_01control_HXHX.npy b/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_no_simplification_3qubits_01control_HXHX.npy
deleted file mode 100644
index 1e30cd2..0000000
Binary files a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_no_simplification_3qubits_01control_HXHX.npy and /dev/null differ
diff --git a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_no_simplification_3qubits_10control_HYHY.npy b/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_no_simplification_3qubits_10control_HYHY.npy
deleted file mode 100644
index 0ac8dc2..0000000
Binary files a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_no_simplification_3qubits_10control_HYHY.npy and /dev/null differ
diff --git a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_no_simplification_4qubits_023control_RXRYRXRYRXRY.npy b/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_no_simplification_4qubits_023control_RXRYRXRYRXRY.npy
deleted file mode 100644
index f9200c3..0000000
Binary files a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_no_simplification_4qubits_023control_RXRYRXRYRXRY.npy and /dev/null differ
diff --git a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_no_simplification_4qubits_213control_RXRYRXRYRXRY.npy b/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_no_simplification_4qubits_213control_RXRYRXRYRXRY.npy
deleted file mode 100644
index 33376d8..0000000
Binary files a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_no_simplification_4qubits_213control_RXRYRXRYRXRY.npy and /dev/null differ
diff --git a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_simplification_3qubits_01control_HXHX.npy b/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_simplification_3qubits_01control_HXHX.npy
deleted file mode 100644
index 12df6a3..0000000
Binary files a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_simplification_3qubits_01control_HXHX.npy and /dev/null differ
diff --git a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_simplification_3qubits_10control_HYHY.npy b/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_simplification_3qubits_10control_HYHY.npy
deleted file mode 100644
index f6152f0..0000000
Binary files a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_simplification_3qubits_10control_HYHY.npy and /dev/null differ
diff --git a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_simplification_4qubits_023control_RXRYRXRYRXRY.npy b/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_simplification_4qubits_023control_RXRYRXRYRXRY.npy
deleted file mode 100644
index f9200c3..0000000
Binary files a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_simplification_4qubits_023control_RXRYRXRYRXRY.npy and /dev/null differ
diff --git a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_simplification_4qubits_213control_RXRYRXRYRXRY.npy b/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_simplification_4qubits_213control_RXRYRXRYRXRY.npy
deleted file mode 100644
index 33376d8..0000000
Binary files a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_diagonal_simplification_4qubits_213control_RXRYRXRYRXRY.npy and /dev/null differ
diff --git a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_no_simplification_3qubits_01control_HXHX.npy b/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_no_simplification_3qubits_01control_HXHX.npy
deleted file mode 100644
index 13aad2c..0000000
Binary files a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_no_simplification_3qubits_01control_HXHX.npy and /dev/null differ
diff --git a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_no_simplification_3qubits_10control_HYHY.npy b/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_no_simplification_3qubits_10control_HYHY.npy
deleted file mode 100644
index 060bc31..0000000
Binary files a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_no_simplification_3qubits_10control_HYHY.npy and /dev/null differ
diff --git a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_no_simplification_4qubits_023control_RXRYRXRYRXRY.npy b/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_no_simplification_4qubits_023control_RXRYRXRYRXRY.npy
deleted file mode 100644
index ba5dd70..0000000
Binary files a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_no_simplification_4qubits_023control_RXRYRXRYRXRY.npy and /dev/null differ
diff --git a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_no_simplification_4qubits_213control_RXRYRXRYRXRY.npy b/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_no_simplification_4qubits_213control_RXRYRXRYRXRY.npy
deleted file mode 100644
index 226cf2c..0000000
Binary files a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_no_simplification_4qubits_213control_RXRYRXRYRXRY.npy and /dev/null differ
diff --git a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_simplification_3qubits_01control_HXHX.npy b/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_simplification_3qubits_01control_HXHX.npy
deleted file mode 100644
index ff9755a..0000000
Binary files a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_simplification_3qubits_01control_HXHX.npy and /dev/null differ
diff --git a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_simplification_3qubits_10control_HYHY.npy b/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_simplification_3qubits_10control_HYHY.npy
deleted file mode 100644
index 711ae84..0000000
Binary files a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_simplification_3qubits_10control_HYHY.npy and /dev/null differ
diff --git a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_simplification_4qubits_023control_RXRYRXRYRXRY.npy b/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_simplification_4qubits_023control_RXRYRXRYRXRY.npy
deleted file mode 100644
index ba5dd70..0000000
Binary files a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_simplification_4qubits_023control_RXRYRXRYRXRY.npy and /dev/null differ
diff --git a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_simplification_4qubits_213control_RXRYRXRYRXRY.npy b/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_simplification_4qubits_213control_RXRYRXRYRXRY.npy
deleted file mode 100644
index 226cf2c..0000000
Binary files a/tests/circuit/gate_matrix_checkers/UC_unitary_matrix_no_diagonal_simplification_4qubits_213control_RXRYRXRYRXRY.npy and /dev/null differ
diff --git a/tests/circuit/gate_utils.py b/tests/circuit/gate_utils.py
index cb82384..6a61b03 100644
--- a/tests/circuit/gate_utils.py
+++ b/tests/circuit/gate_utils.py
@@ -357,22 +357,6 @@
     "UCRZ_unitary_matrix_3qubits_10control",
     "UCRZ_unitary_matrix_4qubits_023control",
     "UCRZ_unitary_matrix_4qubits_213control",
-    "UC_unitary_matrix_no_diagonal_no_simplification_3qubits_01control_HXHX",
-    "UC_unitary_matrix_no_diagonal_no_simplification_3qubits_10control_HYHY",
-    "UC_unitary_matrix_no_diagonal_no_simplification_4qubits_023control_RXRYRXRYRXRY",
-    "UC_unitary_matrix_no_diagonal_no_simplification_4qubits_213control_RXRYRXRYRXRY",
-    "UC_unitary_matrix_diagonal_no_simplification_3qubits_01control_HXHX",
-    "UC_unitary_matrix_diagonal_no_simplification_3qubits_10control_HYHY",
-    "UC_unitary_matrix_diagonal_no_simplification_4qubits_023control_RXRYRXRYRXRY",
-    "UC_unitary_matrix_diagonal_no_simplification_4qubits_213control_RXRYRXRYRXRY",
-    "UC_unitary_matrix_no_diagonal_simplification_3qubits_01control_HXHX",
-    "UC_unitary_matrix_no_diagonal_simplification_3qubits_10control_HYHY",
-    "UC_unitary_matrix_no_diagonal_simplification_4qubits_023control_RXRYRXRYRXRY",
-    "UC_unitary_matrix_no_diagonal_simplification_4qubits_213control_RXRYRXRYRXRY",
-    "UC_unitary_matrix_diagonal_simplification_3qubits_01control_HXHX",
-    "UC_unitary_matrix_diagonal_simplification_3qubits_10control_HYHY",
-    "UC_unitary_matrix_diagonal_simplification_4qubits_023control_RXRYRXRYRXRY",
-    "UC_unitary_matrix_diagonal_simplification_4qubits_213control_RXRYRXRYRXRY",
     "qft_no_swap_no_inverse_approx0_5qubits",
     "qft_no_swap_no_inverse_approx0_6qubits",
     "qft_no_swap_no_inverse_approx0_7qubits",
@@ -436,7 +420,7 @@
     "qft_swap_inverse_approx3_5qubits",
     "qft_swap_inverse_approx3_6qubits",
     "qft_swap_inverse_approx3_7qubits",
-    "qft_swap_inverse_approx3_8qubits"
+    "qft_swap_inverse_approx3_8qubits",
 ]
 
 import numpy as np
@@ -519,7 +503,9 @@
 `global_shift` = 1/3
 `qubit_indices` = 0
 """
-XPow_global_shift_unitary_matrix = np.load(prefix + "XPow_global_shift_unitary_matrix.npy")
+XPow_global_shift_unitary_matrix = np.load(
+    prefix + "XPow_global_shift_unitary_matrix.npy"
+)
 
 """ circuit.YPow() tester
 
@@ -539,7 +525,9 @@
 `global_shift` = 1/3
 `qubit_indices` = 0
 """
-YPow_global_shift_unitary_matrix = np.load(prefix + "YPow_global_shift_unitary_matrix.npy")
+YPow_global_shift_unitary_matrix = np.load(
+    prefix + "YPow_global_shift_unitary_matrix.npy"
+)
 
 """ circuit.ZPow() tester
 
@@ -559,7 +547,9 @@
 `global_shift` = 1/3
 `qubit_indices` = 0
 """
-ZPow_global_shift_unitary_matrix = np.load(prefix + "ZPow_global_shift_unitary_matrix.npy")
+ZPow_global_shift_unitary_matrix = np.load(
+    prefix + "ZPow_global_shift_unitary_matrix.npy"
+)
 
 """ circuit.RXX() tester
 
@@ -569,7 +559,9 @@
 `first_qubit_index` = 0
 `second_qubit_index` = 1
 """
-RXX_unitary_matrix_pi_over_4_01qubits = np.load(prefix + "RXX_unitary_matrix_pi_over_4_01qubits.npy")
+RXX_unitary_matrix_pi_over_4_01qubits = np.load(
+    prefix + "RXX_unitary_matrix_pi_over_4_01qubits.npy"
+)
 
 """ circuit.RXX() tester
 
@@ -579,7 +571,9 @@
 `first_qubit_index` = 1
 `second_qubit_index` = 0
 """
-RXX_unitary_matrix_pi_over_4_10qubits = np.load(prefix + "RXX_unitary_matrix_pi_over_4_10qubits.npy")
+RXX_unitary_matrix_pi_over_4_10qubits = np.load(
+    prefix + "RXX_unitary_matrix_pi_over_4_10qubits.npy"
+)
 
 """ circuit.RXX() tester
 
@@ -589,7 +583,9 @@
 `first_qubit_index` = 0
 `second_qubit_index` = 2
 """
-RXX_unitary_matrix_1_over_4_02qubits = np.load(prefix + "RXX_unitary_matrix_1_over_4_02qubits.npy")
+RXX_unitary_matrix_1_over_4_02qubits = np.load(
+    prefix + "RXX_unitary_matrix_1_over_4_02qubits.npy"
+)
 
 """ circuit.RXX() tester
 
@@ -599,7 +595,9 @@
 `first_qubit_index` = 2
 `second_qubit_index` = 0
 """
-RXX_unitary_matrix_1_over_4_20qubits = np.load(prefix + "RXX_unitary_matrix_1_over_4_20qubits.npy")
+RXX_unitary_matrix_1_over_4_20qubits = np.load(
+    prefix + "RXX_unitary_matrix_1_over_4_20qubits.npy"
+)
 
 """ circuit.RXX() tester
 
@@ -609,7 +607,9 @@
 `first_qubit_index` = 1
 `second_qubit_index` = 2
 """
-RXX_unitary_matrix_pi_over_4_12qubits = np.load(prefix + "RXX_unitary_matrix_pi_over_4_12qubits.npy")
+RXX_unitary_matrix_pi_over_4_12qubits = np.load(
+    prefix + "RXX_unitary_matrix_pi_over_4_12qubits.npy"
+)
 
 """ circuit.RYY() tester
 
@@ -619,7 +619,9 @@
 `first_qubit_index` = 0
 `second_qubit_index` = 1
 """
-RYY_unitary_matrix_pi_over_4_01qubits = np.load(prefix + "RYY_unitary_matrix_pi_over_4_01qubits.npy")
+RYY_unitary_matrix_pi_over_4_01qubits = np.load(
+    prefix + "RYY_unitary_matrix_pi_over_4_01qubits.npy"
+)
 
 """ circuit.RYY() tester
 
@@ -629,7 +631,9 @@
 `first_qubit_index` = 1
 `second_qubit_index` = 0
 """
-RYY_unitary_matrix_pi_over_4_10qubits = np.load(prefix + "RYY_unitary_matrix_pi_over_4_10qubits.npy")
+RYY_unitary_matrix_pi_over_4_10qubits = np.load(
+    prefix + "RYY_unitary_matrix_pi_over_4_10qubits.npy"
+)
 
 """ circuit.RYY() tester
 
@@ -639,7 +643,9 @@
 `first_qubit_index` = 0
 `second_qubit_index` = 2
 """
-RYY_unitary_matrix_1_over_4_02qubits = np.load(prefix + "RYY_unitary_matrix_1_over_4_02qubits.npy")
+RYY_unitary_matrix_1_over_4_02qubits = np.load(
+    prefix + "RYY_unitary_matrix_1_over_4_02qubits.npy"
+)
 
 """ circuit.RYY() tester
 
@@ -649,7 +655,9 @@
 `first_qubit_index` = 2
 `second_qubit_index` = 0
 """
-RYY_unitary_matrix_1_over_4_20qubits = np.load(prefix + "RYY_unitary_matrix_1_over_4_20qubits.npy")
+RYY_unitary_matrix_1_over_4_20qubits = np.load(
+    prefix + "RYY_unitary_matrix_1_over_4_20qubits.npy"
+)
 
 """ circuit.RYY() tester
 
@@ -659,7 +667,9 @@
 `first_qubit_index` = 1
 `second_qubit_index` = 2
 """
-RYY_unitary_matrix_pi_over_4_12qubits = np.load(prefix + "RYY_unitary_matrix_pi_over_4_12qubits.npy")
+RYY_unitary_matrix_pi_over_4_12qubits = np.load(
+    prefix + "RYY_unitary_matrix_pi_over_4_12qubits.npy"
+)
 
 """ circuit.RZZ() tester
 
@@ -669,7 +679,9 @@
 `first_qubit_index` = 0
 `second_qubit_index` = 1
 """
-RZZ_unitary_matrix_pi_over_4_01qubits = np.load(prefix + "RZZ_unitary_matrix_pi_over_4_01qubits.npy")
+RZZ_unitary_matrix_pi_over_4_01qubits = np.load(
+    prefix + "RZZ_unitary_matrix_pi_over_4_01qubits.npy"
+)
 
 """ circuit.RZZ() tester
 
@@ -679,7 +691,9 @@
 `first_qubit_index` = 1
 `second_qubit_index` = 0
 """
-RZZ_unitary_matrix_pi_over_4_10qubits = np.load(prefix + "RZZ_unitary_matrix_pi_over_4_10qubits.npy")
+RZZ_unitary_matrix_pi_over_4_10qubits = np.load(
+    prefix + "RZZ_unitary_matrix_pi_over_4_10qubits.npy"
+)
 
 """ circuit.RZZ() tester
 
@@ -689,7 +703,9 @@
 `first_qubit_index` = 0
 `second_qubit_index` = 2
 """
-RZZ_unitary_matrix_1_over_4_02qubits = np.load(prefix + "RZZ_unitary_matrix_1_over_4_02qubits.npy")
+RZZ_unitary_matrix_1_over_4_02qubits = np.load(
+    prefix + "RZZ_unitary_matrix_1_over_4_02qubits.npy"
+)
 
 """ circuit.RZZ() tester
 
@@ -699,7 +715,9 @@
 `first_qubit_index` = 2
 `second_qubit_index` = 0
 """
-RZZ_unitary_matrix_1_over_4_20qubits = np.load(prefix + "RZZ_unitary_matrix_1_over_4_20qubits.npy")
+RZZ_unitary_matrix_1_over_4_20qubits = np.load(
+    prefix + "RZZ_unitary_matrix_1_over_4_20qubits.npy"
+)
 
 """ circuit.RZZ() tester
 
@@ -709,7 +727,9 @@
 `first_qubit_index` = 1
 `second_qubit_index` = 2
 """
-RZZ_unitary_matrix_pi_over_4_12qubits = np.load(prefix + "RZZ_unitary_matrix_pi_over_4_12qubits.npy")
+RZZ_unitary_matrix_pi_over_4_12qubits = np.load(
+    prefix + "RZZ_unitary_matrix_pi_over_4_12qubits.npy"
+)
 
 """ circuit.SWAP() tester
 
@@ -1124,7 +1144,9 @@
 `control_qubit_index` = 0
 `target_qubit_index` = 1
 """
-CRX_unitary_matrix_pi_over_4_01qubits = np.load(prefix + "CRX_unitary_matrix_pi_over_4_01qubits.npy")
+CRX_unitary_matrix_pi_over_4_01qubits = np.load(
+    prefix + "CRX_unitary_matrix_pi_over_4_01qubits.npy"
+)
 
 """ circuit.CRX() tester
 
@@ -1134,7 +1156,9 @@
 `control_qubit_index` = 1
 `target_qubit_index` = 0
 """
-CRX_unitary_matrix_pi_over_4_10qubits = np.load(prefix + "CRX_unitary_matrix_pi_over_4_10qubits.npy")
+CRX_unitary_matrix_pi_over_4_10qubits = np.load(
+    prefix + "CRX_unitary_matrix_pi_over_4_10qubits.npy"
+)
 
 """ circuit.CRX() tester
 
@@ -1144,7 +1168,9 @@
 `control_qubit_index` = 0
 `target_qubit_index` = 2
 """
-CRX_unitary_matrix_1_over_4_02qubits = np.load(prefix + "CRX_unitary_matrix_1_over_4_02qubits.npy")
+CRX_unitary_matrix_1_over_4_02qubits = np.load(
+    prefix + "CRX_unitary_matrix_1_over_4_02qubits.npy"
+)
 
 """ circuit.CRX() tester
 
@@ -1154,7 +1180,9 @@
 `control_qubit_index` = 2
 `target_qubit_index` = 0
 """
-CRX_unitary_matrix_1_over_4_20qubits = np.load(prefix + "CRX_unitary_matrix_1_over_4_20qubits.npy")
+CRX_unitary_matrix_1_over_4_20qubits = np.load(
+    prefix + "CRX_unitary_matrix_1_over_4_20qubits.npy"
+)
 
 """ circuit.CRX() tester
 
@@ -1164,7 +1192,9 @@
 `control_qubit_index` = 1
 `target_qubit_index` = 2
 """
-CRX_unitary_matrix_pi_over_4_12qubits = np.load(prefix + "CRX_unitary_matrix_pi_over_4_12qubits.npy")
+CRX_unitary_matrix_pi_over_4_12qubits = np.load(
+    prefix + "CRX_unitary_matrix_pi_over_4_12qubits.npy"
+)
 
 """ circuit.CRY() tester
 
@@ -1174,7 +1204,9 @@
 `control_qubit_index` = 0
 `target_qubit_index` = 1
 """
-CRY_unitary_matrix_pi_over_4_01qubits = np.load(prefix + "CRY_unitary_matrix_pi_over_4_01qubits.npy")
+CRY_unitary_matrix_pi_over_4_01qubits = np.load(
+    prefix + "CRY_unitary_matrix_pi_over_4_01qubits.npy"
+)
 
 """ circuit.CRY() tester
 
@@ -1184,7 +1216,9 @@
 `control_qubit_index` = 1
 `target_qubit_index` = 0
 """
-CRY_unitary_matrix_pi_over_4_10qubits = np.load(prefix + "CRY_unitary_matrix_pi_over_4_10qubits.npy")
+CRY_unitary_matrix_pi_over_4_10qubits = np.load(
+    prefix + "CRY_unitary_matrix_pi_over_4_10qubits.npy"
+)
 
 """ circuit.CRY() tester
 
@@ -1194,7 +1228,9 @@
 `control_qubit_index` = 0
 `target_qubit_index` = 2
 """
-CRY_unitary_matrix_1_over_4_02qubits = np.load(prefix + "CRY_unitary_matrix_1_over_4_02qubits.npy")
+CRY_unitary_matrix_1_over_4_02qubits = np.load(
+    prefix + "CRY_unitary_matrix_1_over_4_02qubits.npy"
+)
 
 """ circuit.CRY() tester
 
@@ -1204,7 +1240,9 @@
 `control_qubit_index` = 2
 `target_qubit_index` = 0
 """
-CRY_unitary_matrix_1_over_4_20qubits = np.load(prefix + "CRY_unitary_matrix_1_over_4_20qubits.npy")
+CRY_unitary_matrix_1_over_4_20qubits = np.load(
+    prefix + "CRY_unitary_matrix_1_over_4_20qubits.npy"
+)
 
 """ circuit.CRY() tester
 
@@ -1214,7 +1252,9 @@
 `control_qubit_index` = 1
 `target_qubit_index` = 2
 """
-CRY_unitary_matrix_pi_over_4_12qubits = np.load(prefix + "CRY_unitary_matrix_pi_over_4_12qubits.npy")
+CRY_unitary_matrix_pi_over_4_12qubits = np.load(
+    prefix + "CRY_unitary_matrix_pi_over_4_12qubits.npy"
+)
 
 """ circuit.CRZ() tester
 
@@ -1224,7 +1264,9 @@
 `control_qubit_index` = 0
 `target_qubit_index` = 1
 """
-CRZ_unitary_matrix_pi_over_4_01qubits = np.load(prefix + "CRZ_unitary_matrix_pi_over_4_01qubits.npy")
+CRZ_unitary_matrix_pi_over_4_01qubits = np.load(
+    prefix + "CRZ_unitary_matrix_pi_over_4_01qubits.npy"
+)
 
 """ circuit.CRZ() tester
 
@@ -1234,7 +1276,9 @@
 `control_qubit_index` = 1
 `target_qubit_index` = 0
 """
-CRZ_unitary_matrix_pi_over_4_10qubits = np.load(prefix + "CRZ_unitary_matrix_pi_over_4_10qubits.npy")
+CRZ_unitary_matrix_pi_over_4_10qubits = np.load(
+    prefix + "CRZ_unitary_matrix_pi_over_4_10qubits.npy"
+)
 
 """ circuit.CRZ() tester
 
@@ -1244,7 +1288,9 @@
 `control_qubit_index` = 0
 `target_qubit_index` = 2
 """
-CRZ_unitary_matrix_1_over_4_02qubits = np.load(prefix + "CRZ_unitary_matrix_1_over_4_02qubits.npy")
+CRZ_unitary_matrix_1_over_4_02qubits = np.load(
+    prefix + "CRZ_unitary_matrix_1_over_4_02qubits.npy"
+)
 
 """ circuit.CRZ() tester
 
@@ -1254,7 +1300,9 @@
 `control_qubit_index` = 2
 `target_qubit_index` = 0
 """
-CRZ_unitary_matrix_1_over_4_20qubits = np.load(prefix + "CRZ_unitary_matrix_1_over_4_20qubits.npy")
+CRZ_unitary_matrix_1_over_4_20qubits = np.load(
+    prefix + "CRZ_unitary_matrix_1_over_4_20qubits.npy"
+)
 
 """ circuit.CRZ() tester
 
@@ -1264,7 +1312,9 @@
 `control_qubit_index` = 1
 `target_qubit_index` = 2
 """
-CRZ_unitary_matrix_pi_over_4_12qubits = np.load(prefix + "CRZ_unitary_matrix_pi_over_4_12qubits.npy")
+CRZ_unitary_matrix_pi_over_4_12qubits = np.load(
+    prefix + "CRZ_unitary_matrix_pi_over_4_12qubits.npy"
+)
 
 """ circuit.CPhase() tester
 
@@ -1274,7 +1324,9 @@
 `control_qubit_index` = 0
 `target_qubit_index` = 1
 """
-CPhase_unitary_matrix_pi_over_4_01qubits = np.load(prefix + "CPhase_unitary_matrix_pi_over_4_01qubits.npy")
+CPhase_unitary_matrix_pi_over_4_01qubits = np.load(
+    prefix + "CPhase_unitary_matrix_pi_over_4_01qubits.npy"
+)
 
 """ circuit.CPhase() tester
 
@@ -1284,7 +1336,9 @@
 `control_qubit_index` = 1
 `target_qubit_index` = 0
 """
-CPhase_unitary_matrix_pi_over_4_10qubits = np.load(prefix + "CPhase_unitary_matrix_pi_over_4_10qubits.npy")
+CPhase_unitary_matrix_pi_over_4_10qubits = np.load(
+    prefix + "CPhase_unitary_matrix_pi_over_4_10qubits.npy"
+)
 
 """ circuit.CPhase() tester
 
@@ -1294,7 +1348,9 @@
 `control_qubit_index` = 0
 `target_qubit_index` = 2
 """
-CPhase_unitary_matrix_1_over_4_02qubits = np.load(prefix + "CPhase_unitary_matrix_1_over_4_02qubits.npy")
+CPhase_unitary_matrix_1_over_4_02qubits = np.load(
+    prefix + "CPhase_unitary_matrix_1_over_4_02qubits.npy"
+)
 
 """ circuit.CPhase() tester
 
@@ -1304,7 +1360,9 @@
 `control_qubit_index` = 2
 `target_qubit_index` = 0
 """
-CPhase_unitary_matrix_1_over_4_20qubits = np.load(prefix + "CPhase_unitary_matrix_1_over_4_20qubits.npy")
+CPhase_unitary_matrix_1_over_4_20qubits = np.load(
+    prefix + "CPhase_unitary_matrix_1_over_4_20qubits.npy"
+)
 
 """ circuit.CPhase() tester
 
@@ -1314,7 +1372,9 @@
 `control_qubit_index` = 1
 `target_qubit_index` = 2
 """
-CPhase_unitary_matrix_pi_over_4_12qubits = np.load(prefix + "CPhase_unitary_matrix_pi_over_4_12qubits.npy")
+CPhase_unitary_matrix_pi_over_4_12qubits = np.load(
+    prefix + "CPhase_unitary_matrix_pi_over_4_12qubits.npy"
+)
 
 """ circuit.CXPow() tester
 
@@ -1325,7 +1385,9 @@
 `control_qubit_index` = 0
 `target_qubit_index` = 1
 """
-CXPow_unitary_matrix_1_over_4_0_shift_01qubits = np.load(prefix + "CXPow_unitary_matrix_1_over_4_0_shift_01qubits.npy")
+CXPow_unitary_matrix_1_over_4_0_shift_01qubits = np.load(
+    prefix + "CXPow_unitary_matrix_1_over_4_0_shift_01qubits.npy"
+)
 
 """ circuit.CXPow() tester
 
@@ -1336,7 +1398,9 @@
 `control_qubit_index` = 1
 `target_qubit_index` = 0
 """
-CXPow_unitary_matrix_1_over_4_0_shift_10qubits = np.load(prefix + "CXPow_unitary_matrix_1_over_4_0_shift_10qubits.npy")
+CXPow_unitary_matrix_1_over_4_0_shift_10qubits = np.load(
+    prefix + "CXPow_unitary_matrix_1_over_4_0_shift_10qubits.npy"
+)
 
 """ circuit.CXPow() tester
 
@@ -1347,7 +1411,9 @@
 `control_qubit_index` = 0
 `target_qubit_index` = 2
 """
-CXPow_unitary_matrix_1_over_4_1_over_3_shift_02qubits = np.load(prefix + "CXPow_unitary_matrix_1_over_4_1_over_3_shift_02qubits.npy")
+CXPow_unitary_matrix_1_over_4_1_over_3_shift_02qubits = np.load(
+    prefix + "CXPow_unitary_matrix_1_over_4_1_over_3_shift_02qubits.npy"
+)
 
 """ circuit.CXPow() tester
 
@@ -1358,7 +1424,9 @@
 `control_qubit_index` = 2
 `target_qubit_index` = 0
 """
-CXPow_unitary_matrix_1_over_4_1_over_3_shift_20qubits = np.load(prefix + "CXPow_unitary_matrix_1_over_4_1_over_3_shift_20qubits.npy")
+CXPow_unitary_matrix_1_over_4_1_over_3_shift_20qubits = np.load(
+    prefix + "CXPow_unitary_matrix_1_over_4_1_over_3_shift_20qubits.npy"
+)
 
 """ circuit.CXPow() tester
 
@@ -1369,7 +1437,9 @@
 `control_qubit_index` = 1
 `target_qubit_index` = 2
 """
-CXPow_unitary_matrix_negative1_over_4_0_shift_12qubits = np.load(prefix + "CXPow_unitary_matrix_negative1_over_4_0_shift_12qubits.npy")
+CXPow_unitary_matrix_negative1_over_4_0_shift_12qubits = np.load(
+    prefix + "CXPow_unitary_matrix_negative1_over_4_0_shift_12qubits.npy"
+)
 
 """ circuit.CYPow() tester
 
@@ -1380,7 +1450,9 @@
 `control_qubit_index` = 0
 `target_qubit_index` = 1
 """
-CYPow_unitary_matrix_1_over_4_0_shift_01qubits = np.load(prefix + "CYPow_unitary_matrix_1_over_4_0_shift_01qubits.npy")
+CYPow_unitary_matrix_1_over_4_0_shift_01qubits = np.load(
+    prefix + "CYPow_unitary_matrix_1_over_4_0_shift_01qubits.npy"
+)
 
 """ circuit.CYPow() tester
 
@@ -1391,7 +1463,9 @@
 `control_qubit_index` = 1
 `target_qubit_index` = 0
 """
-CYPow_unitary_matrix_1_over_4_0_shift_10qubits = np.load(prefix + "CYPow_unitary_matrix_1_over_4_0_shift_10qubits.npy")
+CYPow_unitary_matrix_1_over_4_0_shift_10qubits = np.load(
+    prefix + "CYPow_unitary_matrix_1_over_4_0_shift_10qubits.npy"
+)
 
 """ circuit.CYPow() tester
 
@@ -1402,7 +1476,9 @@
 `control_qubit_index` = 0
 `target_qubit_index` = 2
 """
-CYPow_unitary_matrix_1_over_4_1_over_3_shift_02qubits = np.load(prefix + "CYPow_unitary_matrix_1_over_4_1_over_3_shift_02qubits.npy")
+CYPow_unitary_matrix_1_over_4_1_over_3_shift_02qubits = np.load(
+    prefix + "CYPow_unitary_matrix_1_over_4_1_over_3_shift_02qubits.npy"
+)
 
 """ circuit.CYPow() tester
 
@@ -1413,7 +1489,9 @@
 `control_qubit_index` = 2
 `target_qubit_index` = 0
 """
-CYPow_unitary_matrix_1_over_4_1_over_3_shift_20qubits = np.load(prefix + "CYPow_unitary_matrix_1_over_4_1_over_3_shift_20qubits.npy")
+CYPow_unitary_matrix_1_over_4_1_over_3_shift_20qubits = np.load(
+    prefix + "CYPow_unitary_matrix_1_over_4_1_over_3_shift_20qubits.npy"
+)
 
 """ circuit.CYPow() tester
 
@@ -1424,7 +1502,9 @@
 `control_qubit_index` = 1
 `target_qubit_index` = 2
 """
-CYPow_unitary_matrix_negative1_over_4_0_shift_12qubits = np.load(prefix + "CYPow_unitary_matrix_negative1_over_4_0_shift_12qubits.npy")
+CYPow_unitary_matrix_negative1_over_4_0_shift_12qubits = np.load(
+    prefix + "CYPow_unitary_matrix_negative1_over_4_0_shift_12qubits.npy"
+)
 
 """ circuit.CZPow() tester
 
@@ -1435,7 +1515,9 @@
 `control_qubit_index` = 0
 `target_qubit_index` = 1
 """
-CZPow_unitary_matrix_1_over_4_0_shift_01qubits = np.load(prefix + "CZPow_unitary_matrix_1_over_4_0_shift_01qubits.npy")
+CZPow_unitary_matrix_1_over_4_0_shift_01qubits = np.load(
+    prefix + "CZPow_unitary_matrix_1_over_4_0_shift_01qubits.npy"
+)
 
 """ circuit.CZPow() tester
 
@@ -1446,7 +1528,9 @@
 `control_qubit_index` = 1
 `target_qubit_index` = 0
 """
-CZPow_unitary_matrix_1_over_4_0_shift_10qubits = np.load(prefix + "CZPow_unitary_matrix_1_over_4_0_shift_10qubits.npy")
+CZPow_unitary_matrix_1_over_4_0_shift_10qubits = np.load(
+    prefix + "CZPow_unitary_matrix_1_over_4_0_shift_10qubits.npy"
+)
 
 """ circuit.CZPow() tester
 
@@ -1457,7 +1541,9 @@
 `control_qubit_index` = 0
 `target_qubit_index` = 2
 """
-CZPow_unitary_matrix_1_over_4_1_over_3_shift_02qubits = np.load(prefix + "CZPow_unitary_matrix_1_over_4_1_over_3_shift_02qubits.npy")
+CZPow_unitary_matrix_1_over_4_1_over_3_shift_02qubits = np.load(
+    prefix + "CZPow_unitary_matrix_1_over_4_1_over_3_shift_02qubits.npy"
+)
 
 """ circuit.CZPow() tester
 
@@ -1468,7 +1554,9 @@
 `control_qubit_index` = 2
 `target_qubit_index` = 0
 """
-CZPow_unitary_matrix_1_over_4_1_over_3_shift_20qubits = np.load(prefix + "CZPow_unitary_matrix_1_over_4_1_over_3_shift_20qubits.npy")
+CZPow_unitary_matrix_1_over_4_1_over_3_shift_20qubits = np.load(
+    prefix + "CZPow_unitary_matrix_1_over_4_1_over_3_shift_20qubits.npy"
+)
 
 """ circuit.CZPow() tester
 
@@ -1479,7 +1567,9 @@
 `control_qubit_index` = 1
 `target_qubit_index` = 2
 """
-CZPow_unitary_matrix_negative1_over_4_0_shift_12qubits = np.load(prefix + "CZPow_unitary_matrix_negative1_over_4_0_shift_12qubits.npy")
+CZPow_unitary_matrix_negative1_over_4_0_shift_12qubits = np.load(
+    prefix + "CZPow_unitary_matrix_negative1_over_4_0_shift_12qubits.npy"
+)
 
 """ circuit.CRXX() tester
 
@@ -1490,7 +1580,9 @@
 `first_target_index` = 1
 `second_target_index` = 2
 """
-CRXX_unitary_matrix_pi_over_4_012qubits = np.load(prefix + "CRXX_unitary_matrix_pi_over_4_012qubits.npy")
+CRXX_unitary_matrix_pi_over_4_012qubits = np.load(
+    prefix + "CRXX_unitary_matrix_pi_over_4_012qubits.npy"
+)
 
 """ circuit.CRXX() tester
 
@@ -1501,7 +1593,9 @@
 `first_target_index` = 0
 `second_target_index` = 2
 """
-CRXX_unitary_matrix_pi_over_4_102qubits = np.load(prefix + "CRXX_unitary_matrix_pi_over_4_102qubits.npy")
+CRXX_unitary_matrix_pi_over_4_102qubits = np.load(
+    prefix + "CRXX_unitary_matrix_pi_over_4_102qubits.npy"
+)
 
 """ circuit.CRXX() tester
 
@@ -1512,7 +1606,9 @@
 `first_target_index` = 2
 `second_target_index` = 3
 """
-CRXX_unitary_matrix_1_over_4_123qubits = np.load(prefix + "CRXX_unitary_matrix_1_over_4_123qubits.npy")
+CRXX_unitary_matrix_1_over_4_123qubits = np.load(
+    prefix + "CRXX_unitary_matrix_1_over_4_123qubits.npy"
+)
 
 """ circuit.CRXX() tester
 
@@ -1523,7 +1619,9 @@
 `first_target_index` = 1
 `second_target_index` = 3
 """
-CRXX_unitary_matrix_1_over_4_213qubits = np.load(prefix + "CRXX_unitary_matrix_1_over_4_213qubits.npy")
+CRXX_unitary_matrix_1_over_4_213qubits = np.load(
+    prefix + "CRXX_unitary_matrix_1_over_4_213qubits.npy"
+)
 
 """ circuit.CRXX() tester
 
@@ -1534,7 +1632,9 @@
 `first_target_index` = 2
 `second_target_index` = 3
 """
-CRXX_unitary_matrix_pi_over_4_023qubits = np.load(prefix + "CRXX_unitary_matrix_pi_over_4_023qubits.npy")
+CRXX_unitary_matrix_pi_over_4_023qubits = np.load(
+    prefix + "CRXX_unitary_matrix_pi_over_4_023qubits.npy"
+)
 
 """ circuit.CRYY() tester
 
@@ -1545,7 +1645,9 @@
 `first_target_index` = 1
 `second_target_index` = 2
 """
-CRYY_unitary_matrix_pi_over_4_012qubits = np.load(prefix + "CRYY_unitary_matrix_pi_over_4_012qubits.npy")
+CRYY_unitary_matrix_pi_over_4_012qubits = np.load(
+    prefix + "CRYY_unitary_matrix_pi_over_4_012qubits.npy"
+)
 
 """ circuit.CRYY() tester
 
@@ -1556,7 +1658,9 @@
 `first_target_index` = 0
 `second_target_index` = 2
 """
-CRYY_unitary_matrix_pi_over_4_102qubits = np.load(prefix + "CRYY_unitary_matrix_pi_over_4_102qubits.npy")
+CRYY_unitary_matrix_pi_over_4_102qubits = np.load(
+    prefix + "CRYY_unitary_matrix_pi_over_4_102qubits.npy"
+)
 
 """ circuit.CRYY() tester
 
@@ -1567,7 +1671,9 @@
 `first_target_index` = 2
 `second_target_index` = 3
 """
-CRYY_unitary_matrix_1_over_4_123qubits = np.load(prefix + "CRYY_unitary_matrix_1_over_4_123qubits.npy")
+CRYY_unitary_matrix_1_over_4_123qubits = np.load(
+    prefix + "CRYY_unitary_matrix_1_over_4_123qubits.npy"
+)
 
 """ circuit.CRYY() tester
 
@@ -1578,7 +1684,9 @@
 `first_target_index` = 1
 `second_target_index` = 3
 """
-CRYY_unitary_matrix_1_over_4_213qubits = np.load(prefix + "CRYY_unitary_matrix_1_over_4_213qubits.npy")
+CRYY_unitary_matrix_1_over_4_213qubits = np.load(
+    prefix + "CRYY_unitary_matrix_1_over_4_213qubits.npy"
+)
 
 """ circuit.CRYY() tester
 
@@ -1589,7 +1697,9 @@
 `first_target_index` = 2
 `second_target_index` = 3
 """
-CRYY_unitary_matrix_pi_over_4_023qubits = np.load(prefix + "CRYY_unitary_matrix_pi_over_4_023qubits.npy")
+CRYY_unitary_matrix_pi_over_4_023qubits = np.load(
+    prefix + "CRYY_unitary_matrix_pi_over_4_023qubits.npy"
+)
 
 """ circuit.CRZZ() tester
 
@@ -1600,7 +1710,9 @@
 `first_target_index` = 1
 `second_target_index` = 2
 """
-CRZZ_unitary_matrix_pi_over_4_012qubits = np.load(prefix + "CRZZ_unitary_matrix_pi_over_4_012qubits.npy")
+CRZZ_unitary_matrix_pi_over_4_012qubits = np.load(
+    prefix + "CRZZ_unitary_matrix_pi_over_4_012qubits.npy"
+)
 
 """ circuit.CRZZ() tester
 
@@ -1611,7 +1723,9 @@
 `first_target_index` = 0
 `second_target_index` = 2
 """
-CRZZ_unitary_matrix_pi_over_4_102qubits = np.load(prefix + "CRZZ_unitary_matrix_pi_over_4_102qubits.npy")
+CRZZ_unitary_matrix_pi_over_4_102qubits = np.load(
+    prefix + "CRZZ_unitary_matrix_pi_over_4_102qubits.npy"
+)
 
 """ circuit.CRZZ() tester
 
@@ -1622,7 +1736,9 @@
 `first_target_index` = 2
 `second_target_index` = 3
 """
-CRZZ_unitary_matrix_1_over_4_123qubits = np.load(prefix + "CRZZ_unitary_matrix_1_over_4_123qubits.npy")
+CRZZ_unitary_matrix_1_over_4_123qubits = np.load(
+    prefix + "CRZZ_unitary_matrix_1_over_4_123qubits.npy"
+)
 
 """ circuit.CRZZ() tester
 
@@ -1633,7 +1749,9 @@
 `first_target_index` = 1
 `second_target_index` = 3
 """
-CRZZ_unitary_matrix_1_over_4_213qubits = np.load(prefix + "CRZZ_unitary_matrix_1_over_4_213qubits.npy")
+CRZZ_unitary_matrix_1_over_4_213qubits = np.load(
+    prefix + "CRZZ_unitary_matrix_1_over_4_213qubits.npy"
+)
 
 """ circuit.CRZZ() tester
 
@@ -1644,7 +1762,9 @@
 `first_target_index` = 2
 `second_target_index` = 3
 """
-CRZZ_unitary_matrix_pi_over_4_023qubits = np.load(prefix + "CRZZ_unitary_matrix_pi_over_4_023qubits.npy")
+CRZZ_unitary_matrix_pi_over_4_023qubits = np.load(
+    prefix + "CRZZ_unitary_matrix_pi_over_4_023qubits.npy"
+)
 
 """ circuit.CU3() tester
 
@@ -1654,7 +1774,9 @@
 `control_index` = 0
 `target_index` = 1
 """
-CU3_unitary_matrix_pi2_pi3_pi4_01qubits = np.load(prefix + "CU3_unitary_matrix_pi2_pi3_pi4_01qubits.npy")
+CU3_unitary_matrix_pi2_pi3_pi4_01qubits = np.load(
+    prefix + "CU3_unitary_matrix_pi2_pi3_pi4_01qubits.npy"
+)
 
 """ circuit.CU3() tester
 
@@ -1664,7 +1786,9 @@
 `control_index` = 1
 `target_index` = 0
 """
-CU3_unitary_matrix_pi2_pi3_pi4_10qubits = np.load(prefix + "CU3_unitary_matrix_pi2_pi3_pi4_10qubits.npy")
+CU3_unitary_matrix_pi2_pi3_pi4_10qubits = np.load(
+    prefix + "CU3_unitary_matrix_pi2_pi3_pi4_10qubits.npy"
+)
 
 """ circuit.CU3() tester
 
@@ -1674,7 +1798,9 @@
 `control_index` = 0
 `target_index` = 1
 """
-CU3_unitary_matrix_pi2_pi3_pi4_02qubits = np.load(prefix + "CU3_unitary_matrix_pi2_pi3_pi4_02qubits.npy")
+CU3_unitary_matrix_pi2_pi3_pi4_02qubits = np.load(
+    prefix + "CU3_unitary_matrix_pi2_pi3_pi4_02qubits.npy"
+)
 
 """ circuit.CU3() tester
 
@@ -1684,7 +1810,9 @@
 `control_index` = 0
 `target_index` = 1
 """
-CU3_unitary_matrix_pi2_pi3_pi4_20qubits = np.load(prefix + "CU3_unitary_matrix_pi2_pi3_pi4_20qubits.npy")
+CU3_unitary_matrix_pi2_pi3_pi4_20qubits = np.load(
+    prefix + "CU3_unitary_matrix_pi2_pi3_pi4_20qubits.npy"
+)
 
 """ circuit.CU3() tester
 
@@ -1694,7 +1822,9 @@
 `control_index` = 1
 `target_index` = 2
 """
-CU3_unitary_matrix_pi2_pi3_pi4_12qubits = np.load(prefix + "CU3_unitary_matrix_pi2_pi3_pi4_12qubits.npy")
+CU3_unitary_matrix_pi2_pi3_pi4_12qubits = np.load(
+    prefix + "CU3_unitary_matrix_pi2_pi3_pi4_12qubits.npy"
+)
 
 """ circuit.CSWAP() tester
 
@@ -1750,89 +1880,107 @@
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3]
 """
-MCX_unitary_matrix_01_23_qubits = np.load(prefix + "MCX_unitary_matrix_01_23_qubits.npy")
+MCX_unitary_matrix_01_23_qubits = np.load(
+    prefix + "MCX_unitary_matrix_01_23_qubits.npy"
+)
 
 """ circuit.MCX() tester
 
 Parameters
 ----------
-`control_qubits` = [1, 0]
-`target_qubits` = [2, 3]
+`control_indices` = [1, 0]
+`target_indices` = [2, 3]
 """
-MCX_unitary_matrix_10_23_qubits = np.load(prefix + "MCX_unitary_matrix_10_23_qubits.npy")
+MCX_unitary_matrix_10_23_qubits = np.load(
+    prefix + "MCX_unitary_matrix_10_23_qubits.npy"
+)
 
 """ circuit.MCX() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 2]
-`target_qubits` = [1, 3]
+`control_indices` = [0, 2]
+`target_indices` = [1, 3]
 """
-MCX_unitary_matrix_02_13_qubits = np.load(prefix + "MCX_unitary_matrix_02_13_qubits.npy")
+MCX_unitary_matrix_02_13_qubits = np.load(
+    prefix + "MCX_unitary_matrix_02_13_qubits.npy"
+)
 
 """ circuit.MCX() tester
 
 Parameters
 ----------
-`control_qubits` = [2, 0]
-`target_qubits` = [3, 4]
+`control_indices` = [2, 0]
+`target_indices` = [3, 4]
 """
-MCX_unitary_matrix_20_34_qubits = np.load(prefix + "MCX_unitary_matrix_20_34_qubits.npy")
+MCX_unitary_matrix_20_34_qubits = np.load(
+    prefix + "MCX_unitary_matrix_20_34_qubits.npy"
+)
 
 """ circuit.MCX() tester
 
 Parameters
 ----------
-`control_qubits` = [1, 2]
-`target_qubits` = [0, 4]
+`control_indices` = [1, 2]
+`target_indices` = [0, 4]
 """
-MCX_unitary_matrix_12_04_qubits = np.load(prefix + "MCX_unitary_matrix_12_04_qubits.npy")
+MCX_unitary_matrix_12_04_qubits = np.load(
+    prefix + "MCX_unitary_matrix_12_04_qubits.npy"
+)
 
 """ circuit.MCX() tester
 
 Parameters
 ----------
-`control_qubits` = [5, 3]
-`target_qubits` = [0, 1]
+`control_indices` = [5, 3]
+`target_indices` = [0, 1]
 """
-MCX_unitary_matrix_53_01_qubits = np.load(prefix + "MCX_unitary_matrix_53_01_qubits.npy")
+MCX_unitary_matrix_53_01_qubits = np.load(
+    prefix + "MCX_unitary_matrix_53_01_qubits.npy"
+)
 
 """ circuit.MCX() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4]
 """
-MCX_unitary_matrix_012_34_qubits = np.load(prefix + "MCX_unitary_matrix_012_34_qubits.npy")
+MCX_unitary_matrix_012_34_qubits = np.load(
+    prefix + "MCX_unitary_matrix_012_34_qubits.npy"
+)
 
 """ circuit.MCX() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [3, 4, 5]
+`control_indices` = [0, 1]
+`target_indices` = [3, 4, 5]
 """
-MCX_unitary_matrix_01_234_qubits = np.load(prefix + "MCX_unitary_matrix_01_234_qubits.npy")
+MCX_unitary_matrix_01_234_qubits = np.load(
+    prefix + "MCX_unitary_matrix_01_234_qubits.npy"
+)
 
 """ circuit.MCX() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4, 5]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4, 5]
 """
-MCX_unitary_matrix_012_345_qubits = np.load(prefix + "MCX_unitary_matrix_012_345_qubits.npy")
+MCX_unitary_matrix_012_345_qubits = np.load(
+    prefix + "MCX_unitary_matrix_012_345_qubits.npy"
+)
 
 """ circuit.MCX() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [2]
+`control_indices` = [0, 1]
+`target_indices` = [2]
 """
 MCX_unitary_matrix_01_2_qubits = np.load(prefix + "MCX_unitary_matrix_01_2_qubits.npy")
 
@@ -1840,8 +1988,8 @@
 
 Parameters
 ----------
-`control_qubits` = [0]
-`target_qubits` = [2, 3]
+`control_indices` = [0]
+`target_indices` = [2, 3]
 """
 MCX_unitary_matrix_0_23_qubits = np.load(prefix + "MCX_unitary_matrix_0_23_qubits.npy")
 
@@ -1849,89 +1997,107 @@
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3]
 """
-MCY_unitary_matrix_01_23_qubits = np.load(prefix + "MCY_unitary_matrix_01_23_qubits.npy")
+MCY_unitary_matrix_01_23_qubits = np.load(
+    prefix + "MCY_unitary_matrix_01_23_qubits.npy"
+)
 
 """ circuit.MCY() tester
 
 Parameters
 ----------
-`control_qubits` = [1, 0]
-`target_qubits` = [2, 3]
+`control_indices` = [1, 0]
+`target_indices` = [2, 3]
 """
-MCY_unitary_matrix_10_23_qubits = np.load(prefix + "MCY_unitary_matrix_10_23_qubits.npy")
+MCY_unitary_matrix_10_23_qubits = np.load(
+    prefix + "MCY_unitary_matrix_10_23_qubits.npy"
+)
 
 """ circuit.MCY() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 2]
-`target_qubits` = [1, 3]
+`control_indices` = [0, 2]
+`target_indices` = [1, 3]
 """
-MCY_unitary_matrix_02_13_qubits = np.load(prefix + "MCY_unitary_matrix_02_13_qubits.npy")
+MCY_unitary_matrix_02_13_qubits = np.load(
+    prefix + "MCY_unitary_matrix_02_13_qubits.npy"
+)
 
 """ circuit.MCY() tester
 
 Parameters
 ----------
-`control_qubits` = [2, 0]
-`target_qubits` = [3, 4]
+`control_indices` = [2, 0]
+`target_indices` = [3, 4]
 """
-MCY_unitary_matrix_20_34_qubits = np.load(prefix + "MCY_unitary_matrix_20_34_qubits.npy")
+MCY_unitary_matrix_20_34_qubits = np.load(
+    prefix + "MCY_unitary_matrix_20_34_qubits.npy"
+)
 
 """ circuit.MCY() tester
 
 Parameters
 ----------
-`control_qubits` = [1, 2]
-`target_qubits` = [0, 4]
+`control_indices` = [1, 2]
+`target_indices` = [0, 4]
 """
-MCY_unitary_matrix_12_04_qubits = np.load(prefix + "MCY_unitary_matrix_12_04_qubits.npy")
+MCY_unitary_matrix_12_04_qubits = np.load(
+    prefix + "MCY_unitary_matrix_12_04_qubits.npy"
+)
 
 """ circuit.MCY() tester
 
 Parameters
 ----------
-`control_qubits` = [5, 3]
-`target_qubits` = [0, 1]
+`control_indices` = [5, 3]
+`target_indices` = [0, 1]
 """
-MCY_unitary_matrix_53_01_qubits = np.load(prefix + "MCY_unitary_matrix_53_01_qubits.npy")
+MCY_unitary_matrix_53_01_qubits = np.load(
+    prefix + "MCY_unitary_matrix_53_01_qubits.npy"
+)
 
 """ circuit.MCY() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4]
 """
-MCY_unitary_matrix_012_34_qubits = np.load(prefix + "MCY_unitary_matrix_012_34_qubits.npy")
+MCY_unitary_matrix_012_34_qubits = np.load(
+    prefix + "MCY_unitary_matrix_012_34_qubits.npy"
+)
 
 """ circuit.MCY() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [3, 4, 5]
+`control_indices` = [0, 1]
+`target_indices` = [3, 4, 5]
 """
-MCY_unitary_matrix_01_234_qubits = np.load(prefix + "MCY_unitary_matrix_01_234_qubits.npy")
+MCY_unitary_matrix_01_234_qubits = np.load(
+    prefix + "MCY_unitary_matrix_01_234_qubits.npy"
+)
 
 """ circuit.MCY() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4, 5]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4, 5]
 """
-MCY_unitary_matrix_012_345_qubits = np.load(prefix + "MCY_unitary_matrix_012_345_qubits.npy")
+MCY_unitary_matrix_012_345_qubits = np.load(
+    prefix + "MCY_unitary_matrix_012_345_qubits.npy"
+)
 
 """ circuit.MCY() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [2]
+`control_indices` = [0, 1]
+`target_indices` = [2]
 """
 MCY_unitary_matrix_01_2_qubits = np.load(prefix + "MCY_unitary_matrix_01_2_qubits.npy")
 
@@ -1939,8 +2105,8 @@
 
 Parameters
 ----------
-`control_qubits` = [0]
-`target_qubits` = [2, 3]
+`control_indices` = [0]
+`target_indices` = [2, 3]
 """
 MCY_unitary_matrix_0_23_qubits = np.load(prefix + "MCY_unitary_matrix_0_23_qubits.npy")
 
@@ -1948,89 +2114,107 @@
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3]
 """
-MCZ_unitary_matrix_01_23_qubits = np.load(prefix + "MCZ_unitary_matrix_01_23_qubits.npy")
+MCZ_unitary_matrix_01_23_qubits = np.load(
+    prefix + "MCZ_unitary_matrix_01_23_qubits.npy"
+)
 
 """ circuit.MCZ() tester
 
 Parameters
 ----------
-`control_qubits` = [1, 0]
-`target_qubits` = [2, 3]
+`control_indices` = [1, 0]
+`target_indices` = [2, 3]
 """
-MCZ_unitary_matrix_10_23_qubits = np.load(prefix + "MCZ_unitary_matrix_10_23_qubits.npy")
+MCZ_unitary_matrix_10_23_qubits = np.load(
+    prefix + "MCZ_unitary_matrix_10_23_qubits.npy"
+)
 
 """ circuit.MCZ() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 2]
-`target_qubits` = [1, 3]
+`control_indices` = [0, 2]
+`target_indices` = [1, 3]
 """
-MCZ_unitary_matrix_02_13_qubits = np.load(prefix + "MCZ_unitary_matrix_02_13_qubits.npy")
+MCZ_unitary_matrix_02_13_qubits = np.load(
+    prefix + "MCZ_unitary_matrix_02_13_qubits.npy"
+)
 
 """ circuit.MCZ() tester
 
 Parameters
 ----------
-`control_qubits` = [2, 0]
-`target_qubits` = [3, 4]
+`control_indices` = [2, 0]
+`target_indices` = [3, 4]
 """
-MCZ_unitary_matrix_20_34_qubits = np.load(prefix + "MCZ_unitary_matrix_20_34_qubits.npy")
+MCZ_unitary_matrix_20_34_qubits = np.load(
+    prefix + "MCZ_unitary_matrix_20_34_qubits.npy"
+)
 
 """ circuit.MCZ() tester
 
 Parameters
 ----------
-`control_qubits` = [1, 2]
-`target_qubits` = [0, 4]
+`control_indices` = [1, 2]
+`target_indices` = [0, 4]
 """
-MCZ_unitary_matrix_12_04_qubits = np.load(prefix + "MCZ_unitary_matrix_12_04_qubits.npy")
+MCZ_unitary_matrix_12_04_qubits = np.load(
+    prefix + "MCZ_unitary_matrix_12_04_qubits.npy"
+)
 
 """ circuit.MCZ() tester
 
 Parameters
 ----------
-`control_qubits` = [5, 3]
-`target_qubits` = [0, 1]
+`control_indices` = [5, 3]
+`target_indices` = [0, 1]
 """
-MCZ_unitary_matrix_53_01_qubits = np.load(prefix + "MCZ_unitary_matrix_53_01_qubits.npy")
+MCZ_unitary_matrix_53_01_qubits = np.load(
+    prefix + "MCZ_unitary_matrix_53_01_qubits.npy"
+)
 
 """ circuit.MCZ() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4]
 """
-MCZ_unitary_matrix_012_34_qubits = np.load(prefix + "MCZ_unitary_matrix_012_34_qubits.npy")
+MCZ_unitary_matrix_012_34_qubits = np.load(
+    prefix + "MCZ_unitary_matrix_012_34_qubits.npy"
+)
 
 """ circuit.MCZ() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [3, 4, 5]
+`control_indices` = [0, 1]
+`target_indices` = [3, 4, 5]
 """
-MCZ_unitary_matrix_01_234_qubits = np.load(prefix + "MCZ_unitary_matrix_01_234_qubits.npy")
+MCZ_unitary_matrix_01_234_qubits = np.load(
+    prefix + "MCZ_unitary_matrix_01_234_qubits.npy"
+)
 
 """ circuit.MCZ() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4, 5]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4, 5]
 """
-MCZ_unitary_matrix_012_345_qubits = np.load(prefix + "MCZ_unitary_matrix_012_345_qubits.npy")
+MCZ_unitary_matrix_012_345_qubits = np.load(
+    prefix + "MCZ_unitary_matrix_012_345_qubits.npy"
+)
 
 """ circuit.MCZ() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [2]
+`control_indices` = [0, 1]
+`target_indices` = [2]
 """
 MCZ_unitary_matrix_01_2_qubits = np.load(prefix + "MCZ_unitary_matrix_01_2_qubits.npy")
 
@@ -2038,8 +2222,8 @@
 
 Parameters
 ----------
-`control_qubits` = [0]
-`target_qubits` = [2, 3]
+`control_indices` = [0]
+`target_indices` = [2, 3]
 """
 MCZ_unitary_matrix_0_23_qubits = np.load(prefix + "MCZ_unitary_matrix_0_23_qubits.npy")
 
@@ -2047,89 +2231,107 @@
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3]
 """
-MCH_unitary_matrix_01_23_qubits = np.load(prefix + "MCH_unitary_matrix_01_23_qubits.npy")
+MCH_unitary_matrix_01_23_qubits = np.load(
+    prefix + "MCH_unitary_matrix_01_23_qubits.npy"
+)
 
 """ circuit.MCH() tester
 
 Parameters
 ----------
-`control_qubits` = [1, 0]
-`target_qubits` = [2, 3]
+`control_indices` = [1, 0]
+`target_indices` = [2, 3]
 """
-MCH_unitary_matrix_10_23_qubits = np.load(prefix + "MCH_unitary_matrix_10_23_qubits.npy")
+MCH_unitary_matrix_10_23_qubits = np.load(
+    prefix + "MCH_unitary_matrix_10_23_qubits.npy"
+)
 
 """ circuit.MCH() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 2]
-`target_qubits` = [1, 3]
+`control_indices` = [0, 2]
+`target_indices` = [1, 3]
 """
-MCH_unitary_matrix_02_13_qubits = np.load(prefix + "MCH_unitary_matrix_02_13_qubits.npy")
+MCH_unitary_matrix_02_13_qubits = np.load(
+    prefix + "MCH_unitary_matrix_02_13_qubits.npy"
+)
 
 """ circuit.MCH() tester
 
 Parameters
 ----------
-`control_qubits` = [2, 0]
-`target_qubits` = [3, 4]
+`control_indices` = [2, 0]
+`target_indices` = [3, 4]
 """
-MCH_unitary_matrix_20_34_qubits = np.load(prefix + "MCH_unitary_matrix_20_34_qubits.npy")
+MCH_unitary_matrix_20_34_qubits = np.load(
+    prefix + "MCH_unitary_matrix_20_34_qubits.npy"
+)
 
 """ circuit.MCH() tester
 
 Parameters
 ----------
-`control_qubits` = [1, 2]
-`target_qubits` = [0, 4]
+`control_indices` = [1, 2]
+`target_indices` = [0, 4]
 """
-MCH_unitary_matrix_12_04_qubits = np.load(prefix + "MCH_unitary_matrix_12_04_qubits.npy")
+MCH_unitary_matrix_12_04_qubits = np.load(
+    prefix + "MCH_unitary_matrix_12_04_qubits.npy"
+)
 
 """ circuit.MCH() tester
 
 Parameters
 ----------
-`control_qubits` = [5, 3]
-`target_qubits` = [0, 1]
+`control_indices` = [5, 3]
+`target_indices` = [0, 1]
 """
-MCH_unitary_matrix_53_01_qubits = np.load(prefix + "MCH_unitary_matrix_53_01_qubits.npy")
+MCH_unitary_matrix_53_01_qubits = np.load(
+    prefix + "MCH_unitary_matrix_53_01_qubits.npy"
+)
 
 """ circuit.MCH() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4]
 """
-MCH_unitary_matrix_012_34_qubits = np.load(prefix + "MCH_unitary_matrix_012_34_qubits.npy")
+MCH_unitary_matrix_012_34_qubits = np.load(
+    prefix + "MCH_unitary_matrix_012_34_qubits.npy"
+)
 
 """ circuit.MCH() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [3, 4, 5]
+`control_indices` = [0, 1]
+`target_indices` = [3, 4, 5]
 """
-MCH_unitary_matrix_01_234_qubits = np.load(prefix + "MCH_unitary_matrix_01_234_qubits.npy")
+MCH_unitary_matrix_01_234_qubits = np.load(
+    prefix + "MCH_unitary_matrix_01_234_qubits.npy"
+)
 
 """ circuit.MCH() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4, 5]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4, 5]
 """
-MCH_unitary_matrix_012_345_qubits = np.load(prefix + "MCH_unitary_matrix_012_345_qubits.npy")
+MCH_unitary_matrix_012_345_qubits = np.load(
+    prefix + "MCH_unitary_matrix_012_345_qubits.npy"
+)
 
 """ circuit.MCH() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [2]
+`control_indices` = [0, 1]
+`target_indices` = [2]
 """
 MCH_unitary_matrix_01_2_qubits = np.load(prefix + "MCH_unitary_matrix_01_2_qubits.npy")
 
@@ -2137,8 +2339,8 @@
 
 Parameters
 ----------
-`control_qubits` = [0]
-`target_qubits` = [2, 3]
+`control_indices` = [0]
+`target_indices` = [2, 3]
 """
 MCH_unitary_matrix_0_23_qubits = np.load(prefix + "MCH_unitary_matrix_0_23_qubits.npy")
 
@@ -2146,89 +2348,107 @@
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3]
 """
-MCS_unitary_matrix_01_23_qubits = np.load(prefix + "MCS_unitary_matrix_01_23_qubits.npy")
+MCS_unitary_matrix_01_23_qubits = np.load(
+    prefix + "MCS_unitary_matrix_01_23_qubits.npy"
+)
 
 """ circuit.MCS() tester
 
 Parameters
 ----------
-`control_qubits` = [1, 0]
-`target_qubits` = [2, 3]
+`control_indices` = [1, 0]
+`target_indices` = [2, 3]
 """
-MCS_unitary_matrix_10_23_qubits = np.load(prefix + "MCS_unitary_matrix_10_23_qubits.npy")
+MCS_unitary_matrix_10_23_qubits = np.load(
+    prefix + "MCS_unitary_matrix_10_23_qubits.npy"
+)
 
 """ circuit.MCS() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 2]
-`target_qubits` = [1, 3]
+`control_indices` = [0, 2]
+`target_indices` = [1, 3]
 """
-MCS_unitary_matrix_02_13_qubits = np.load(prefix + "MCS_unitary_matrix_02_13_qubits.npy")
+MCS_unitary_matrix_02_13_qubits = np.load(
+    prefix + "MCS_unitary_matrix_02_13_qubits.npy"
+)
 
 """ circuit.MCS() tester
 
 Parameters
 ----------
-`control_qubits` = [2, 0]
-`target_qubits` = [3, 4]
+`control_indices` = [2, 0]
+`target_indices` = [3, 4]
 """
-MCS_unitary_matrix_20_34_qubits = np.load(prefix + "MCS_unitary_matrix_20_34_qubits.npy")
+MCS_unitary_matrix_20_34_qubits = np.load(
+    prefix + "MCS_unitary_matrix_20_34_qubits.npy"
+)
 
 """ circuit.MCS() tester
 
 Parameters
 ----------
-`control_qubits` = [1, 2]
-`target_qubits` = [0, 4]
+`control_indices` = [1, 2]
+`target_indices` = [0, 4]
 """
-MCS_unitary_matrix_12_04_qubits = np.load(prefix + "MCS_unitary_matrix_12_04_qubits.npy")
+MCS_unitary_matrix_12_04_qubits = np.load(
+    prefix + "MCS_unitary_matrix_12_04_qubits.npy"
+)
 
 """ circuit.MCS() tester
 
 Parameters
 ----------
-`control_qubits` = [5, 3]
-`target_qubits` = [0, 1]
+`control_indices` = [5, 3]
+`target_indices` = [0, 1]
 """
-MCS_unitary_matrix_53_01_qubits = np.load(prefix + "MCS_unitary_matrix_53_01_qubits.npy")
+MCS_unitary_matrix_53_01_qubits = np.load(
+    prefix + "MCS_unitary_matrix_53_01_qubits.npy"
+)
 
 """ circuit.MCS() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4]
 """
-MCS_unitary_matrix_012_34_qubits = np.load(prefix + "MCS_unitary_matrix_012_34_qubits.npy")
+MCS_unitary_matrix_012_34_qubits = np.load(
+    prefix + "MCS_unitary_matrix_012_34_qubits.npy"
+)
 
 """ circuit.MCS() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [3, 4, 5]
+`control_indices` = [0, 1]
+`target_indices` = [3, 4, 5]
 """
-MCS_unitary_matrix_01_234_qubits = np.load(prefix + "MCS_unitary_matrix_01_234_qubits.npy")
+MCS_unitary_matrix_01_234_qubits = np.load(
+    prefix + "MCS_unitary_matrix_01_234_qubits.npy"
+)
 
 """ circuit.MCS() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4, 5]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4, 5]
 """
-MCS_unitary_matrix_012_345_qubits = np.load(prefix + "MCS_unitary_matrix_012_345_qubits.npy")
+MCS_unitary_matrix_012_345_qubits = np.load(
+    prefix + "MCS_unitary_matrix_012_345_qubits.npy"
+)
 
 """ circuit.MCS() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [2]
+`control_indices` = [0, 1]
+`target_indices` = [2]
 """
 MCS_unitary_matrix_01_2_qubits = np.load(prefix + "MCS_unitary_matrix_01_2_qubits.npy")
 
@@ -2236,8 +2456,8 @@
 
 Parameters
 ----------
-`control_qubits` = [0]
-`target_qubits` = [2, 3]
+`control_indices` = [0]
+`target_indices` = [2, 3]
 """
 MCS_unitary_matrix_0_23_qubits = np.load(prefix + "MCS_unitary_matrix_0_23_qubits.npy")
 
@@ -2245,188 +2465,228 @@
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3]
 """
-MCSdg_unitary_matrix_01_23_qubits = np.load(prefix + "MCSdg_unitary_matrix_01_23_qubits.npy")
+MCSdg_unitary_matrix_01_23_qubits = np.load(
+    prefix + "MCSdg_unitary_matrix_01_23_qubits.npy"
+)
 
 """ circuit.MCSdg() tester
 
 Parameters
 ----------
-`control_qubits` = [1, 0]
-`target_qubits` = [2, 3]
+`control_indices` = [1, 0]
+`target_indices` = [2, 3]
 """
-MCSdg_unitary_matrix_10_23_qubits = np.load(prefix + "MCSdg_unitary_matrix_10_23_qubits.npy")
+MCSdg_unitary_matrix_10_23_qubits = np.load(
+    prefix + "MCSdg_unitary_matrix_10_23_qubits.npy"
+)
 
 """ circuit.MCSdg() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 2]
-`target_qubits` = [1, 3]
+`control_indices` = [0, 2]
+`target_indices` = [1, 3]
 """
-MCSdg_unitary_matrix_02_13_qubits = np.load(prefix + "MCSdg_unitary_matrix_02_13_qubits.npy")
+MCSdg_unitary_matrix_02_13_qubits = np.load(
+    prefix + "MCSdg_unitary_matrix_02_13_qubits.npy"
+)
 
 """ circuit.MCSdg() tester
 
 Parameters
 ----------
-`control_qubits` = [2, 0]
-`target_qubits` = [3, 4]
+`control_indices` = [2, 0]
+`target_indices` = [3, 4]
 """
-MCSdg_unitary_matrix_20_34_qubits = np.load(prefix + "MCSdg_unitary_matrix_20_34_qubits.npy")
+MCSdg_unitary_matrix_20_34_qubits = np.load(
+    prefix + "MCSdg_unitary_matrix_20_34_qubits.npy"
+)
 
 """ circuit.MCSdg() tester
 
 Parameters
 ----------
-`control_qubits` = [1, 2]
-`target_qubits` = [0, 4]
+`control_indices` = [1, 2]
+`target_indices` = [0, 4]
 """
-MCSdg_unitary_matrix_12_04_qubits = np.load(prefix + "MCSdg_unitary_matrix_12_04_qubits.npy")
+MCSdg_unitary_matrix_12_04_qubits = np.load(
+    prefix + "MCSdg_unitary_matrix_12_04_qubits.npy"
+)
 
 """ circuit.MCSdg() tester
 
 Parameters
 ----------
-`control_qubits` = [5, 3]
-`target_qubits` = [0, 1]
+`control_indices` = [5, 3]
+`target_indices` = [0, 1]
 """
-MCSdg_unitary_matrix_53_01_qubits = np.load(prefix + "MCSdg_unitary_matrix_53_01_qubits.npy")
+MCSdg_unitary_matrix_53_01_qubits = np.load(
+    prefix + "MCSdg_unitary_matrix_53_01_qubits.npy"
+)
 
 """ circuit.MCSdg() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4]
 """
-MCSdg_unitary_matrix_012_34_qubits = np.load(prefix + "MCSdg_unitary_matrix_012_34_qubits.npy")
+MCSdg_unitary_matrix_012_34_qubits = np.load(
+    prefix + "MCSdg_unitary_matrix_012_34_qubits.npy"
+)
 
 """ circuit.MCSdg() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [3, 4, 5]
+`control_indices` = [0, 1]
+`target_indices` = [3, 4, 5]
 """
-MCSdg_unitary_matrix_01_234_qubits = np.load(prefix + "MCSdg_unitary_matrix_01_234_qubits.npy")
+MCSdg_unitary_matrix_01_234_qubits = np.load(
+    prefix + "MCSdg_unitary_matrix_01_234_qubits.npy"
+)
 
 """ circuit.MCSdg() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4, 5]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4, 5]
 """
-MCSdg_unitary_matrix_012_345_qubits = np.load(prefix + "MCSdg_unitary_matrix_012_345_qubits.npy")
+MCSdg_unitary_matrix_012_345_qubits = np.load(
+    prefix + "MCSdg_unitary_matrix_012_345_qubits.npy"
+)
 
 """ circuit.MCSdg() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [2]
+`control_indices` = [0, 1]
+`target_indices` = [2]
 """
-MCSdg_unitary_matrix_01_2_qubits = np.load(prefix + "MCSdg_unitary_matrix_01_2_qubits.npy")
+MCSdg_unitary_matrix_01_2_qubits = np.load(
+    prefix + "MCSdg_unitary_matrix_01_2_qubits.npy"
+)
 
 """ circuit.MCSdg() tester
 
 Parameters
 ----------
-`control_qubits` = [0]
-`target_qubits` = [2, 3]
+`control_indices` = [0]
+`target_indices` = [2, 3]
 """
-MCSdg_unitary_matrix_0_23_qubits = np.load(prefix + "MCSdg_unitary_matrix_0_23_qubits.npy")
+MCSdg_unitary_matrix_0_23_qubits = np.load(
+    prefix + "MCSdg_unitary_matrix_0_23_qubits.npy"
+)
 
 """ circuit.MCT() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3]
 """
-MCT_unitary_matrix_01_23_qubits = np.load(prefix + "MCT_unitary_matrix_01_23_qubits.npy")
+MCT_unitary_matrix_01_23_qubits = np.load(
+    prefix + "MCT_unitary_matrix_01_23_qubits.npy"
+)
 
 """ circuit.MCT() tester
 
 Parameters
 ----------
-`control_qubits` = [1, 0]
-`target_qubits` = [2, 3]
+`control_indices` = [1, 0]
+`target_indices` = [2, 3]
 """
-MCT_unitary_matrix_10_23_qubits = np.load(prefix + "MCT_unitary_matrix_10_23_qubits.npy")
+MCT_unitary_matrix_10_23_qubits = np.load(
+    prefix + "MCT_unitary_matrix_10_23_qubits.npy"
+)
 
 """ circuit.MCT() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 2]
-`target_qubits` = [1, 3]
+`control_indices` = [0, 2]
+`target_indices` = [1, 3]
 """
-MCT_unitary_matrix_02_13_qubits = np.load(prefix + "MCT_unitary_matrix_02_13_qubits.npy")
+MCT_unitary_matrix_02_13_qubits = np.load(
+    prefix + "MCT_unitary_matrix_02_13_qubits.npy"
+)
 
 """ circuit.MCT() tester
 
 Parameters
 ----------
-`control_qubits` = [2, 0]
-`target_qubits` = [3, 4]
+`control_indices` = [2, 0]
+`target_indices` = [3, 4]
 """
-MCT_unitary_matrix_20_34_qubits = np.load(prefix + "MCT_unitary_matrix_20_34_qubits.npy")
+MCT_unitary_matrix_20_34_qubits = np.load(
+    prefix + "MCT_unitary_matrix_20_34_qubits.npy"
+)
 
 """ circuit.MCT() tester
 
 Parameters
 ----------
-`control_qubits` = [1, 2]
-`target_qubits` = [0, 4]
+`control_indices` = [1, 2]
+`target_indices` = [0, 4]
 """
-MCT_unitary_matrix_12_04_qubits = np.load(prefix + "MCT_unitary_matrix_12_04_qubits.npy")
+MCT_unitary_matrix_12_04_qubits = np.load(
+    prefix + "MCT_unitary_matrix_12_04_qubits.npy"
+)
 
 """ circuit.MCT() tester
 
 Parameters
 ----------
-`control_qubits` = [5, 3]
-`target_qubits` = [0, 1]
+`control_indices` = [5, 3]
+`target_indices` = [0, 1]
 """
-MCT_unitary_matrix_53_01_qubits = np.load(prefix + "MCT_unitary_matrix_53_01_qubits.npy")
+MCT_unitary_matrix_53_01_qubits = np.load(
+    prefix + "MCT_unitary_matrix_53_01_qubits.npy"
+)
 
 """ circuit.MCT() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4]
 """
-MCT_unitary_matrix_012_34_qubits = np.load(prefix + "MCT_unitary_matrix_012_34_qubits.npy")
+MCT_unitary_matrix_012_34_qubits = np.load(
+    prefix + "MCT_unitary_matrix_012_34_qubits.npy"
+)
 
 """ circuit.MCT() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [3, 4, 5]
+`control_indices` = [0, 1]
+`target_indices` = [3, 4, 5]
 """
-MCT_unitary_matrix_01_234_qubits = np.load(prefix + "MCT_unitary_matrix_01_234_qubits.npy")
+MCT_unitary_matrix_01_234_qubits = np.load(
+    prefix + "MCT_unitary_matrix_01_234_qubits.npy"
+)
 
 """ circuit.MCT() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4, 5]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4, 5]
 """
-MCT_unitary_matrix_012_345_qubits = np.load(prefix + "MCT_unitary_matrix_012_345_qubits.npy")
+MCT_unitary_matrix_012_345_qubits = np.load(
+    prefix + "MCT_unitary_matrix_012_345_qubits.npy"
+)
 
 """ circuit.MCT() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [2]
+`control_indices` = [0, 1]
+`target_indices` = [2]
 """
 MCT_unitary_matrix_01_2_qubits = np.load(prefix + "MCT_unitary_matrix_01_2_qubits.npy")
 
@@ -2434,8 +2694,8 @@
 
 Parameters
 ----------
-`control_qubits` = [0]
-`target_qubits` = [2, 3]
+`control_indices` = [0]
+`target_indices` = [2, 3]
 """
 MCT_unitary_matrix_0_23_qubits = np.load(prefix + "MCT_unitary_matrix_0_23_qubits.npy")
 
@@ -2443,630 +2703,758 @@
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3]
 """
-MCTdg_unitary_matrix_01_23_qubits = np.load(prefix + "MCTdg_unitary_matrix_01_23_qubits.npy")
+MCTdg_unitary_matrix_01_23_qubits = np.load(
+    prefix + "MCTdg_unitary_matrix_01_23_qubits.npy"
+)
 
 """ circuit.MCTdg() tester
 
 Parameters
 ----------
-`control_qubits` = [1, 0]
-`target_qubits` = [2, 3]
+`control_indices` = [1, 0]
+`target_indices` = [2, 3]
 """
-MCTdg_unitary_matrix_10_23_qubits = np.load(prefix + "MCTdg_unitary_matrix_10_23_qubits.npy")
+MCTdg_unitary_matrix_10_23_qubits = np.load(
+    prefix + "MCTdg_unitary_matrix_10_23_qubits.npy"
+)
 
 """ circuit.MCTdg() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 2]
-`target_qubits` = [1, 3]
+`control_indices` = [0, 2]
+`target_indices` = [1, 3]
 """
-MCTdg_unitary_matrix_02_13_qubits = np.load(prefix + "MCTdg_unitary_matrix_02_13_qubits.npy")
+MCTdg_unitary_matrix_02_13_qubits = np.load(
+    prefix + "MCTdg_unitary_matrix_02_13_qubits.npy"
+)
 
 """ circuit.MCTdg() tester
 
 Parameters
 ----------
-`control_qubits` = [2, 0]
-`target_qubits` = [3, 4]
+`control_indices` = [2, 0]
+`target_indices` = [3, 4]
 """
-MCTdg_unitary_matrix_20_34_qubits = np.load(prefix + "MCTdg_unitary_matrix_20_34_qubits.npy")
+MCTdg_unitary_matrix_20_34_qubits = np.load(
+    prefix + "MCTdg_unitary_matrix_20_34_qubits.npy"
+)
 
 """ circuit.MCTdg() tester
 
 Parameters
 ----------
-`control_qubits` = [1, 2]
-`target_qubits` = [0, 4]
+`control_indices` = [1, 2]
+`target_indices` = [0, 4]
 """
-MCTdg_unitary_matrix_12_04_qubits = np.load(prefix + "MCTdg_unitary_matrix_12_04_qubits.npy")
+MCTdg_unitary_matrix_12_04_qubits = np.load(
+    prefix + "MCTdg_unitary_matrix_12_04_qubits.npy"
+)
 
 """ circuit.MCTdg() tester
 
 Parameters
 ----------
-`control_qubits` = [5, 3]
-`target_qubits` = [0, 1]
+`control_indices` = [5, 3]
+`target_indices` = [0, 1]
 """
-MCTdg_unitary_matrix_53_01_qubits = np.load(prefix + "MCTdg_unitary_matrix_53_01_qubits.npy")
+MCTdg_unitary_matrix_53_01_qubits = np.load(
+    prefix + "MCTdg_unitary_matrix_53_01_qubits.npy"
+)
 
 """ circuit.MCTdg() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4]
 """
-MCTdg_unitary_matrix_012_34_qubits = np.load(prefix + "MCTdg_unitary_matrix_012_34_qubits.npy")
+MCTdg_unitary_matrix_012_34_qubits = np.load(
+    prefix + "MCTdg_unitary_matrix_012_34_qubits.npy"
+)
 
 """ circuit.MCTdg() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [3, 4, 5]
+`control_indices` = [0, 1]
+`target_indices` = [3, 4, 5]
 """
-MCTdg_unitary_matrix_01_234_qubits = np.load(prefix + "MCTdg_unitary_matrix_01_234_qubits.npy")
+MCTdg_unitary_matrix_01_234_qubits = np.load(
+    prefix + "MCTdg_unitary_matrix_01_234_qubits.npy"
+)
 
 """ circuit.MCTdg() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4, 5]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4, 5]
 """
-MCTdg_unitary_matrix_012_345_qubits = np.load(prefix + "MCTdg_unitary_matrix_012_345_qubits.npy")
+MCTdg_unitary_matrix_012_345_qubits = np.load(
+    prefix + "MCTdg_unitary_matrix_012_345_qubits.npy"
+)
 
 """ circuit.MCTdg() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
-`target_qubits` = [2]
+`control_indices` = [0, 1]
+`target_indices` = [2]
 """
-MCTdg_unitary_matrix_01_2_qubits = np.load(prefix + "MCTdg_unitary_matrix_01_2_qubits.npy")
+MCTdg_unitary_matrix_01_2_qubits = np.load(
+    prefix + "MCTdg_unitary_matrix_01_2_qubits.npy"
+)
 
 """ circuit.MCT() tester
 
 Parameters
 ----------
-`control_qubits` = [0]
-`target_qubits` = [2, 3]
+`control_indices` = [0]
+`target_indices` = [2, 3]
 """
-MCTdg_unitary_matrix_0_23_qubits = np.load(prefix + "MCTdg_unitary_matrix_0_23_qubits.npy")
+MCTdg_unitary_matrix_0_23_qubits = np.load(
+    prefix + "MCTdg_unitary_matrix_0_23_qubits.npy"
+)
 
 """ circuit.MCRX() tester
 
 Parameters
 ----------
 `angle` = np.pi/4
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3]
 """
-MCRX_unitary_matrix_pi_over_4_01_23_qubits = np.load(prefix + "MCRX_unitary_matrix_pi_over_4_01_23_qubits.npy")
+MCRX_unitary_matrix_pi_over_4_01_23_qubits = np.load(
+    prefix + "MCRX_unitary_matrix_pi_over_4_01_23_qubits.npy"
+)
 
 """ circuit.MCRX() tester
 
 Parameters
 ----------
 `angle` = np.pi/4
-`control_qubits` = [1, 0]
-`target_qubits` = [2, 3]
+`control_indices` = [1, 0]
+`target_indices` = [2, 3]
 """
-MCRX_unitary_matrix_pi_over_4_10_23_qubits = np.load(prefix + "MCRX_unitary_matrix_pi_over_4_10_23_qubits.npy")
+MCRX_unitary_matrix_pi_over_4_10_23_qubits = np.load(
+    prefix + "MCRX_unitary_matrix_pi_over_4_10_23_qubits.npy"
+)
 
 """ circuit.MCRX() tester
 
 Parameters
 ----------
 `angle` = 1/4
-`control_qubits` = [0, 2]
-`target_qubits` = [1, 3]
+`control_indices` = [0, 2]
+`target_indices` = [1, 3]
 """
-MCRX_unitary_matrix_1_over_4_02_13_qubits = np.load(prefix + "MCRX_unitary_matrix_1_over_4_02_13_qubits.npy")
+MCRX_unitary_matrix_1_over_4_02_13_qubits = np.load(
+    prefix + "MCRX_unitary_matrix_1_over_4_02_13_qubits.npy"
+)
 
 """ circuit.MCRX() tester
 
 Parameters
 ----------
 `angle` = 1/4
-`control_qubits` = [2, 0]
-`target_qubits` = [3, 4]
+`control_indices` = [2, 0]
+`target_indices` = [3, 4]
 """
-MCRX_unitary_matrix_1_over_4_20_34_qubits = np.load(prefix + "MCRX_unitary_matrix_1_over_4_20_34_qubits.npy")
+MCRX_unitary_matrix_1_over_4_20_34_qubits = np.load(
+    prefix + "MCRX_unitary_matrix_1_over_4_20_34_qubits.npy"
+)
 
 """ circuit.MCRX() tester
 
 Parameters
 ----------
 `angle` = -1/4
-`control_qubits` = [1, 2]
-`target_qubits` = [0, 4]
+`control_indices` = [1, 2]
+`target_indices` = [0, 4]
 """
-MCRX_unitary_matrix_negative1_over_4_12_04_qubits = np.load(prefix + "MCRX_unitary_matrix_negative1_over_4_12_04_qubits.npy")
+MCRX_unitary_matrix_negative1_over_4_12_04_qubits = np.load(
+    prefix + "MCRX_unitary_matrix_negative1_over_4_12_04_qubits.npy"
+)
 
 """ circuit.MCRX() tester
 
 Parameters
 ----------
 `angle` = -1/4
-`control_qubits` = [5, 3]
-`target_qubits` = [0, 1]
+`control_indices` = [5, 3]
+`target_indices` = [0, 1]
 """
-MCRX_unitary_matrix_negative1_over_4_53_01_qubits = np.load(prefix + "MCRX_unitary_matrix_negative1_over_4_53_01_qubits.npy")
+MCRX_unitary_matrix_negative1_over_4_53_01_qubits = np.load(
+    prefix + "MCRX_unitary_matrix_negative1_over_4_53_01_qubits.npy"
+)
 
 """ circuit.MCRX() tester
 
 Parameters
 ----------
 `angle` = 1/3
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4]
 """
-MCRX_unitary_matrix_1_over_3_012_34_qubits = np.load(prefix + "MCRX_unitary_matrix_1_over_3_012_34_qubits.npy")
+MCRX_unitary_matrix_1_over_3_012_34_qubits = np.load(
+    prefix + "MCRX_unitary_matrix_1_over_3_012_34_qubits.npy"
+)
 
 """ circuit.MCRX() tester
 
 Parameters
 ----------
 `angle` = 1/3
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3, 4]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3, 4]
 """
-MCRX_unitary_matrix_1_over_3_01_234_qubits = np.load(prefix + "MCRX_unitary_matrix_1_over_3_01_234_qubits.npy")
+MCRX_unitary_matrix_1_over_3_01_234_qubits = np.load(
+    prefix + "MCRX_unitary_matrix_1_over_3_01_234_qubits.npy"
+)
 
 """ circuit.MCRX() tester
 
 Parameters
 ----------
 `angle` = pi/4
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4, 5]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4, 5]
 """
-MCRX_unitary_matrix_pi_over_4_012_345_qubits = np.load(prefix + "MCRX_unitary_matrix_pi_over_4_012_345_qubits.npy")
+MCRX_unitary_matrix_pi_over_4_012_345_qubits = np.load(
+    prefix + "MCRX_unitary_matrix_pi_over_4_012_345_qubits.npy"
+)
 
 """ circuit.MCRX() tester
 
 Parameters
 ----------
 `angle` = pi/4
-`control_qubits` = [0, 1]
-`target_qubits` = [2]
+`control_indices` = [0, 1]
+`target_indices` = [2]
 """
-MCRX_unitary_matrix_pi_over_4_01_2_qubits = np.load(prefix + "MCRX_unitary_matrix_pi_over_4_01_2_qubits.npy")
+MCRX_unitary_matrix_pi_over_4_01_2_qubits = np.load(
+    prefix + "MCRX_unitary_matrix_pi_over_4_01_2_qubits.npy"
+)
 
 """ circuit.MCRX() tester
 
 Parameters
 ----------
 `angle` = pi/4
-`control_qubits` = [0]
-`target_qubits` = [2, 3]
+`control_indices` = [0]
+`target_indices` = [2, 3]
 """
-MCRX_unitary_matrix_pi_over_4_0_23_qubits = np.load(prefix + "MCRX_unitary_matrix_pi_over_4_0_23_qubits.npy")
+MCRX_unitary_matrix_pi_over_4_0_23_qubits = np.load(
+    prefix + "MCRX_unitary_matrix_pi_over_4_0_23_qubits.npy"
+)
 
 """ circuit.MCRX() tester
 
 Parameters
 ----------
 `angle` = 0.1
-`control_qubits` = [0, 1, 2, 3, 4, 5]
-`target_qubits` = [6]
+`control_indices` = [0, 1, 2, 3, 4, 5]
+`target_indices` = [6]
 """
-MCRX_unitary_matrix_0dot1_012345_6_qubits = np.load(prefix + "MCRX_unitary_matrix_0dot1_012345_6_qubits.npy")
+MCRX_unitary_matrix_0dot1_012345_6_qubits = np.load(
+    prefix + "MCRX_unitary_matrix_0dot1_012345_6_qubits.npy"
+)
 
 """ circuit.MCRX() tester
 
 Parameters
 ----------
 `angle` = 0.1
-`control_qubits` = [0, 1, 2, 3, 4, 5, 6]
-`target_qubits` = [7]
+`control_indices` = [0, 1, 2, 3, 4, 5, 6]
+`target_indices` = [7]
 """
-MCRX_unitary_matrix_0dot1_0123456_7_qubits = np.load(prefix + "MCRX_unitary_matrix_0dot1_0123456_7_qubits.npy")
+MCRX_unitary_matrix_0dot1_0123456_7_qubits = np.load(
+    prefix + "MCRX_unitary_matrix_0dot1_0123456_7_qubits.npy"
+)
 
 """ circuit.MCRX() tester
 
 Parameters
 ----------
 `angle` = 0.1
-`control_qubits` = [0, 1, 2, 3, 4, 5, 6, 7]
-`target_qubits` = [8]
+`control_indices` = [0, 1, 2, 3, 4, 5, 6, 7]
+`target_indices` = [8]
 """
-MCRX_unitary_matrix_0dot1_01234567_8_qubits = np.load(prefix + "MCRX_unitary_matrix_0dot1_01234567_8_qubits.npy")
+MCRX_unitary_matrix_0dot1_01234567_8_qubits = np.load(
+    prefix + "MCRX_unitary_matrix_0dot1_01234567_8_qubits.npy"
+)
 
 """ circuit.MCRY() tester
 
 Parameters
 ----------
 `angle` = np.pi/4
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3]
 """
-MCRY_unitary_matrix_pi_over_4_01_23_qubits = np.load(prefix + "MCRY_unitary_matrix_pi_over_4_01_23_qubits.npy")
+MCRY_unitary_matrix_pi_over_4_01_23_qubits = np.load(
+    prefix + "MCRY_unitary_matrix_pi_over_4_01_23_qubits.npy"
+)
 
 """ circuit.MCRY() tester
 
 Parameters
 ----------
 `angle` = np.pi/4
-`control_qubits` = [1, 0]
-`target_qubits` = [2, 3]
+`control_indices` = [1, 0]
+`target_indices` = [2, 3]
 """
-MCRY_unitary_matrix_pi_over_4_10_23_qubits = np.load(prefix + "MCRY_unitary_matrix_pi_over_4_10_23_qubits.npy")
+MCRY_unitary_matrix_pi_over_4_10_23_qubits = np.load(
+    prefix + "MCRY_unitary_matrix_pi_over_4_10_23_qubits.npy"
+)
 
 """ circuit.MCRY() tester
 
 Parameters
 ----------
 `angle` = 1/4
-`control_qubits` = [0, 2]
-`target_qubits` = [1, 3]
+`control_indices` = [0, 2]
+`target_indices` = [1, 3]
 """
-MCRY_unitary_matrix_1_over_4_02_13_qubits = np.load(prefix + "MCRY_unitary_matrix_1_over_4_02_13_qubits.npy")
+MCRY_unitary_matrix_1_over_4_02_13_qubits = np.load(
+    prefix + "MCRY_unitary_matrix_1_over_4_02_13_qubits.npy"
+)
 
 """ circuit.MCRY() tester
 
 Parameters
 ----------
 `angle` = 1/4
-`control_qubits` = [2, 0]
-`target_qubits` = [3, 4]
+`control_indices` = [2, 0]
+`target_indices` = [3, 4]
 """
-MCRY_unitary_matrix_1_over_4_20_34_qubits = np.load(prefix + "MCRY_unitary_matrix_1_over_4_20_34_qubits.npy")
+MCRY_unitary_matrix_1_over_4_20_34_qubits = np.load(
+    prefix + "MCRY_unitary_matrix_1_over_4_20_34_qubits.npy"
+)
 
 """ circuit.MCRY() tester
 
 Parameters
 ----------
 `angle` = -1/4
-`control_qubits` = [1, 2]
-`target_qubits` = [0, 4]
+`control_indices` = [1, 2]
+`target_indices` = [0, 4]
 """
-MCRY_unitary_matrix_negative1_over_4_12_04_qubits = np.load(prefix + "MCRY_unitary_matrix_negative1_over_4_12_04_qubits.npy")
+MCRY_unitary_matrix_negative1_over_4_12_04_qubits = np.load(
+    prefix + "MCRY_unitary_matrix_negative1_over_4_12_04_qubits.npy"
+)
 
 """ circuit.MCRY() tester
 
 Parameters
 ----------
 `angle` = -1/4
-`control_qubits` = [5, 3]
-`target_qubits` = [0, 1]
+`control_indices` = [5, 3]
+`target_indices` = [0, 1]
 """
-MCRY_unitary_matrix_negative1_over_4_53_01_qubits = np.load(prefix + "MCRY_unitary_matrix_negative1_over_4_53_01_qubits.npy")
+MCRY_unitary_matrix_negative1_over_4_53_01_qubits = np.load(
+    prefix + "MCRY_unitary_matrix_negative1_over_4_53_01_qubits.npy"
+)
 
 """ circuit.MCRY() tester
 
 Parameters
 ----------
 `angle` = 1/3
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4]
 """
-MCRY_unitary_matrix_1_over_3_012_34_qubits = np.load(prefix + "MCRY_unitary_matrix_1_over_3_012_34_qubits.npy")
+MCRY_unitary_matrix_1_over_3_012_34_qubits = np.load(
+    prefix + "MCRY_unitary_matrix_1_over_3_012_34_qubits.npy"
+)
 
 """ circuit.MCRY() tester
 
 Parameters
 ----------
 `angle` = 1/3
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3, 4]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3, 4]
 """
-MCRY_unitary_matrix_1_over_3_01_234_qubits = np.load(prefix + "MCRY_unitary_matrix_1_over_3_01_234_qubits.npy")
+MCRY_unitary_matrix_1_over_3_01_234_qubits = np.load(
+    prefix + "MCRY_unitary_matrix_1_over_3_01_234_qubits.npy"
+)
 
 """ circuit.MCRY() tester
 
 Parameters
 ----------
 `angle` = pi/4
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4, 5]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4, 5]
 """
-MCRY_unitary_matrix_pi_over_4_012_345_qubits = np.load(prefix + "MCRY_unitary_matrix_pi_over_4_012_345_qubits.npy")
+MCRY_unitary_matrix_pi_over_4_012_345_qubits = np.load(
+    prefix + "MCRY_unitary_matrix_pi_over_4_012_345_qubits.npy"
+)
 
 """ circuit.MCRY() tester
 
 Parameters
 ----------
 `angle` = pi/4
-`control_qubits` = [0, 1]
-`target_qubits` = [2]
+`control_indices` = [0, 1]
+`target_indices` = [2]
 """
-MCRY_unitary_matrix_pi_over_4_01_2_qubits = np.load(prefix + "MCRY_unitary_matrix_pi_over_4_01_2_qubits.npy")
+MCRY_unitary_matrix_pi_over_4_01_2_qubits = np.load(
+    prefix + "MCRY_unitary_matrix_pi_over_4_01_2_qubits.npy"
+)
 
 """ circuit.MCRY() tester
 
 Parameters
 ----------
 `angle` = pi/4
-`control_qubits` = [0]
-`target_qubits` = [2, 3]
+`control_indices` = [0]
+`target_indices` = [2, 3]
 """
-MCRY_unitary_matrix_pi_over_4_0_23_qubits = np.load(prefix + "MCRY_unitary_matrix_pi_over_4_0_23_qubits.npy")
+MCRY_unitary_matrix_pi_over_4_0_23_qubits = np.load(
+    prefix + "MCRY_unitary_matrix_pi_over_4_0_23_qubits.npy"
+)
 
 """ circuit.MCRY() tester
 
 Parameters
 ----------
 `angle` = 0.1
-`control_qubits` = [0, 1, 2, 3, 4, 5]
-`target_qubits` = [6]
+`control_indices` = [0, 1, 2, 3, 4, 5]
+`target_indices` = [6]
 """
-MCRY_unitary_matrix_0dot1_012345_6_qubits = np.load(prefix + "MCRY_unitary_matrix_0dot1_012345_6_qubits.npy")
+MCRY_unitary_matrix_0dot1_012345_6_qubits = np.load(
+    prefix + "MCRY_unitary_matrix_0dot1_012345_6_qubits.npy"
+)
 
 """ circuit.MCRY() tester
 
 Parameters
 ----------
 `angle` = 0.1
-`control_qubits` = [0, 1, 2, 3, 4, 5, 6]
-`target_qubits` = [7]
+`control_indices` = [0, 1, 2, 3, 4, 5, 6]
+`target_indices` = [7]
 """
-MCRY_unitary_matrix_0dot1_0123456_7_qubits = np.load(prefix + "MCRY_unitary_matrix_0dot1_0123456_7_qubits.npy")
+MCRY_unitary_matrix_0dot1_0123456_7_qubits = np.load(
+    prefix + "MCRY_unitary_matrix_0dot1_0123456_7_qubits.npy"
+)
 
 """ circuit.MCRY() tester
 
 Parameters
 ----------
 `angle` = 0.1
-`control_qubits` = [0, 1, 2, 3, 4, 5, 6, 7]
-`target_qubits` = [8]
+`control_indices` = [0, 1, 2, 3, 4, 5, 6, 7]
+`target_indices` = [8]
 """
-MCRY_unitary_matrix_0dot1_01234567_8_qubits = np.load(prefix + "MCRY_unitary_matrix_0dot1_01234567_8_qubits.npy")
+MCRY_unitary_matrix_0dot1_01234567_8_qubits = np.load(
+    prefix + "MCRY_unitary_matrix_0dot1_01234567_8_qubits.npy"
+)
 
 """ circuit.MCRZ() tester
 
 Parameters
 ----------
 `angle` = np.pi/4
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3]
 """
-MCRZ_unitary_matrix_pi_over_4_01_23_qubits = np.load(prefix + "MCRZ_unitary_matrix_pi_over_4_01_23_qubits.npy")
+MCRZ_unitary_matrix_pi_over_4_01_23_qubits = np.load(
+    prefix + "MCRZ_unitary_matrix_pi_over_4_01_23_qubits.npy"
+)
 
 """ circuit.MCRZ() tester
 
 Parameters
 ----------
 `angle` = np.pi/4
-`control_qubits` = [1, 0]
-`target_qubits` = [2, 3]
+`control_indices` = [1, 0]
+`target_indices` = [2, 3]
 """
-MCRZ_unitary_matrix_pi_over_4_10_23_qubits = np.load(prefix + "MCRZ_unitary_matrix_pi_over_4_10_23_qubits.npy")
+MCRZ_unitary_matrix_pi_over_4_10_23_qubits = np.load(
+    prefix + "MCRZ_unitary_matrix_pi_over_4_10_23_qubits.npy"
+)
 
 """ circuit.MCRZ() tester
 
 Parameters
 ----------
 `angle` = 1/4
-`control_qubits` = [0, 2]
-`target_qubits` = [1, 3]
+`control_indices` = [0, 2]
+`target_indices` = [1, 3]
 """
-MCRZ_unitary_matrix_1_over_4_02_13_qubits = np.load(prefix + "MCRZ_unitary_matrix_1_over_4_02_13_qubits.npy")
+MCRZ_unitary_matrix_1_over_4_02_13_qubits = np.load(
+    prefix + "MCRZ_unitary_matrix_1_over_4_02_13_qubits.npy"
+)
 
 """ circuit.MCRZ() tester
 
 Parameters
 ----------
 `angle` = 1/4
-`control_qubits` = [2, 0]
-`target_qubits` = [3, 4]
+`control_indices` = [2, 0]
+`target_indices` = [3, 4]
 """
-MCRZ_unitary_matrix_1_over_4_20_34_qubits = np.load(prefix + "MCRZ_unitary_matrix_1_over_4_20_34_qubits.npy")
+MCRZ_unitary_matrix_1_over_4_20_34_qubits = np.load(
+    prefix + "MCRZ_unitary_matrix_1_over_4_20_34_qubits.npy"
+)
 
 """ circuit.MCRZ() tester
 
 Parameters
 ----------
 `angle` = -1/4
-`control_qubits` = [1, 2]
-`target_qubits` = [0, 4]
+`control_indices` = [1, 2]
+`target_indices` = [0, 4]
 """
-MCRZ_unitary_matrix_negative1_over_4_12_04_qubits = np.load(prefix + "MCRZ_unitary_matrix_negative1_over_4_12_04_qubits.npy")
+MCRZ_unitary_matrix_negative1_over_4_12_04_qubits = np.load(
+    prefix + "MCRZ_unitary_matrix_negative1_over_4_12_04_qubits.npy"
+)
 
 """ circuit.MCRZ() tester
 
 Parameters
 ----------
 `angle` = -1/4
-`control_qubits` = [5, 3]
-`target_qubits` = [0, 1]
+`control_indices` = [5, 3]
+`target_indices` = [0, 1]
 """
-MCRZ_unitary_matrix_negative1_over_4_53_01_qubits = np.load(prefix + "MCRZ_unitary_matrix_negative1_over_4_53_01_qubits.npy")
+MCRZ_unitary_matrix_negative1_over_4_53_01_qubits = np.load(
+    prefix + "MCRZ_unitary_matrix_negative1_over_4_53_01_qubits.npy"
+)
 
 """ circuit.MCRZ() tester
 
 Parameters
 ----------
 `angle` = 1/3
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4]
 """
-MCRZ_unitary_matrix_1_over_3_012_34_qubits = np.load(prefix + "MCRZ_unitary_matrix_1_over_3_012_34_qubits.npy")
+MCRZ_unitary_matrix_1_over_3_012_34_qubits = np.load(
+    prefix + "MCRZ_unitary_matrix_1_over_3_012_34_qubits.npy"
+)
 
 """ circuit.MCRZ() tester
 
 Parameters
 ----------
 `angle` = 1/3
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3, 4]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3, 4]
 """
-MCRZ_unitary_matrix_1_over_3_01_234_qubits = np.load(prefix + "MCRZ_unitary_matrix_1_over_3_01_234_qubits.npy")
+MCRZ_unitary_matrix_1_over_3_01_234_qubits = np.load(
+    prefix + "MCRZ_unitary_matrix_1_over_3_01_234_qubits.npy"
+)
 
 """ circuit.MCRZ() tester
 
 Parameters
 ----------
 `angle` = pi/4
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4, 5]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4, 5]
 """
-MCRZ_unitary_matrix_pi_over_4_012_345_qubits = np.load(prefix + "MCRZ_unitary_matrix_pi_over_4_012_345_qubits.npy")
+MCRZ_unitary_matrix_pi_over_4_012_345_qubits = np.load(
+    prefix + "MCRZ_unitary_matrix_pi_over_4_012_345_qubits.npy"
+)
 
 """ circuit.MCRY() tester
 
 Parameters
 ----------
 `angle` = pi/4
-`control_qubits` = [0, 1]
-`target_qubits` = [2]
+`control_indices` = [0, 1]
+`target_indices` = [2]
 """
-MCRZ_unitary_matrix_pi_over_4_01_2_qubits = np.load(prefix + "MCRZ_unitary_matrix_pi_over_4_01_2_qubits.npy")
+MCRZ_unitary_matrix_pi_over_4_01_2_qubits = np.load(
+    prefix + "MCRZ_unitary_matrix_pi_over_4_01_2_qubits.npy"
+)
 
 """ circuit.MCRZ() tester
 
 Parameters
 ----------
 `angle` = pi/4
-`control_qubits` = [0]
-`target_qubits` = [2, 3]
+`control_indices` = [0]
+`target_indices` = [2, 3]
 """
-MCRZ_unitary_matrix_pi_over_4_0_23_qubits = np.load(prefix + "MCRZ_unitary_matrix_pi_over_4_0_23_qubits.npy")
+MCRZ_unitary_matrix_pi_over_4_0_23_qubits = np.load(
+    prefix + "MCRZ_unitary_matrix_pi_over_4_0_23_qubits.npy"
+)
 
 """ circuit.MCRZ() tester
 
 Parameters
 ----------
 `angle` = 0.1
-`control_qubits` = [0, 1, 2, 3, 4, 5]
-`target_qubits` = [6]
+`control_indices` = [0, 1, 2, 3, 4, 5]
+`target_indices` = [6]
 """
-MCRZ_unitary_matrix_0dot1_012345_6_qubits = np.load(prefix + "MCRZ_unitary_matrix_0dot1_012345_6_qubits.npy")
+MCRZ_unitary_matrix_0dot1_012345_6_qubits = np.load(
+    prefix + "MCRZ_unitary_matrix_0dot1_012345_6_qubits.npy"
+)
 
 """ circuit.MCRZ() tester
 
 Parameters
 ----------
 `angle` = 0.1
-`control_qubits` = [0, 1, 2, 3, 4, 5, 6]
-`target_qubits` = [7]
+`control_indices` = [0, 1, 2, 3, 4, 5, 6]
+`target_indices` = [7]
 """
-MCRZ_unitary_matrix_0dot1_0123456_7_qubits = np.load(prefix + "MCRZ_unitary_matrix_0dot1_0123456_7_qubits.npy")
+MCRZ_unitary_matrix_0dot1_0123456_7_qubits = np.load(
+    prefix + "MCRZ_unitary_matrix_0dot1_0123456_7_qubits.npy"
+)
 
 """ circuit.MCRZ() tester
 
 Parameters
 ----------
 `angle` = 0.1
-`control_qubits` = [0, 1, 2, 3, 4, 5, 6, 7]
-`target_qubits` = [8]
+`control_indices` = [0, 1, 2, 3, 4, 5, 6, 7]
+`target_indices` = [8]
 """
-MCRZ_unitary_matrix_0dot1_01234567_8_qubits = np.load(prefix + "MCRZ_unitary_matrix_0dot1_01234567_8_qubits.npy")
+MCRZ_unitary_matrix_0dot1_01234567_8_qubits = np.load(
+    prefix + "MCRZ_unitary_matrix_0dot1_01234567_8_qubits.npy"
+)
 
 """ circuit.MCPhase() tester
 
 Parameters
 ----------
 `angle` = np.pi/4
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3]
 """
-MCPhase_unitary_matrix_pi_over_4_01_23_qubits = np.load(prefix + "MCPhase_unitary_matrix_pi_over_4_01_23_qubits.npy")
+MCPhase_unitary_matrix_pi_over_4_01_23_qubits = np.load(
+    prefix + "MCPhase_unitary_matrix_pi_over_4_01_23_qubits.npy"
+)
 
 """ circuit.MCPhase() tester
 
 Parameters
 ----------
 `angle` = np.pi/4
-`control_qubits` = [1, 0]
-`target_qubits` = [2, 3]
+`control_indices` = [1, 0]
+`target_indices` = [2, 3]
 """
-MCPhase_unitary_matrix_pi_over_4_10_23_qubits = np.load(prefix + "MCPhase_unitary_matrix_pi_over_4_10_23_qubits.npy")
+MCPhase_unitary_matrix_pi_over_4_10_23_qubits = np.load(
+    prefix + "MCPhase_unitary_matrix_pi_over_4_10_23_qubits.npy"
+)
 
 """ circuit.MCPhase() tester
 
 Parameters
 ----------
 `angle` = 1/4
-`control_qubits` = [0, 2]
-`target_qubits` = [1, 3]
+`control_indices` = [0, 2]
+`target_indices` = [1, 3]
 """
-MCPhase_unitary_matrix_1_over_4_02_13_qubits = np.load(prefix + "MCPhase_unitary_matrix_1_over_4_02_13_qubits.npy")
+MCPhase_unitary_matrix_1_over_4_02_13_qubits = np.load(
+    prefix + "MCPhase_unitary_matrix_1_over_4_02_13_qubits.npy"
+)
 
 """ circuit.MCPhase() tester
 
 Parameters
 ----------
 `angle` = 1/4
-`control_qubits` = [2, 0]
-`target_qubits` = [3, 4]
+`control_indices` = [2, 0]
+`target_indices` = [3, 4]
 """
-MCPhase_unitary_matrix_1_over_4_20_34_qubits = np.load(prefix + "MCPhase_unitary_matrix_1_over_4_20_34_qubits.npy")
+MCPhase_unitary_matrix_1_over_4_20_34_qubits = np.load(
+    prefix + "MCPhase_unitary_matrix_1_over_4_20_34_qubits.npy"
+)
 
 """ circuit.MCPhase() tester
 
 Parameters
 ----------
 `angle` = -1/4
-`control_qubits` = [1, 2]
-`target_qubits` = [0, 4]
+`control_indices` = [1, 2]
+`target_indices` = [0, 4]
 """
-MCPhase_unitary_matrix_negative1_over_4_12_04_qubits = np.load(prefix + "MCPhase_unitary_matrix_negative1_over_4_12_04_qubits.npy")
+MCPhase_unitary_matrix_negative1_over_4_12_04_qubits = np.load(
+    prefix + "MCPhase_unitary_matrix_negative1_over_4_12_04_qubits.npy"
+)
 
 """ circuit.MCPhase() tester
 
 Parameters
 ----------
 `angle` = -1/4
-`control_qubits` = [5, 3]
-`target_qubits` = [0, 1]
+`control_indices` = [5, 3]
+`target_indices` = [0, 1]
 """
-MCPhase_unitary_matrix_negative1_over_4_53_01_qubits = np.load(prefix + "MCPhase_unitary_matrix_negative1_over_4_53_01_qubits.npy")
+MCPhase_unitary_matrix_negative1_over_4_53_01_qubits = np.load(
+    prefix + "MCPhase_unitary_matrix_negative1_over_4_53_01_qubits.npy"
+)
 
 """ circuit.MCPhase() tester
 
 Parameters
 ----------
 `angle` = 1/3
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4]
 """
-MCPhase_unitary_matrix_1_over_3_012_34_qubits = np.load(prefix + "MCPhase_unitary_matrix_1_over_3_012_34_qubits.npy")
+MCPhase_unitary_matrix_1_over_3_012_34_qubits = np.load(
+    prefix + "MCPhase_unitary_matrix_1_over_3_012_34_qubits.npy"
+)
 
 """ circuit.MCPhase() tester
 
 Parameters
 ----------
 `angle` = 1/3
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3, 4]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3, 4]
 """
-MCPhase_unitary_matrix_1_over_3_01_234_qubits = np.load(prefix + "MCPhase_unitary_matrix_1_over_3_01_234_qubits.npy")
+MCPhase_unitary_matrix_1_over_3_01_234_qubits = np.load(
+    prefix + "MCPhase_unitary_matrix_1_over_3_01_234_qubits.npy"
+)
 
 """ circuit.MCPhase() tester
 
 Parameters
 ----------
 `angle` = pi/4
-`control_qubits` = [0, 1, 2]
-`target_qubits` = [3, 4, 5]
+`control_indices` = [0, 1, 2]
+`target_indices` = [3, 4, 5]
 """
-MCPhase_unitary_matrix_pi_over_4_012_345_qubits = np.load(prefix + "MCPhase_unitary_matrix_pi_over_4_012_345_qubits.npy")
+MCPhase_unitary_matrix_pi_over_4_012_345_qubits = np.load(
+    prefix + "MCPhase_unitary_matrix_pi_over_4_012_345_qubits.npy"
+)
 
 """ circuit.MCPhase() tester
 
 Parameters
 ----------
 `angle` = pi/4
-`control_qubits` = [0, 1]
-`target_qubits` = [2]
+`control_indices` = [0, 1]
+`target_indices` = [2]
 """
-MCPhase_unitary_matrix_pi_over_4_01_2_qubits = np.load(prefix + "MCPhase_unitary_matrix_pi_over_4_01_2_qubits.npy")
+MCPhase_unitary_matrix_pi_over_4_01_2_qubits = np.load(
+    prefix + "MCPhase_unitary_matrix_pi_over_4_01_2_qubits.npy"
+)
 
 """ circuit.MCPhase() tester
 
 Parameters
 ----------
 `angle` = pi/4
-`control_qubits` = [0]
-`target_qubits` = [2, 3]
+`control_indices` = [0]
+`target_indices` = [2, 3]
 """
-MCPhase_unitary_matrix_pi_over_4_0_23_qubits = np.load(prefix + "MCPhase_unitary_matrix_pi_over_4_0_23_qubits.npy")
+MCPhase_unitary_matrix_pi_over_4_0_23_qubits = np.load(
+    prefix + "MCPhase_unitary_matrix_pi_over_4_0_23_qubits.npy"
+)
 
 """ circuit.MCXPow() tester
 
@@ -3074,10 +3462,12 @@
 ----------
 `power` = 1/4
 `global_shift` = 0
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3]
 """
-MCXPow_unitary_matrix_1_over_4_0_shift_01_23_qubits = np.load(prefix + "MCXPow_unitary_matrix_1_over_4_0_shift_01_23_qubits.npy")
+MCXPow_unitary_matrix_1_over_4_0_shift_01_23_qubits = np.load(
+    prefix + "MCXPow_unitary_matrix_1_over_4_0_shift_01_23_qubits.npy"
+)
 
 """ circuit.MCXPow() tester
 
@@ -3085,10 +3475,12 @@
 ----------
 `power` = 1/4
 `global_shift` = 0
-`control_qubits` = [1, 0]
-`target_qubits` = [2, 3]
+`control_indices` = [1, 0]
+`target_indices` = [2, 3]
 """
-MCXPow_unitary_matrix_1_over_4_0_shift_10_23_qubits = np.load(prefix + "MCXPow_unitary_matrix_1_over_4_0_shift_10_23_qubits.npy")
+MCXPow_unitary_matrix_1_over_4_0_shift_10_23_qubits = np.load(
+    prefix + "MCXPow_unitary_matrix_1_over_4_0_shift_10_23_qubits.npy"
+)
 
 """ circuit.MCXPow() tester
 
@@ -3096,10 +3488,12 @@
 ----------
 `power` = 1/4
 `global_shift` = 0
-`control_qubits` = [0, 2]
-`target_qubits` = [1, 3]
+`control_indices` = [0, 2]
+`target_indices` = [1, 3]
 """
-MCXPow_unitary_matrix_1_over_4_0_shift_02_13_qubits = np.load(prefix + "MCXPow_unitary_matrix_1_over_4_0_shift_02_13_qubits.npy")
+MCXPow_unitary_matrix_1_over_4_0_shift_02_13_qubits = np.load(
+    prefix + "MCXPow_unitary_matrix_1_over_4_0_shift_02_13_qubits.npy"
+)
 
 """ circuit.MCXPow() tester
 
@@ -3107,10 +3501,12 @@
 ----------
 `power` = 1/4
 `global_shift` = 0
-`control_qubits` = [2, 0]
-`target_qubits` = [3, 4]
+`control_indices` = [2, 0]
+`target_indices` = [3, 4]
 """
-MCXPow_unitary_matrix_1_over_4_0_shift_20_34_qubits = np.load(prefix + "MCXPow_unitary_matrix_1_over_4_0_shift_20_34_qubits.npy")
+MCXPow_unitary_matrix_1_over_4_0_shift_20_34_qubits = np.load(
+    prefix + "MCXPow_unitary_matrix_1_over_4_0_shift_20_34_qubits.npy"
+)
 
 """ circuit.MCXPow() tester
 
@@ -3118,10 +3514,12 @@
 ----------
 `power` = -1/4
 `global_shift` = 0
-`control_qubits` = [1, 2]
-`target_qubits` = [0, 4]
+`control_indices` = [1, 2]
+`target_indices` = [0, 4]
 """
-MCXPow_unitary_matrix_negative1_over_4_0_shift_12_04_qubits = np.load(prefix + "MCXPow_unitary_matrix_negative1_over_4_0_shift_12_04_qubits.npy")
+MCXPow_unitary_matrix_negative1_over_4_0_shift_12_04_qubits = np.load(
+    prefix + "MCXPow_unitary_matrix_negative1_over_4_0_shift_12_04_qubits.npy"
+)
 
 """ circuit.MCXPow() tester
 
@@ -3129,10 +3527,12 @@
 ----------
 `power` = 1/4
 `global_shift` = 1/3
-`control_qubits` = [0, 1]
-`target_qubits` = [2]
+`control_indices` = [0, 1]
+`target_indices` = [2]
 """
-MCXPow_unitary_matrix_1_over_4_1_over_3_shift_01_2_qubits = np.load(prefix + "MCXPow_unitary_matrix_1_over_4_1_over_3_shift_01_2_qubits.npy")
+MCXPow_unitary_matrix_1_over_4_1_over_3_shift_01_2_qubits = np.load(
+    prefix + "MCXPow_unitary_matrix_1_over_4_1_over_3_shift_01_2_qubits.npy"
+)
 
 """ circuit.MCXPow() tester
 
@@ -3140,10 +3540,12 @@
 ----------
 `power` = 1/4
 `global_shift` = 1/3
-`control_qubits` = [0]
-`target_qubits` = [2, 3]
+`control_indices` = [0]
+`target_indices` = [2, 3]
 """
-MCXPow_unitary_matrix_1_over_4_1_over_3_shift_0_23_qubits = np.load(prefix + "MCXPow_unitary_matrix_1_over_4_1_over_3_shift_0_23_qubits.npy")
+MCXPow_unitary_matrix_1_over_4_1_over_3_shift_0_23_qubits = np.load(
+    prefix + "MCXPow_unitary_matrix_1_over_4_1_over_3_shift_0_23_qubits.npy"
+)
 
 """ circuit.MCXPow() tester
 
@@ -3151,10 +3553,13 @@
 ----------
 `power` = -1/4
 `global_shift` = 1/3
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3]
 """
-MCXPow_unitary_matrix_negative1_over_4_negative1_over_3_shift_01_23_qubits = np.load(prefix + "MCXPow_unitary_matrix_negative1_over_4_negative1_over_3_shift_01_23_qubits.npy")
+MCXPow_unitary_matrix_negative1_over_4_negative1_over_3_shift_01_23_qubits = np.load(
+    prefix
+    + "MCXPow_unitary_matrix_negative1_over_4_negative1_over_3_shift_01_23_qubits.npy"
+)
 
 """ circuit.MCYPow() tester
 
@@ -3162,10 +3567,12 @@
 ----------
 `power` = 1/4
 `global_shift` = 0
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3]
 """
-MCYPow_unitary_matrix_1_over_4_0_shift_01_23_qubits = np.load(prefix + "MCYPow_unitary_matrix_1_over_4_0_shift_01_23_qubits.npy")
+MCYPow_unitary_matrix_1_over_4_0_shift_01_23_qubits = np.load(
+    prefix + "MCYPow_unitary_matrix_1_over_4_0_shift_01_23_qubits.npy"
+)
 
 """ circuit.MCYPow() tester
 
@@ -3173,10 +3580,12 @@
 ----------
 `power` = 1/4
 `global_shift` = 0
-`control_qubits` = [1, 0]
-`target_qubits` = [2, 3]
+`control_indices` = [1, 0]
+`target_indices` = [2, 3]
 """
-MCYPow_unitary_matrix_1_over_4_0_shift_10_23_qubits = np.load(prefix + "MCYPow_unitary_matrix_1_over_4_0_shift_10_23_qubits.npy")
+MCYPow_unitary_matrix_1_over_4_0_shift_10_23_qubits = np.load(
+    prefix + "MCYPow_unitary_matrix_1_over_4_0_shift_10_23_qubits.npy"
+)
 
 """ circuit.MCYPow() tester
 
@@ -3184,10 +3593,12 @@
 ----------
 `power` = 1/4
 `global_shift` = 0
-`control_qubits` = [0, 2]
-`target_qubits` = [1, 3]
+`control_indices` = [0, 2]
+`target_indices` = [1, 3]
 """
-MCYPow_unitary_matrix_1_over_4_0_shift_02_13_qubits = np.load(prefix + "MCYPow_unitary_matrix_1_over_4_0_shift_02_13_qubits.npy")
+MCYPow_unitary_matrix_1_over_4_0_shift_02_13_qubits = np.load(
+    prefix + "MCYPow_unitary_matrix_1_over_4_0_shift_02_13_qubits.npy"
+)
 
 """ circuit.MCYPow() tester
 
@@ -3195,10 +3606,12 @@
 ----------
 `power` = 1/4
 `global_shift` = 0
-`control_qubits` = [2, 0]
-`target_qubits` = [3, 4]
+`control_indices` = [2, 0]
+`target_indices` = [3, 4]
 """
-MCYPow_unitary_matrix_1_over_4_0_shift_20_34_qubits = np.load(prefix + "MCYPow_unitary_matrix_1_over_4_0_shift_20_34_qubits.npy")
+MCYPow_unitary_matrix_1_over_4_0_shift_20_34_qubits = np.load(
+    prefix + "MCYPow_unitary_matrix_1_over_4_0_shift_20_34_qubits.npy"
+)
 
 """ circuit.MCYPow() tester
 
@@ -3206,10 +3619,12 @@
 ----------
 `power` = -1/4
 `global_shift` = 0
-`control_qubits` = [1, 2]
-`target_qubits` = [0, 4]
+`control_indices` = [1, 2]
+`target_indices` = [0, 4]
 """
-MCYPow_unitary_matrix_negative1_over_4_0_shift_12_04_qubits = np.load(prefix + "MCYPow_unitary_matrix_negative1_over_4_0_shift_12_04_qubits.npy")
+MCYPow_unitary_matrix_negative1_over_4_0_shift_12_04_qubits = np.load(
+    prefix + "MCYPow_unitary_matrix_negative1_over_4_0_shift_12_04_qubits.npy"
+)
 
 """ circuit.MCYPow() tester
 
@@ -3217,10 +3632,12 @@
 ----------
 `power` = 1/4
 `global_shift` = 1/3
-`control_qubits` = [0, 1]
-`target_qubits` = [2]
+`control_indices` = [0, 1]
+`target_indices` = [2]
 """
-MCYPow_unitary_matrix_1_over_4_1_over_3_shift_01_2_qubits = np.load(prefix + "MCYPow_unitary_matrix_1_over_4_1_over_3_shift_01_2_qubits.npy")
+MCYPow_unitary_matrix_1_over_4_1_over_3_shift_01_2_qubits = np.load(
+    prefix + "MCYPow_unitary_matrix_1_over_4_1_over_3_shift_01_2_qubits.npy"
+)
 
 """ circuit.MCYPow() tester
 
@@ -3228,10 +3645,12 @@
 ----------
 `power` = 1/4
 `global_shift` = 1/3
-`control_qubits` = [0]
-`target_qubits` = [2, 3]
+`control_indices` = [0]
+`target_indices` = [2, 3]
 """
-MCYPow_unitary_matrix_1_over_4_1_over_3_shift_0_23_qubits = np.load(prefix + "MCYPow_unitary_matrix_1_over_4_1_over_3_shift_0_23_qubits.npy")
+MCYPow_unitary_matrix_1_over_4_1_over_3_shift_0_23_qubits = np.load(
+    prefix + "MCYPow_unitary_matrix_1_over_4_1_over_3_shift_0_23_qubits.npy"
+)
 
 """ circuit.MCYPow() tester
 
@@ -3239,10 +3658,13 @@
 ----------
 `power` = -1/4
 `global_shift` = 1/3
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3]
 """
-MCYPow_unitary_matrix_negative1_over_4_negative1_over_3_shift_01_23_qubits = np.load(prefix + "MCYPow_unitary_matrix_negative1_over_4_negative1_over_3_shift_01_23_qubits.npy")
+MCYPow_unitary_matrix_negative1_over_4_negative1_over_3_shift_01_23_qubits = np.load(
+    prefix
+    + "MCYPow_unitary_matrix_negative1_over_4_negative1_over_3_shift_01_23_qubits.npy"
+)
 
 """ circuit.MCZPow() tester
 
@@ -3250,10 +3672,12 @@
 ----------
 `power` = 1/4
 `global_shift` = 0
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3]
 """
-MCZPow_unitary_matrix_1_over_4_0_shift_01_23_qubits = np.load(prefix + "MCZPow_unitary_matrix_1_over_4_0_shift_01_23_qubits.npy")
+MCZPow_unitary_matrix_1_over_4_0_shift_01_23_qubits = np.load(
+    prefix + "MCZPow_unitary_matrix_1_over_4_0_shift_01_23_qubits.npy"
+)
 
 """ circuit.MCZPow() tester
 
@@ -3261,10 +3685,12 @@
 ----------
 `power` = 1/4
 `global_shift` = 0
-`control_qubits` = [1, 0]
-`target_qubits` = [2, 3]
+`control_indices` = [1, 0]
+`target_indices` = [2, 3]
 """
-MCZPow_unitary_matrix_1_over_4_0_shift_10_23_qubits = np.load(prefix + "MCZPow_unitary_matrix_1_over_4_0_shift_10_23_qubits.npy")
+MCZPow_unitary_matrix_1_over_4_0_shift_10_23_qubits = np.load(
+    prefix + "MCZPow_unitary_matrix_1_over_4_0_shift_10_23_qubits.npy"
+)
 
 """ circuit.MCZPow() tester
 
@@ -3272,10 +3698,12 @@
 ----------
 `power` = 1/4
 `global_shift` = 0
-`control_qubits` = [0, 2]
-`target_qubits` = [1, 3]
+`control_indices` = [0, 2]
+`target_indices` = [1, 3]
 """
-MCZPow_unitary_matrix_1_over_4_0_shift_02_13_qubits = np.load(prefix + "MCZPow_unitary_matrix_1_over_4_0_shift_02_13_qubits.npy")
+MCZPow_unitary_matrix_1_over_4_0_shift_02_13_qubits = np.load(
+    prefix + "MCZPow_unitary_matrix_1_over_4_0_shift_02_13_qubits.npy"
+)
 
 """ circuit.MCZPow() tester
 
@@ -3283,10 +3711,12 @@
 ----------
 `power` = 1/4
 `global_shift` = 0
-`control_qubits` = [2, 0]
-`target_qubits` = [3, 4]
+`control_indices` = [2, 0]
+`target_indices` = [3, 4]
 """
-MCZPow_unitary_matrix_1_over_4_0_shift_20_34_qubits = np.load(prefix + "MCZPow_unitary_matrix_1_over_4_0_shift_20_34_qubits.npy")
+MCZPow_unitary_matrix_1_over_4_0_shift_20_34_qubits = np.load(
+    prefix + "MCZPow_unitary_matrix_1_over_4_0_shift_20_34_qubits.npy"
+)
 
 """ circuit.MCZPow() tester
 
@@ -3294,10 +3724,12 @@
 ----------
 `power` = -1/4
 `global_shift` = 0
-`control_qubits` = [1, 2]
-`target_qubits` = [0, 4]
+`control_indices` = [1, 2]
+`target_indices` = [0, 4]
 """
-MCZPow_unitary_matrix_negative1_over_4_0_shift_12_04_qubits = np.load(prefix + "MCZPow_unitary_matrix_negative1_over_4_0_shift_12_04_qubits.npy")
+MCZPow_unitary_matrix_negative1_over_4_0_shift_12_04_qubits = np.load(
+    prefix + "MCZPow_unitary_matrix_negative1_over_4_0_shift_12_04_qubits.npy"
+)
 
 """ circuit.MCZPow() tester
 
@@ -3305,10 +3737,12 @@
 ----------
 `power` = 1/4
 `global_shift` = 1/3
-`control_qubits` = [0, 1]
-`target_qubits` = [2]
+`control_indices` = [0, 1]
+`target_indices` = [2]
 """
-MCZPow_unitary_matrix_1_over_4_1_over_3_shift_01_2_qubits = np.load(prefix + "MCZPow_unitary_matrix_1_over_4_1_over_3_shift_01_2_qubits.npy")
+MCZPow_unitary_matrix_1_over_4_1_over_3_shift_01_2_qubits = np.load(
+    prefix + "MCZPow_unitary_matrix_1_over_4_1_over_3_shift_01_2_qubits.npy"
+)
 
 """ circuit.MCZPow() tester
 
@@ -3316,10 +3750,12 @@
 ----------
 `power` = 1/4
 `global_shift` = 1/3
-`control_qubits` = [0]
-`target_qubits` = [2, 3]
+`control_indices` = [0]
+`target_indices` = [2, 3]
 """
-MCZPow_unitary_matrix_1_over_4_1_over_3_shift_0_23_qubits = np.load(prefix + "MCZPow_unitary_matrix_1_over_4_1_over_3_shift_0_23_qubits.npy")
+MCZPow_unitary_matrix_1_over_4_1_over_3_shift_0_23_qubits = np.load(
+    prefix + "MCZPow_unitary_matrix_1_over_4_1_over_3_shift_0_23_qubits.npy"
+)
 
 """ circuit.MCZPow() tester
 
@@ -3327,810 +3763,864 @@
 ----------
 `power` = -1/4
 `global_shift` = 1/3
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3]
 """
-MCZPow_unitary_matrix_negative1_over_4_negative1_over_3_shift_01_23_qubits = np.load(prefix + "MCZPow_unitary_matrix_negative1_over_4_negative1_over_3_shift_01_23_qubits.npy")
+MCZPow_unitary_matrix_negative1_over_4_negative1_over_3_shift_01_23_qubits = np.load(
+    prefix
+    + "MCZPow_unitary_matrix_negative1_over_4_negative1_over_3_shift_01_23_qubits.npy"
+)
 
 """ circuit.MCRXX() tester
 
 Parameters
 ----------
 `angle` = np.pi/4
-`control_qubits` = [0, 1]
+`control_indices` = [0, 1]
 `first_target_index` = 2
 `second_target_index` = 3
 """
-MCRXX_unitary_matrix_pi_over_4_01_23_qubits = np.load(prefix + "MCRXX_unitary_matrix_pi_over_4_01_23_qubits.npy")
+MCRXX_unitary_matrix_pi_over_4_01_23_qubits = np.load(
+    prefix + "MCRXX_unitary_matrix_pi_over_4_01_23_qubits.npy"
+)
 
 """ circuit.MCRXX() tester
 
 Parameters
 ----------
 `angle` = np.pi/4
-`control_qubits` = [1, 0]
+`control_indices` = [1, 0]
 `first_target_index` = 2
 `second_target_index` = 3
 """
-MCRXX_unitary_matrix_pi_over_4_10_23_qubits = np.load(prefix + "MCRXX_unitary_matrix_pi_over_4_10_23_qubits.npy")
+MCRXX_unitary_matrix_pi_over_4_10_23_qubits = np.load(
+    prefix + "MCRXX_unitary_matrix_pi_over_4_10_23_qubits.npy"
+)
 
 """ circuit.MCRXX() tester
 
 Parameters
 ----------
 `angle` = 1/4
-`control_qubits` = [0, 2]
+`control_indices` = [0, 2]
 `first_target_index` = 1
 `second_target_index` = 3
 """
-MCRXX_unitary_matrix_1_over_4_02_13_qubits = np.load(prefix + "MCRXX_unitary_matrix_1_over_4_02_13_qubits.npy")
+MCRXX_unitary_matrix_1_over_4_02_13_qubits = np.load(
+    prefix + "MCRXX_unitary_matrix_1_over_4_02_13_qubits.npy"
+)
 
 """ circuit.MCRXX() tester
 
 Parameters
 ----------
 `angle` = 1/4
-`control_qubits` = [2, 0]
+`control_indices` = [2, 0]
 `first_target_index` = 3
 `second_target_index` = 4
 """
-MCRXX_unitary_matrix_1_over_4_20_34_qubits = np.load(prefix + "MCRXX_unitary_matrix_1_over_4_20_34_qubits.npy")
+MCRXX_unitary_matrix_1_over_4_20_34_qubits = np.load(
+    prefix + "MCRXX_unitary_matrix_1_over_4_20_34_qubits.npy"
+)
 
 """ circuit.MCRXX() tester
 
 Parameters
 ----------
 `angle` = -1/4
-`control_qubits` = [1, 2]
+`control_indices` = [1, 2]
 `first_target_index` = 0
 `second_target_index` = 4
 """
-MCRXX_unitary_matrix_negative1_over_4_12_04_qubits = np.load(prefix + "MCRXX_unitary_matrix_negative1_over_4_12_04_qubits.npy")
+MCRXX_unitary_matrix_negative1_over_4_12_04_qubits = np.load(
+    prefix + "MCRXX_unitary_matrix_negative1_over_4_12_04_qubits.npy"
+)
 
 """ circuit.MCRXX() tester
 
 Parameters
 ----------
 `angle` = -1/4
-`control_qubits` = [5, 3]
+`control_indices` = [5, 3]
 `first_target_index` = 0
 `second_target_index` = 1
 """
-MCRXX_unitary_matrix_negative1_over_4_53_01_qubits = np.load(prefix + "MCRXX_unitary_matrix_negative1_over_4_53_01_qubits.npy")
+MCRXX_unitary_matrix_negative1_over_4_53_01_qubits = np.load(
+    prefix + "MCRXX_unitary_matrix_negative1_over_4_53_01_qubits.npy"
+)
 
 """ circuit.MCRXX() tester
 
 Parameters
 ----------
 `angle` = 1/3
-`control_qubits` = [0, 1, 2]
+`control_indices` = [0, 1, 2]
 `first_target_index` = 3
 `second_target_index` = 4
 """
-MCRXX_unitary_matrix_1_over_3_012_34_qubits = np.load(prefix + "MCRXX_unitary_matrix_1_over_3_012_34_qubits.npy")
+MCRXX_unitary_matrix_1_over_3_012_34_qubits = np.load(
+    prefix + "MCRXX_unitary_matrix_1_over_3_012_34_qubits.npy"
+)
 
 """ circuit.MCRXX() tester
 
 Parameters
 ----------
 `angle` = 1/3
-`control_qubits` = [0]
+`control_indices` = [0]
 `first_target_index` = 2
 `second_target_index` = 3
 """
-MCRXX_unitary_matrix_1_over_3_0_23_qubits = np.load(prefix + "MCRXX_unitary_matrix_1_over_3_0_23_qubits.npy")
+MCRXX_unitary_matrix_1_over_3_0_23_qubits = np.load(
+    prefix + "MCRXX_unitary_matrix_1_over_3_0_23_qubits.npy"
+)
 
 """ circuit.MCRYY() tester
 
 Parameters
 ----------
 `angle` = np.pi/4
-`control_qubits` = [0, 1]
+`control_indices` = [0, 1]
 `first_target_index` = 2
 `second_target_index` = 3
 """
-MCRYY_unitary_matrix_pi_over_4_01_23_qubits = np.load(prefix + "MCRYY_unitary_matrix_pi_over_4_01_23_qubits.npy")
+MCRYY_unitary_matrix_pi_over_4_01_23_qubits = np.load(
+    prefix + "MCRYY_unitary_matrix_pi_over_4_01_23_qubits.npy"
+)
 
 """ circuit.MCRYY() tester
 
 Parameters
 ----------
 `angle` = np.pi/4
-`control_qubits` = [1, 0]
+`control_indices` = [1, 0]
 `first_target_index` = 2
 `second_target_index` = 3
 """
-MCRYY_unitary_matrix_pi_over_4_10_23_qubits = np.load(prefix + "MCRYY_unitary_matrix_pi_over_4_10_23_qubits.npy")
+MCRYY_unitary_matrix_pi_over_4_10_23_qubits = np.load(
+    prefix + "MCRYY_unitary_matrix_pi_over_4_10_23_qubits.npy"
+)
 
 """ circuit.MCRYY() tester
 
 Parameters
 ----------
 `angle` = 1/4
-`control_qubits` = [0, 2]
+`control_indices` = [0, 2]
 `first_target_index` = 1
 `second_target_index` = 3
 """
-MCRYY_unitary_matrix_1_over_4_02_13_qubits = np.load(prefix + "MCRYY_unitary_matrix_1_over_4_02_13_qubits.npy")
+MCRYY_unitary_matrix_1_over_4_02_13_qubits = np.load(
+    prefix + "MCRYY_unitary_matrix_1_over_4_02_13_qubits.npy"
+)
 
 """ circuit.MCRYY() tester
 
 Parameters
 ----------
 `angle` = 1/4
-`control_qubits` = [2, 0]
+`control_indices` = [2, 0]
 `first_target_index` = 3
 `second_target_index` = 4
 """
-MCRYY_unitary_matrix_1_over_4_20_34_qubits = np.load(prefix + "MCRYY_unitary_matrix_1_over_4_20_34_qubits.npy")
+MCRYY_unitary_matrix_1_over_4_20_34_qubits = np.load(
+    prefix + "MCRYY_unitary_matrix_1_over_4_20_34_qubits.npy"
+)
 
 """ circuit.MCRYY() tester
 
 Parameters
 ----------
 `angle` = -1/4
-`control_qubits` = [1, 2]
+`control_indices` = [1, 2]
 `first_target_index` = 0
 `second_target_index` = 4
 """
-MCRYY_unitary_matrix_negative1_over_4_12_04_qubits = np.load(prefix + "MCRYY_unitary_matrix_negative1_over_4_12_04_qubits.npy")
+MCRYY_unitary_matrix_negative1_over_4_12_04_qubits = np.load(
+    prefix + "MCRYY_unitary_matrix_negative1_over_4_12_04_qubits.npy"
+)
 
 """ circuit.MCRYY() tester
 
 Parameters
 ----------
 `angle` = -1/4
-`control_qubits` = [5, 3]
+`control_indices` = [5, 3]
 `first_target_index` = 0
 `second_target_index` = 1
 """
-MCRYY_unitary_matrix_negative1_over_4_53_01_qubits = np.load(prefix + "MCRYY_unitary_matrix_negative1_over_4_53_01_qubits.npy")
+MCRYY_unitary_matrix_negative1_over_4_53_01_qubits = np.load(
+    prefix + "MCRYY_unitary_matrix_negative1_over_4_53_01_qubits.npy"
+)
 
 """ circuit.MCRYY() tester
 
 Parameters
 ----------
 `angle` = 1/3
-`control_qubits` = [0, 1, 2]
+`control_indices` = [0, 1, 2]
 `first_target_index` = 3
 `second_target_index` = 4
 """
-MCRYY_unitary_matrix_1_over_3_012_34_qubits = np.load(prefix + "MCRYY_unitary_matrix_1_over_3_012_34_qubits.npy")
+MCRYY_unitary_matrix_1_over_3_012_34_qubits = np.load(
+    prefix + "MCRYY_unitary_matrix_1_over_3_012_34_qubits.npy"
+)
 
 """ circuit.MCRYY() tester
 
 Parameters
 ----------
 `angle` = 1/3
-`control_qubits` = [0]
+`control_indices` = [0]
 `first_target_index` = 2
 `second_target_index` = 3
 """
-MCRYY_unitary_matrix_1_over_3_0_23_qubits = np.load(prefix + "MCRYY_unitary_matrix_1_over_3_0_23_qubits.npy")
+MCRYY_unitary_matrix_1_over_3_0_23_qubits = np.load(
+    prefix + "MCRYY_unitary_matrix_1_over_3_0_23_qubits.npy"
+)
 
 """ circuit.MCRZZ() tester
 
 Parameters
 ----------
 `angle` = np.pi/4
-`control_qubits` = [0, 1]
+`control_indices` = [0, 1]
 `first_target_index` = 2
 `second_target_index` = 3
 """
-MCRZZ_unitary_matrix_pi_over_4_01_23_qubits = np.load(prefix + "MCRZZ_unitary_matrix_pi_over_4_01_23_qubits.npy")
+MCRZZ_unitary_matrix_pi_over_4_01_23_qubits = np.load(
+    prefix + "MCRZZ_unitary_matrix_pi_over_4_01_23_qubits.npy"
+)
 
 """ circuit.MCRZZ() tester
 
 Parameters
 ----------
 `angle` = np.pi/4
-`control_qubits` = [1, 0]
+`control_indices` = [1, 0]
 `first_target_index` = 2
 `second_target_index` = 3
 """
-MCRZZ_unitary_matrix_pi_over_4_10_23_qubits = np.load(prefix + "MCRZZ_unitary_matrix_pi_over_4_10_23_qubits.npy")
+MCRZZ_unitary_matrix_pi_over_4_10_23_qubits = np.load(
+    prefix + "MCRZZ_unitary_matrix_pi_over_4_10_23_qubits.npy"
+)
 
 """ circuit.MCRZZ() tester
 
 Parameters
 ----------
 `angle` = 1/4
-`control_qubits` = [0, 2]
+`control_indices` = [0, 2]
 `first_target_index` = 1
 `second_target_index` = 3
 """
-MCRZZ_unitary_matrix_1_over_4_02_13_qubits = np.load(prefix + "MCRZZ_unitary_matrix_1_over_4_02_13_qubits.npy")
+MCRZZ_unitary_matrix_1_over_4_02_13_qubits = np.load(
+    prefix + "MCRZZ_unitary_matrix_1_over_4_02_13_qubits.npy"
+)
 
 """ circuit.MCRZZ() tester
 
 Parameters
 ----------
 `angle` = 1/4
-`control_qubits` = [2, 0]
+`control_indices` = [2, 0]
 `first_target_index` = 3
 `second_target_index` = 4
 """
-MCRZZ_unitary_matrix_1_over_4_20_34_qubits = np.load(prefix + "MCRZZ_unitary_matrix_1_over_4_20_34_qubits.npy")
+MCRZZ_unitary_matrix_1_over_4_20_34_qubits = np.load(
+    prefix + "MCRZZ_unitary_matrix_1_over_4_20_34_qubits.npy"
+)
 
 """ circuit.MCRZZ() tester
 
 Parameters
 ----------
 `angle` = -1/4
-`control_qubits` = [1, 2]
+`control_indices` = [1, 2]
 `first_target_index` = 0
 `second_target_index` = 4
 """
-MCRZZ_unitary_matrix_negative1_over_4_12_04_qubits = np.load(prefix + "MCRZZ_unitary_matrix_negative1_over_4_12_04_qubits.npy")
+MCRZZ_unitary_matrix_negative1_over_4_12_04_qubits = np.load(
+    prefix + "MCRZZ_unitary_matrix_negative1_over_4_12_04_qubits.npy"
+)
 
 """ circuit.MCRZZ() tester
 
 Parameters
 ----------
 `angle` = -1/4
-`control_qubits` = [5, 3]
+`control_indices` = [5, 3]
 `first_target_index` = 0
 `second_target_index` = 1
 """
-MCRZZ_unitary_matrix_negative1_over_4_53_01_qubits = np.load(prefix + "MCRZZ_unitary_matrix_negative1_over_4_53_01_qubits.npy")
+MCRZZ_unitary_matrix_negative1_over_4_53_01_qubits = np.load(
+    prefix + "MCRZZ_unitary_matrix_negative1_over_4_53_01_qubits.npy"
+)
 
 """ circuit.MCRZZ() tester
 
 Parameters
 ----------
 `angle` = 1/3
-`control_qubits` = [0, 1, 2]
+`control_indices` = [0, 1, 2]
 `first_target_index` = 3
 `second_target_index` = 4
 """
-MCRZZ_unitary_matrix_1_over_3_012_34_qubits = np.load(prefix + "MCRZZ_unitary_matrix_1_over_3_012_34_qubits.npy")
+MCRZZ_unitary_matrix_1_over_3_012_34_qubits = np.load(
+    prefix + "MCRZZ_unitary_matrix_1_over_3_012_34_qubits.npy"
+)
 
 """ circuit.MCRZZ() tester
 
 Parameters
 ----------
 `angle` = 1/3
-`control_qubits` = [0]
+`control_indices` = [0]
 `first_target_index` = 2
 `second_target_index` = 3
 """
-MCRZZ_unitary_matrix_1_over_3_0_23_qubits = np.load(prefix + "MCRZZ_unitary_matrix_1_over_3_0_23_qubits.npy")
+MCRZZ_unitary_matrix_1_over_3_0_23_qubits = np.load(
+    prefix + "MCRZZ_unitary_matrix_1_over_3_0_23_qubits.npy"
+)
 
 """ circuit.MCU3() tester
 
 Parameters
 ----------
 `angles` = (np.pi/2, np.pi/3, np.pi/4)
-`control_qubits` = [0, 1]
-`target_qubits` = [2, 3]
+`control_indices` = [0, 1]
+`target_indices` = [2, 3]
 """
-MCU3_unitary_matrix_pi_over_2_pi_over_3_pi_over_4_01_23_qubits = np.load(prefix + "MCU3_unitary_matrix_pi_over_2_pi_over_3_pi_over_4_01_23_qubits.npy")
+MCU3_unitary_matrix_pi_over_2_pi_over_3_pi_over_4_01_23_qubits = np.load(
+    prefix + "MCU3_unitary_matrix_pi_over_2_pi_over_3_pi_over_4_01_23_qubits.npy"
+)
 
 """ circuit.MCU3() tester
 
 Parameters
 ----------
 `angles` = (np.pi/2, np.pi/3, np.pi/4)
-`control_qubits` = [1, 0]
-`target_qubits` = [2, 3]
+`control_indices` = [1, 0]
+`target_indices` = [2, 3]
 """
-MCU3_unitary_matrix_pi_over_2_pi_over_3_pi_over_4_10_23_qubits = np.load(prefix + "MCU3_unitary_matrix_pi_over_2_pi_over_3_pi_over_4_10_23_qubits.npy")
+MCU3_unitary_matrix_pi_over_2_pi_over_3_pi_over_4_10_23_qubits = np.load(
+    prefix + "MCU3_unitary_matrix_pi_over_2_pi_over_3_pi_over_4_10_23_qubits.npy"
+)
 
 """ circuit.MCU3() tester
 
 Parameters
 ----------
 `angles` = (1/2, 1/3, 1/4)
-`control_qubits` = [0, 2]
-`target_qubits` = [1, 3]
+`control_indices` = [0, 2]
+`target_indices` = [1, 3]
 """
-MCU3_unitary_matrix_1_over_2_1_over_3_1_over_4_02_13_qubits = np.load(prefix + "MCU3_unitary_matrix_1_over_2_1_over_3_1_over_4_02_13_qubits.npy")
+MCU3_unitary_matrix_1_over_2_1_over_3_1_over_4_02_13_qubits = np.load(
+    prefix + "MCU3_unitary_matrix_1_over_2_1_over_3_1_over_4_02_13_qubits.npy"
+)
 
 """ circuit.MCU3() tester
 
 Parameters
 ----------
 `angles` = (1/2, 1/3, 1/4)
-`control_qubits` = [2, 0]
-`target_qubits` = [3, 4]
+`control_indices` = [2, 0]
+`target_indices` = [3, 4]
 """
-MCU3_unitary_matrix_1_over_2_1_over_3_1_over_4_20_34_qubits = np.load(prefix + "MCU3_unitary_matrix_1_over_2_1_over_3_1_over_4_20_34_qubits.npy")
+MCU3_unitary_matrix_1_over_2_1_over_3_1_over_4_20_34_qubits = np.load(
+    prefix + "MCU3_unitary_matrix_1_over_2_1_over_3_1_over_4_20_34_qubits.npy"
+)
 
 """ circuit.MCU3() tester
 
 Parameters
 ----------
 `angles` = (-1/2, -1/3, -1/4)
-`control_qubits` = [1, 2]
-`target_qubits` = [0, 4]
+`control_indices` = [1, 2]
+`target_indices` = [0, 4]
 """
-MCU3_unitary_matrix_negative1_over_2_negative1_over_3_negative1_over_4_12_04_qubits = np.load(prefix + "MCU3_unitary_matrix_negative1_over_2_negative1_over_3_negative1_over_4_12_04_qubits.npy")
+MCU3_unitary_matrix_negative1_over_2_negative1_over_3_negative1_over_4_12_04_qubits = np.load(
+    prefix
+    + "MCU3_unitary_matrix_negative1_over_2_negative1_over_3_negative1_over_4_12_04_qubits.npy"
+)
 
 """ circuit.MCU3() tester
 
 Parameters
 ----------
 `angles` = (np.pi/2, np.pi/3, np.pi/4)
-`control_qubits` = [1, 2, 3]
-`target_qubits` = [4, 5]
+`control_indices` = [1, 2, 3]
+`target_indices` = [4, 5]
 """
-MCU3_unitary_matrix_pi_over_2_pi_over_3_pi_over_4_123_45_qubits = np.load(prefix + "MCU3_unitary_matrix_pi_over_2_pi_over_3_pi_over_4_123_45_qubits.npy")
+MCU3_unitary_matrix_pi_over_2_pi_over_3_pi_over_4_123_45_qubits = np.load(
+    prefix + "MCU3_unitary_matrix_pi_over_2_pi_over_3_pi_over_4_123_45_qubits.npy"
+)
 
 """ circuit.MCU3() tester
 
 Parameters
 ----------
 `angles` = (np.pi/2, np.pi/3, np.pi/4)
-`control_qubits` = [0]
-`target_qubits` = [1, 2]
+`control_indices` = [0]
+`target_indices` = [1, 2]
 """
-MCU3_unitary_matrix_pi_over_2_pi_over_3_pi_over_4_0_12_qubits = np.load(prefix + "MCU3_unitary_matrix_pi_over_2_pi_over_3_pi_over_4_0_12_qubits.npy")
+MCU3_unitary_matrix_pi_over_2_pi_over_3_pi_over_4_0_12_qubits = np.load(
+    prefix + "MCU3_unitary_matrix_pi_over_2_pi_over_3_pi_over_4_0_12_qubits.npy"
+)
 
 """ circuit.MCSWAP() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 1]
+`control_indices` = [0, 1]
 `first_target_index` = 2
 `second_target_index` = 3
 """
-MCSWAP_unitary_matrix_01_23_qubits = np.load(prefix + "MCSWAP_unitary_matrix_01_23_qubits.npy")
+MCSWAP_unitary_matrix_01_23_qubits = np.load(
+    prefix + "MCSWAP_unitary_matrix_01_23_qubits.npy"
+)
 
 """ circuit.MCSWAP() tester
 
 Parameters
 ----------
-`control_qubits` = [1, 0]
+`control_indices` = [1, 0]
 `first_target_index` = 2
 `second_target_index` = 3
 """
-MCSWAP_unitary_matrix_10_23_qubits = np.load(prefix + "MCSWAP_unitary_matrix_10_23_qubits.npy")
+MCSWAP_unitary_matrix_10_23_qubits = np.load(
+    prefix + "MCSWAP_unitary_matrix_10_23_qubits.npy"
+)
 
 """ circuit.MCSWAP() tester
 
 Parameters
 ----------
-`control_qubits` = [0, 2]
+`control_indices` = [0, 2]
 `first_target_index` = 1
 `second_target_index` = 3
 """
-MCSWAP_unitary_matrix_02_13_qubits = np.load(prefix + "MCSWAP_unitary_matrix_02_13_qubits.npy")
+MCSWAP_unitary_matrix_02_13_qubits = np.load(
+    prefix + "MCSWAP_unitary_matrix_02_13_qubits.npy"
+)
 
 """ circuit.MCSWAP() tester
 
 Parameters
 ----------
-`control_qubits` = [2, 0]
+`control_indices` = [2, 0]
 `first_target_index` = 3
 `second_target_index` = 4
 """
-MCSWAP_unitary_matrix_20_34_qubits = np.load(prefix + "MCSWAP_unitary_matrix_20_34_qubits.npy")
+MCSWAP_unitary_matrix_20_34_qubits = np.load(
+    prefix + "MCSWAP_unitary_matrix_20_34_qubits.npy"
+)
 
 """ circuit.MCSWAP() tester
 
 Parameters
 ----------
-`control_qubits` = [1, 2, 3]
+`control_indices` = [1, 2, 3]
 `first_target_index` = 4
 `second_target_index` = 5
 """
-MCSWAP_unitary_matrix_123_45_qubits = np.load(prefix + "MCSWAP_unitary_matrix_123_45_qubits.npy")
+MCSWAP_unitary_matrix_123_45_qubits = np.load(
+    prefix + "MCSWAP_unitary_matrix_123_45_qubits.npy"
+)
 
 """ circuit.MCSWAP() tester
 
 Parameters
 ----------
-`control_qubits` = [0]
+`control_indices` = [0]
 `first_target_index` = 2
 `second_target_index` = 3
 """
-MCSWAP_unitary_matrix_0_23_qubits = np.load(prefix + "MCSWAP_unitary_matrix_0_23_qubits.npy")
+MCSWAP_unitary_matrix_0_23_qubits = np.load(
+    prefix + "MCSWAP_unitary_matrix_0_23_qubits.npy"
+)
 
 """ circuit.UCRX() tester
 
 Parameters
 ----------
 `angles` = (np.pi/2, np.pi/3, np.pi/4, np.pi/5)
-`control_qubits` = [0, 1]
-`target_qubits` = 2
+`control_indices` = [0, 1]
+`target_index` = 2
 """
-UCRX_unitary_matrix_3qubits_01control = np.load(prefix + "UCRX_unitary_matrix_3qubits_01control.npy")
+UCRX_unitary_matrix_3qubits_01control = np.load(
+    prefix + "UCRX_unitary_matrix_3qubits_01control.npy"
+)
 
 """ circuit.UCRX() tester
 
 Parameters
 ----------
 `angles` = (np.pi/2, np.pi/3, np.pi/4, np.pi/5)
-`control_qubits` = [1, 0]
-`target_qubits` = 2
+`control_indices` = [1, 0]
+`target_index` = 2
 """
-UCRX_unitary_matrix_3qubits_10control = np.load(prefix + "UCRX_unitary_matrix_3qubits_10control.npy")
+UCRX_unitary_matrix_3qubits_10control = np.load(
+    prefix + "UCRX_unitary_matrix_3qubits_10control.npy"
+)
 
 """ circuit.UCRX() tester
 
 Parameters
 ----------
 `angles` = (np.pi/2, np.pi/3, np.pi/4, np.pi/5, np.pi/6, np.pi/7, np.pi/8, np.pi/9)
-`control_qubits` = [0, 2, 3]
-`target_qubits` = 1
+`control_indices` = [0, 2, 3]
+`target_index` = 1
 """
-UCRX_unitary_matrix_4qubits_023control = np.load(prefix + "UCRX_unitary_matrix_4qubits_023control.npy")
+UCRX_unitary_matrix_4qubits_023control = np.load(
+    prefix + "UCRX_unitary_matrix_4qubits_023control.npy"
+)
 
 """ circuit.UCRX() tester
 
 Parameters
 ----------
 `angles` = (np.pi/2, np.pi/3, np.pi/4, np.pi/5, np.pi/6, np.pi/7, np.pi/8, np.pi/9)
-`control_qubits` = [2, 1, 3]
-`target_qubits` = 0
+`control_indices` = [2, 1, 3]
+`target_index` = 0
 """
-UCRX_unitary_matrix_4qubits_213control = np.load(prefix + "UCRX_unitary_matrix_4qubits_213control.npy")
+UCRX_unitary_matrix_4qubits_213control = np.load(
+    prefix + "UCRX_unitary_matrix_4qubits_213control.npy"
+)
 
 """ circuit.UCRY() tester
 
 Parameters
 ----------
 `angles` = (np.pi/2, np.pi/3, np.pi/4, np.pi/5)
-`control_qubits` = [0, 1]
-`target_qubits` = 2
+`control_indices` = [0, 1]
+`target_index` = 2
 """
-UCRY_unitary_matrix_3qubits_01control = np.load(prefix + "UCRY_unitary_matrix_3qubits_01control.npy")
+UCRY_unitary_matrix_3qubits_01control = np.load(
+    prefix + "UCRY_unitary_matrix_3qubits_01control.npy"
+)
 
 """ circuit.UCRY() tester
 
 Parameters
 ----------
 `angles` = (np.pi/2, np.pi/3, np.pi/4, np.pi/5)
-`control_qubits` = [1, 0]
-`target_qubits` = 2
+`control_indices` = [1, 0]
+`target_index` = 2
 """
-UCRY_unitary_matrix_3qubits_10control = np.load(prefix + "UCRY_unitary_matrix_3qubits_10control.npy")
+UCRY_unitary_matrix_3qubits_10control = np.load(
+    prefix + "UCRY_unitary_matrix_3qubits_10control.npy"
+)
 
 """ circuit.UCRY() tester
 
 Parameters
 ----------
 `angles` = (np.pi/2, np.pi/3, np.pi/4, np.pi/5, np.pi/6, np.pi/7, np.pi/8, np.pi/9)
-`control_qubits` = [0, 2, 3]
-`target_qubits` = 1
+`control_indices` = [0, 2, 3]
+`target_index` = 1
 """
-UCRY_unitary_matrix_4qubits_023control = np.load(prefix + "UCRY_unitary_matrix_4qubits_023control.npy")
+UCRY_unitary_matrix_4qubits_023control = np.load(
+    prefix + "UCRY_unitary_matrix_4qubits_023control.npy"
+)
 
 """ circuit.UCRY() tester
 
 Parameters
 ----------
 `angles` = (np.pi/2, np.pi/3, np.pi/4, np.pi/5, np.pi/6, np.pi/7, np.pi/8, np.pi/9)
-`control_qubits` = [2, 1, 3]
-`target_qubits` = 0
+`control_indices` = [2, 1, 3]
+`target_index` = 0
 """
-UCRY_unitary_matrix_4qubits_213control = np.load(prefix + "UCRY_unitary_matrix_4qubits_213control.npy")
+UCRY_unitary_matrix_4qubits_213control = np.load(
+    prefix + "UCRY_unitary_matrix_4qubits_213control.npy"
+)
 
 """ circuit.UCRZ() tester
 
 Parameters
 ----------
 `angles` = (np.pi/2, np.pi/3, np.pi/4, np.pi/5)
-`control_qubits` = [0, 1]
-`target_qubits` = 2
+`control_indices` = [0, 1]
+`target_index` = 2
 """
-UCRZ_unitary_matrix_3qubits_01control = np.load(prefix + "UCRZ_unitary_matrix_3qubits_01control.npy")
+UCRZ_unitary_matrix_3qubits_01control = np.load(
+    prefix + "UCRZ_unitary_matrix_3qubits_01control.npy"
+)
 
 """ circuit.UCRZ() tester
 
 Parameters
 ----------
 `angles` = (np.pi/2, np.pi/3, np.pi/4, np.pi/5)
-`control_qubits` = [1, 0]
-`target_qubits` = 2
+`control_indices` = [1, 0]
+`target_index` = 2
 """
-UCRZ_unitary_matrix_3qubits_10control = np.load(prefix + "UCRZ_unitary_matrix_3qubits_10control.npy")
+UCRZ_unitary_matrix_3qubits_10control = np.load(
+    prefix + "UCRZ_unitary_matrix_3qubits_10control.npy"
+)
 
 """ circuit.UCRZ() tester
 
 Parameters
 ----------
 `angles` = (np.pi/2, np.pi/3, np.pi/4, np.pi/5, np.pi/6, np.pi/7, np.pi/8, np.pi/9)
-`control_qubits` = [0, 2, 3]
-`target_qubits` = 1
+`control_indices` = [0, 2, 3]
+`target_index` = 1
 """
-UCRZ_unitary_matrix_4qubits_023control = np.load(prefix + "UCRZ_unitary_matrix_4qubits_023control.npy")
+UCRZ_unitary_matrix_4qubits_023control = np.load(
+    prefix + "UCRZ_unitary_matrix_4qubits_023control.npy"
+)
 
 """ circuit.UCRZ() tester
 
 Parameters
 ----------
 `angles` = (np.pi/2, np.pi/3, np.pi/4, np.pi/5, np.pi/6, np.pi/7, np.pi/8, np.pi/9)
-`control_qubits` = [2, 1, 3]
-`target_qubits` = 0
-"""
-UCRZ_unitary_matrix_4qubits_213control = np.load(prefix + "UCRZ_unitary_matrix_4qubits_213control.npy")
-
-""" circuit.UC() tester
-
-Parameters
-----------
-`gates` = [Hadamard().matrix, PauliX().matrix, Hadamard().matrix, PauliX().matrix]
-`control_qubits` = [0, 1]
-`target_qubits` = 2
-`up_to_diagonal` = False
-`multiplexor_simplification` = False
-"""
-UC_unitary_matrix_no_diagonal_no_simplification_3qubits_01control_HXHX = np.load(prefix + "UC_unitary_matrix_no_diagonal_no_simplification_3qubits_01control_HXHX.npy")
-
-""" circuit.UC() tester
-
-Parameters
-----------
-`gates` = [Hadamard().matrix, PauliY().matrix, Hadamard().matrix, PauliY().matrix]
-`control_qubits` = [1, 0]
-`target_qubits` = 2
-`up_to_diagonal` = False
-`multiplexor_simplification` = False
-"""
-UC_unitary_matrix_no_diagonal_no_simplification_3qubits_10control_HYHY = np.load(prefix + "UC_unitary_matrix_no_diagonal_no_simplification_3qubits_10control_HYHY.npy")
-
-""" circuit.UC() tester
-
-Parameters
-----------
-`gates` = [RX(np.pi/2).matrix, RY(np.pi/3).matrix, RX(np.pi/4).matrix, RY(np.pi/5).matrix, RX(np.pi/6).matrix, RY(np.pi/7).matrix, RX(np.pi/8).matrix, RY(np.pi/9).matrix]
-`control_qubits` = [0, 2, 3]
-`target_qubits` = 1
-`up_to_diagonal` = False
-`multiplexor_simplification` = False
-"""
-UC_unitary_matrix_no_diagonal_no_simplification_4qubits_023control_RXRYRXRYRXRY = np.load(prefix + "UC_unitary_matrix_no_diagonal_no_simplification_4qubits_023control_RXRYRXRYRXRY.npy")
-
-""" circuit.UC() tester
-
-Parameters
-----------
-`gates` = [RX(np.pi/2).matrix, RY(np.pi/3).matrix, RX(np.pi/4).matrix, RY(np.pi/5).matrix, RX(np.pi/6).matrix, RY(np.pi/7).matrix, RX(np.pi/8).matrix, RY(np.pi/9).matrix]
-`control_qubits` = [2, 1, 3]
-`target_qubits` = 0
-`up_to_diagonal` = False
-`multiplexor_simplification` = False
-"""
-UC_unitary_matrix_no_diagonal_no_simplification_4qubits_213control_RXRYRXRYRXRY = np.load(prefix + "UC_unitary_matrix_no_diagonal_no_simplification_4qubits_213control_RXRYRXRYRXRY.npy")
-
-""" circuit.UC() tester
-
-Parameters
-----------
-`gates` = [Hadamard().matrix, PauliX().matrix, Hadamard().matrix, PauliX().matrix]
-`control_qubits` = [0, 1]
-`target_qubits` = 2
-`up_to_diagonal` = True
-`multiplexor_simplification` = False
-"""
-UC_unitary_matrix_diagonal_no_simplification_3qubits_01control_HXHX = np.load(prefix + "UC_unitary_matrix_diagonal_no_simplification_3qubits_01control_HXHX.npy")
-
-""" circuit.UC() tester
-
-Parameters
-----------
-`gates` = [Hadamard().matrix, PauliY().matrix, Hadamard().matrix, PauliY().matrix]
-`control_qubits` = [1, 0]
-`target_qubits` = 2
-`up_to_diagonal` = True
-`multiplexor_simplification` = False
-"""
-UC_unitary_matrix_diagonal_no_simplification_3qubits_10control_HYHY = np.load(prefix + "UC_unitary_matrix_diagonal_no_simplification_3qubits_10control_HYHY.npy")
-
-""" circuit.UC() tester
-
-Parameters
-----------
-`gates` = [RX(np.pi/2).matrix, RY(np.pi/3).matrix, RX(np.pi/4).matrix, RY(np.pi/5).matrix, RX(np.pi/6).matrix, RY(np.pi/7).matrix, RX(np.pi/8).matrix, RY(np.pi/9).matrix]
-`control_qubits` = [0, 2, 3]
-`target_qubits` = 1
-`up_to_diagonal` = True
-`multiplexor_simplification` = False
-"""
-UC_unitary_matrix_diagonal_no_simplification_4qubits_023control_RXRYRXRYRXRY = np.load(prefix + "UC_unitary_matrix_diagonal_no_simplification_4qubits_023control_RXRYRXRYRXRY.npy")
-
-""" circuit.UC() tester
-
-Parameters
-----------
-`gates` = [RX(np.pi/2).matrix, RY(np.pi/3).matrix, RX(np.pi/4).matrix, RY(np.pi/5).matrix, RX(np.pi/6).matrix, RY(np.pi/7).matrix, RX(np.pi/8).matrix, RY(np.pi/9).matrix]
-`control_qubits` = [2, 1, 3]
-`target_qubits` = 0
-`up_to_diagonal` = True
-`multiplexor_simplification` = False
-"""
-UC_unitary_matrix_diagonal_no_simplification_4qubits_213control_RXRYRXRYRXRY = np.load(prefix + "UC_unitary_matrix_diagonal_no_simplification_4qubits_213control_RXRYRXRYRXRY.npy")
-
-""" circuit.UC() tester
-
-Parameters
-----------
-`gates` = [Hadamard().matrix, PauliX().matrix, Hadamard().matrix, PauliX().matrix]
-`control_qubits` = [0, 1]
-`target_qubits` = 2
-`up_to_diagonal` = False
-`multiplexor_simplification` = True
-"""
-UC_unitary_matrix_no_diagonal_simplification_3qubits_01control_HXHX = np.load(prefix + "UC_unitary_matrix_no_diagonal_simplification_3qubits_01control_HXHX.npy")
-
-""" circuit.UC() tester
-
-Parameters
-----------
-`gates` = [Hadamard().matrix, PauliY().matrix, Hadamard().matrix, PauliY().matrix]
-`control_qubits` = [1, 0]
-`target_qubits` = 2
-`up_to_diagonal` = False
-`multiplexor_simplification` = True
-"""
-UC_unitary_matrix_no_diagonal_simplification_3qubits_10control_HYHY = np.load(prefix + "UC_unitary_matrix_no_diagonal_simplification_3qubits_10control_HYHY.npy")
-
-""" circuit.UC() tester
-
-Parameters
-----------
-`gates` = [RX(np.pi/2).matrix, RY(np.pi/3).matrix, RX(np.pi/4).matrix, RY(np.pi/5).matrix, RX(np.pi/6).matrix, RY(np.pi/7).matrix, RX(np.pi/8).matrix, RY(np.pi/9).matrix]
-`control_qubits` = [0, 2, 3]
-`target_qubits` = 1
-`up_to_diagonal` = False
-`multiplexor_simplification` = True
-"""
-UC_unitary_matrix_no_diagonal_simplification_4qubits_023control_RXRYRXRYRXRY = np.load(prefix + "UC_unitary_matrix_no_diagonal_simplification_4qubits_023control_RXRYRXRYRXRY.npy")
-
-""" circuit.UC() tester
-
-Parameters
-----------
-`gates` = [RX(np.pi/2).matrix, RY(np.pi/3).matrix, RX(np.pi/4).matrix, RY(np.pi/5).matrix, RX(np.pi/6).matrix, RY(np.pi/7).matrix, RX(np.pi/8).matrix, RY(np.pi/9).matrix]
-`control_qubits` = [2, 1, 3]
-`target_qubits` = 0
-`up_to_diagonal` = False
-`multiplexor_simplification` = True
-"""
-UC_unitary_matrix_no_diagonal_simplification_4qubits_213control_RXRYRXRYRXRY = np.load(prefix + "UC_unitary_matrix_no_diagonal_simplification_4qubits_213control_RXRYRXRYRXRY.npy")
-
-""" circuit.UC() tester
-
-Parameters
-----------
-`gates` = [Hadamard().matrix, PauliX().matrix, Hadamard().matrix, PauliX().matrix]
-`control_qubits` = [0, 1]
-`target_qubits` = 2
-`up_to_diagonal` = True
-`multiplexor_simplification` = True
-"""
-UC_unitary_matrix_diagonal_simplification_3qubits_01control_HXHX = np.load(prefix + "UC_unitary_matrix_diagonal_simplification_3qubits_01control_HXHX.npy")
-
-""" circuit.UC() tester
-
-Parameters
-----------
-`gates` = [Hadamard().matrix, PauliY().matrix, Hadamard().matrix, PauliY().matrix]
-`control_qubits` = [1, 0]
-`target_qubits` = 2
-`up_to_diagonal` = True
-`multiplexor_simplification` = True
-"""
-UC_unitary_matrix_diagonal_simplification_3qubits_10control_HYHY = np.load(prefix + "UC_unitary_matrix_diagonal_simplification_3qubits_10control_HYHY.npy")
-
-""" circuit.UC() tester
-
-Parameters
-----------
-`gates` = [RX(np.pi/2).matrix, RY(np.pi/3).matrix, RX(np.pi/4).matrix, RY(np.pi/5).matrix, RX(np.pi/6).matrix, RY(np.pi/7).matrix, RX(np.pi/8).matrix, RY(np.pi/9).matrix]
-`control_qubits` = [0, 2, 3]
-`target_qubits` = 1
-`up_to_diagonal` = True
-`multiplexor_simplification` = True
-"""
-UC_unitary_matrix_diagonal_simplification_4qubits_023control_RXRYRXRYRXRY = np.load(prefix + "UC_unitary_matrix_diagonal_simplification_4qubits_023control_RXRYRXRYRXRY.npy")
-
-""" circuit.UC() tester
-
-Parameters
-----------
-`gates` = [RX(np.pi/2).matrix, RY(np.pi/3).matrix, RX(np.pi/4).matrix, RY(np.pi/5).matrix, RX(np.pi/6).matrix, RY(np.pi/7).matrix, RX(np.pi/8).matrix, RY(np.pi/9).matrix]
-`control_qubits` = [2, 1, 3]
-`target_qubits` = 0
-`up_to_diagonal` = True
-`multiplexor_simplification` = True
+`control_indices` = [2, 1, 3]
+`target_index` = 0
 """
-UC_unitary_matrix_diagonal_simplification_4qubits_213control_RXRYRXRYRXRY = np.load(prefix + "UC_unitary_matrix_diagonal_simplification_4qubits_213control_RXRYRXRYRXRY.npy")
+UCRZ_unitary_matrix_4qubits_213control = np.load(
+    prefix + "UCRZ_unitary_matrix_4qubits_213control.npy"
+)
 
 # QFT testers for (5, 6, 7, 8) qubits
 # QFT(no swap, no inverse, approximation_degree = 0)
-qft_no_swap_no_inverse_approx0_5qubits = np.load(prefix + "qft_no_swap_no_inverse_approx0_5qubits.npy")
-qft_no_swap_no_inverse_approx0_6qubits = np.load(prefix + "qft_no_swap_no_inverse_approx0_6qubits.npy")
-qft_no_swap_no_inverse_approx0_7qubits = np.load(prefix + "qft_no_swap_no_inverse_approx0_7qubits.npy")
-qft_no_swap_no_inverse_approx0_8qubits = np.load(prefix + "qft_no_swap_no_inverse_approx0_8qubits.npy")
+
+qft_no_swap_no_inverse_approx0_5qubits = np.load(
+    prefix + "qft_no_swap_no_inverse_approx0_5qubits.npy"
+)
+qft_no_swap_no_inverse_approx0_6qubits = np.load(
+    prefix + "qft_no_swap_no_inverse_approx0_6qubits.npy"
+)
+qft_no_swap_no_inverse_approx0_7qubits = np.load(
+    prefix + "qft_no_swap_no_inverse_approx0_7qubits.npy"
+)
+qft_no_swap_no_inverse_approx0_8qubits = np.load(
+    prefix + "qft_no_swap_no_inverse_approx0_8qubits.npy"
+)
 
 # QFT(no swap, no inverse, approximation_degree = 1)
-qft_no_swap_no_inverse_approx1_5qubits = np.load(prefix + "qft_no_swap_no_inverse_approx1_5qubits.npy")
-qft_no_swap_no_inverse_approx1_6qubits = np.load(prefix + "qft_no_swap_no_inverse_approx1_6qubits.npy")
-qft_no_swap_no_inverse_approx1_7qubits = np.load(prefix + "qft_no_swap_no_inverse_approx1_7qubits.npy")
-qft_no_swap_no_inverse_approx1_8qubits = np.load(prefix + "qft_no_swap_no_inverse_approx1_8qubits.npy")
+
+qft_no_swap_no_inverse_approx1_5qubits = np.load(
+    prefix + "qft_no_swap_no_inverse_approx1_5qubits.npy"
+)
+qft_no_swap_no_inverse_approx1_6qubits = np.load(
+    prefix + "qft_no_swap_no_inverse_approx1_6qubits.npy"
+)
+qft_no_swap_no_inverse_approx1_7qubits = np.load(
+    prefix + "qft_no_swap_no_inverse_approx1_7qubits.npy"
+)
+qft_no_swap_no_inverse_approx1_8qubits = np.load(
+    prefix + "qft_no_swap_no_inverse_approx1_8qubits.npy"
+)
 
 # QFT(no swap, no inverse, approximation_degree = 2)
-qft_no_swap_no_inverse_approx2_5qubits = np.load(prefix + "qft_no_swap_no_inverse_approx2_5qubits.npy")
-qft_no_swap_no_inverse_approx2_6qubits = np.load(prefix + "qft_no_swap_no_inverse_approx2_6qubits.npy")
-qft_no_swap_no_inverse_approx2_7qubits = np.load(prefix + "qft_no_swap_no_inverse_approx2_7qubits.npy")
-qft_no_swap_no_inverse_approx2_8qubits = np.load(prefix + "qft_no_swap_no_inverse_approx2_8qubits.npy")
+
+qft_no_swap_no_inverse_approx2_5qubits = np.load(
+    prefix + "qft_no_swap_no_inverse_approx2_5qubits.npy"
+)
+qft_no_swap_no_inverse_approx2_6qubits = np.load(
+    prefix + "qft_no_swap_no_inverse_approx2_6qubits.npy"
+)
+qft_no_swap_no_inverse_approx2_7qubits = np.load(
+    prefix + "qft_no_swap_no_inverse_approx2_7qubits.npy"
+)
+qft_no_swap_no_inverse_approx2_8qubits = np.load(
+    prefix + "qft_no_swap_no_inverse_approx2_8qubits.npy"
+)
 
 # QFT(no swap, no inverse, approximation_degree = 3)
-qft_no_swap_no_inverse_approx3_5qubits = np.load(prefix + "qft_no_swap_no_inverse_approx3_5qubits.npy")
-qft_no_swap_no_inverse_approx3_6qubits = np.load(prefix + "qft_no_swap_no_inverse_approx3_6qubits.npy")
-qft_no_swap_no_inverse_approx3_7qubits = np.load(prefix + "qft_no_swap_no_inverse_approx3_7qubits.npy")
-qft_no_swap_no_inverse_approx3_8qubits = np.load(prefix + "qft_no_swap_no_inverse_approx3_8qubits.npy")
+
+qft_no_swap_no_inverse_approx3_5qubits = np.load(
+    prefix + "qft_no_swap_no_inverse_approx3_5qubits.npy"
+)
+qft_no_swap_no_inverse_approx3_6qubits = np.load(
+    prefix + "qft_no_swap_no_inverse_approx3_6qubits.npy"
+)
+qft_no_swap_no_inverse_approx3_7qubits = np.load(
+    prefix + "qft_no_swap_no_inverse_approx3_7qubits.npy"
+)
+qft_no_swap_no_inverse_approx3_8qubits = np.load(
+    prefix + "qft_no_swap_no_inverse_approx3_8qubits.npy"
+)
 
 # QFT(swap, no inverse, approximation_degree = 0)
-qft_swap_no_inverse_approx0_5qubits = np.load(prefix + "qft_swap_no_inverse_approx0_5qubits.npy")
-qft_swap_no_inverse_approx0_6qubits = np.load(prefix + "qft_swap_no_inverse_approx0_6qubits.npy")
-qft_swap_no_inverse_approx0_7qubits = np.load(prefix + "qft_swap_no_inverse_approx0_7qubits.npy")
-qft_swap_no_inverse_approx0_8qubits = np.load(prefix + "qft_swap_no_inverse_approx0_8qubits.npy")
+
+qft_swap_no_inverse_approx0_5qubits = np.load(
+    prefix + "qft_swap_no_inverse_approx0_5qubits.npy"
+)
+qft_swap_no_inverse_approx0_6qubits = np.load(
+    prefix + "qft_swap_no_inverse_approx0_6qubits.npy"
+)
+qft_swap_no_inverse_approx0_7qubits = np.load(
+    prefix + "qft_swap_no_inverse_approx0_7qubits.npy"
+)
+qft_swap_no_inverse_approx0_8qubits = np.load(
+    prefix + "qft_swap_no_inverse_approx0_8qubits.npy"
+)
 
 # QFT(swap, no inverse, approximation_degree = 1)
-qft_swap_no_inverse_approx1_5qubits = np.load(prefix + "qft_swap_no_inverse_approx1_5qubits.npy")
-qft_swap_no_inverse_approx1_6qubits = np.load(prefix + "qft_swap_no_inverse_approx1_6qubits.npy")
-qft_swap_no_inverse_approx1_7qubits = np.load(prefix + "qft_swap_no_inverse_approx1_7qubits.npy")
-qft_swap_no_inverse_approx1_8qubits = np.load(prefix + "qft_swap_no_inverse_approx1_8qubits.npy")
+
+qft_swap_no_inverse_approx1_5qubits = np.load(
+    prefix + "qft_swap_no_inverse_approx1_5qubits.npy"
+)
+qft_swap_no_inverse_approx1_6qubits = np.load(
+    prefix + "qft_swap_no_inverse_approx1_6qubits.npy"
+)
+qft_swap_no_inverse_approx1_7qubits = np.load(
+    prefix + "qft_swap_no_inverse_approx1_7qubits.npy"
+)
+qft_swap_no_inverse_approx1_8qubits = np.load(
+    prefix + "qft_swap_no_inverse_approx1_8qubits.npy"
+)
 
 # QFT(swap, no inverse, approximation_degree = 2)
-qft_swap_no_inverse_approx2_5qubits = np.load(prefix + "qft_swap_no_inverse_approx2_5qubits.npy")
-qft_swap_no_inverse_approx2_6qubits = np.load(prefix + "qft_swap_no_inverse_approx2_6qubits.npy")
-qft_swap_no_inverse_approx2_7qubits = np.load(prefix + "qft_swap_no_inverse_approx2_7qubits.npy")
-qft_swap_no_inverse_approx2_8qubits = np.load(prefix + "qft_swap_no_inverse_approx2_8qubits.npy")
+
+qft_swap_no_inverse_approx2_5qubits = np.load(
+    prefix + "qft_swap_no_inverse_approx2_5qubits.npy"
+)
+qft_swap_no_inverse_approx2_6qubits = np.load(
+    prefix + "qft_swap_no_inverse_approx2_6qubits.npy"
+)
+qft_swap_no_inverse_approx2_7qubits = np.load(
+    prefix + "qft_swap_no_inverse_approx2_7qubits.npy"
+)
+qft_swap_no_inverse_approx2_8qubits = np.load(
+    prefix + "qft_swap_no_inverse_approx2_8qubits.npy"
+)
 
 # QFT(swap, no inverse, approximation_degree = 3)
-qft_swap_no_inverse_approx3_5qubits = np.load(prefix + "qft_swap_no_inverse_approx3_5qubits.npy")
-qft_swap_no_inverse_approx3_6qubits = np.load(prefix + "qft_swap_no_inverse_approx3_6qubits.npy")
-qft_swap_no_inverse_approx3_7qubits = np.load(prefix + "qft_swap_no_inverse_approx3_7qubits.npy")
-qft_swap_no_inverse_approx3_8qubits = np.load(prefix + "qft_swap_no_inverse_approx3_8qubits.npy")
+
+qft_swap_no_inverse_approx3_5qubits = np.load(
+    prefix + "qft_swap_no_inverse_approx3_5qubits.npy"
+)
+qft_swap_no_inverse_approx3_6qubits = np.load(
+    prefix + "qft_swap_no_inverse_approx3_6qubits.npy"
+)
+qft_swap_no_inverse_approx3_7qubits = np.load(
+    prefix + "qft_swap_no_inverse_approx3_7qubits.npy"
+)
+qft_swap_no_inverse_approx3_8qubits = np.load(
+    prefix + "qft_swap_no_inverse_approx3_8qubits.npy"
+)
 
 # QFT(no swap, inverse, approximation_degree = 0)
-qft_no_swap_inverse_approx0_5qubits = np.load(prefix + "qft_no_swap_inverse_approx0_5qubits.npy")
-qft_no_swap_inverse_approx0_6qubits = np.load(prefix + "qft_no_swap_inverse_approx0_6qubits.npy")
-qft_no_swap_inverse_approx0_7qubits = np.load(prefix + "qft_no_swap_inverse_approx0_7qubits.npy")
-qft_no_swap_inverse_approx0_8qubits = np.load(prefix + "qft_no_swap_inverse_approx0_8qubits.npy")
+
+qft_no_swap_inverse_approx0_5qubits = np.load(
+    prefix + "qft_no_swap_inverse_approx0_5qubits.npy"
+)
+qft_no_swap_inverse_approx0_6qubits = np.load(
+    prefix + "qft_no_swap_inverse_approx0_6qubits.npy"
+)
+qft_no_swap_inverse_approx0_7qubits = np.load(
+    prefix + "qft_no_swap_inverse_approx0_7qubits.npy"
+)
+qft_no_swap_inverse_approx0_8qubits = np.load(
+    prefix + "qft_no_swap_inverse_approx0_8qubits.npy"
+)
 
 # QFT(no swap, inverse, approximation_degree = 1)
-qft_no_swap_inverse_approx1_5qubits = np.load(prefix + "qft_no_swap_inverse_approx1_5qubits.npy")
-qft_no_swap_inverse_approx1_6qubits = np.load(prefix + "qft_no_swap_inverse_approx1_6qubits.npy")
-qft_no_swap_inverse_approx1_7qubits = np.load(prefix + "qft_no_swap_inverse_approx1_7qubits.npy")
-qft_no_swap_inverse_approx1_8qubits = np.load(prefix + "qft_no_swap_inverse_approx1_8qubits.npy")
+
+qft_no_swap_inverse_approx1_5qubits = np.load(
+    prefix + "qft_no_swap_inverse_approx1_5qubits.npy"
+)
+qft_no_swap_inverse_approx1_6qubits = np.load(
+    prefix + "qft_no_swap_inverse_approx1_6qubits.npy"
+)
+qft_no_swap_inverse_approx1_7qubits = np.load(
+    prefix + "qft_no_swap_inverse_approx1_7qubits.npy"
+)
+qft_no_swap_inverse_approx1_8qubits = np.load(
+    prefix + "qft_no_swap_inverse_approx1_8qubits.npy"
+)
 
 # QFT(no swap, inverse, approximation_degree = 2)
-qft_no_swap_inverse_approx2_5qubits = np.load(prefix + "qft_no_swap_inverse_approx2_5qubits.npy")
-qft_no_swap_inverse_approx2_6qubits = np.load(prefix + "qft_no_swap_inverse_approx2_6qubits.npy")
-qft_no_swap_inverse_approx2_7qubits = np.load(prefix + "qft_no_swap_inverse_approx2_7qubits.npy")
-qft_no_swap_inverse_approx2_8qubits = np.load(prefix + "qft_no_swap_inverse_approx2_8qubits.npy")
+
+qft_no_swap_inverse_approx2_5qubits = np.load(
+    prefix + "qft_no_swap_inverse_approx2_5qubits.npy"
+)
+qft_no_swap_inverse_approx2_6qubits = np.load(
+    prefix + "qft_no_swap_inverse_approx2_6qubits.npy"
+)
+qft_no_swap_inverse_approx2_7qubits = np.load(
+    prefix + "qft_no_swap_inverse_approx2_7qubits.npy"
+)
+qft_no_swap_inverse_approx2_8qubits = np.load(
+    prefix + "qft_no_swap_inverse_approx2_8qubits.npy"
+)
 
 # QFT(no swap, inverse, approximation_degree = 3)
-qft_no_swap_inverse_approx3_5qubits = np.load(prefix + "qft_no_swap_inverse_approx3_5qubits.npy")
-qft_no_swap_inverse_approx3_6qubits = np.load(prefix + "qft_no_swap_inverse_approx3_6qubits.npy")
-qft_no_swap_inverse_approx3_7qubits = np.load(prefix + "qft_no_swap_inverse_approx3_7qubits.npy")
-qft_no_swap_inverse_approx3_8qubits = np.load(prefix + "qft_no_swap_inverse_approx3_8qubits.npy")
+
+qft_no_swap_inverse_approx3_5qubits = np.load(
+    prefix + "qft_no_swap_inverse_approx3_5qubits.npy"
+)
+qft_no_swap_inverse_approx3_6qubits = np.load(
+    prefix + "qft_no_swap_inverse_approx3_6qubits.npy"
+)
+qft_no_swap_inverse_approx3_7qubits = np.load(
+    prefix + "qft_no_swap_inverse_approx3_7qubits.npy"
+)
+qft_no_swap_inverse_approx3_8qubits = np.load(
+    prefix + "qft_no_swap_inverse_approx3_8qubits.npy"
+)
 
 # QFT(swap, inverse, approximation_degree = 0)
-qft_swap_inverse_approx0_5qubits = np.load(prefix + "qft_swap_inverse_approx0_5qubits.npy")
-qft_swap_inverse_approx0_6qubits = np.load(prefix + "qft_swap_inverse_approx0_6qubits.npy")
-qft_swap_inverse_approx0_7qubits = np.load(prefix + "qft_swap_inverse_approx0_7qubits.npy")
-qft_swap_inverse_approx0_8qubits = np.load(prefix + "qft_swap_inverse_approx0_8qubits.npy")
+
+qft_swap_inverse_approx0_5qubits = np.load(
+    prefix + "qft_swap_inverse_approx0_5qubits.npy"
+)
+qft_swap_inverse_approx0_6qubits = np.load(
+    prefix + "qft_swap_inverse_approx0_6qubits.npy"
+)
+qft_swap_inverse_approx0_7qubits = np.load(
+    prefix + "qft_swap_inverse_approx0_7qubits.npy"
+)
+qft_swap_inverse_approx0_8qubits = np.load(
+    prefix + "qft_swap_inverse_approx0_8qubits.npy"
+)
 
 # QFT(swap, inverse, approximation_degree = 1)
-qft_swap_inverse_approx1_5qubits = np.load(prefix + "qft_swap_inverse_approx1_5qubits.npy")
-qft_swap_inverse_approx1_6qubits = np.load(prefix + "qft_swap_inverse_approx1_6qubits.npy")
-qft_swap_inverse_approx1_7qubits = np.load(prefix + "qft_swap_inverse_approx1_7qubits.npy")
-qft_swap_inverse_approx1_8qubits = np.load(prefix + "qft_swap_inverse_approx1_8qubits.npy")
+
+qft_swap_inverse_approx1_5qubits = np.load(
+    prefix + "qft_swap_inverse_approx1_5qubits.npy"
+)
+qft_swap_inverse_approx1_6qubits = np.load(
+    prefix + "qft_swap_inverse_approx1_6qubits.npy"
+)
+qft_swap_inverse_approx1_7qubits = np.load(
+    prefix + "qft_swap_inverse_approx1_7qubits.npy"
+)
+qft_swap_inverse_approx1_8qubits = np.load(
+    prefix + "qft_swap_inverse_approx1_8qubits.npy"
+)
 
 # QFT(swap, inverse, approximation_degree = 2)
-qft_swap_inverse_approx2_5qubits = np.load(prefix + "qft_swap_inverse_approx2_5qubits.npy")
-qft_swap_inverse_approx2_6qubits = np.load(prefix + "qft_swap_inverse_approx2_6qubits.npy")
-qft_swap_inverse_approx2_7qubits = np.load(prefix + "qft_swap_inverse_approx2_7qubits.npy")
-qft_swap_inverse_approx2_8qubits = np.load(prefix + "qft_swap_inverse_approx2_8qubits.npy")
+
+qft_swap_inverse_approx2_5qubits = np.load(
+    prefix + "qft_swap_inverse_approx2_5qubits.npy"
+)
+qft_swap_inverse_approx2_6qubits = np.load(
+    prefix + "qft_swap_inverse_approx2_6qubits.npy"
+)
+qft_swap_inverse_approx2_7qubits = np.load(
+    prefix + "qft_swap_inverse_approx2_7qubits.npy"
+)
+qft_swap_inverse_approx2_8qubits = np.load(
+    prefix + "qft_swap_inverse_approx2_8qubits.npy"
+)
 
 # QFT(swap, inverse, approximation_degree = 3)
-qft_swap_inverse_approx3_5qubits = np.load(prefix + "qft_swap_inverse_approx3_5qubits.npy")
-qft_swap_inverse_approx3_6qubits = np.load(prefix + "qft_swap_inverse_approx3_6qubits.npy")
-qft_swap_inverse_approx3_7qubits = np.load(prefix + "qft_swap_inverse_approx3_7qubits.npy")
-qft_swap_inverse_approx3_8qubits = np.load(prefix + "qft_swap_inverse_approx3_8qubits.npy")
\ No newline at end of file
+
+qft_swap_inverse_approx3_5qubits = np.load(
+    prefix + "qft_swap_inverse_approx3_5qubits.npy"
+)
+qft_swap_inverse_approx3_6qubits = np.load(
+    prefix + "qft_swap_inverse_approx3_6qubits.npy"
+)
+qft_swap_inverse_approx3_7qubits = np.load(
+    prefix + "qft_swap_inverse_approx3_7qubits.npy"
+)
+qft_swap_inverse_approx3_8qubits = np.load(
+    prefix + "qft_swap_inverse_approx3_8qubits.npy"
+)
\ No newline at end of file
diff --git a/tests/circuit/test_circuit_base.py b/tests/circuit/test_circuit_base.py
index d91c73a..298b2ba 100644
--- a/tests/circuit/test_circuit_base.py
+++ b/tests/circuit/test_circuit_base.py
@@ -1094,6 +1094,75 @@ def test_remove_measurement(
         # ensure they are equivalent
         assert circuit == no_measurement_circuit
 
+    @pytest.mark.parametrize("circuit_framework", CIRCUIT_FRAMEWORKS)
+    def test_mul(
+            self,
+            circuit_framework: type[Circuit]
+        ) -> None:
+        """ Test the repeat of circuits via `__mul__` operator.
+
+        Parameters
+        ----------
+        `circuit_framework`: type[quick.circuit.Circuit]
+            The circuit framework to test.
+        """
+        # Define the `quick.circuit.Circuit` instance
+        circuit = circuit_framework(2)
+
+        # Apply a series of gates
+        circuit.H(0)
+        circuit.CX(0, 1)
+
+        new_circuit = circuit * 3
+        new_circuit_reverse = 3 * circuit
+
+        # Define the equivalent `quick.circuit.Circuit` instance, and
+        # ensure they are equivalent
+        checker_circuit = circuit_framework(2)
+        checker_circuit.H(0)
+        checker_circuit.CX(0, 1)
+        checker_circuit.H(0)
+        checker_circuit.CX(0, 1)
+        checker_circuit.H(0)
+        checker_circuit.CX(0, 1)
+
+        assert checker_circuit == new_circuit
+        assert checker_circuit == new_circuit_reverse
+
+    @pytest.mark.parametrize("circuit_framework", CIRCUIT_FRAMEWORKS)
+    def test_matmul(
+            self,
+            circuit_framework: type[Circuit]
+        ) -> None:
+        """ Test the tensor product of circuits via `__matmul__` operator.
+
+        Parameters
+        ----------
+        `circuit_framework`: type[quick.circuit.Circuit]
+            The circuit framework to test.
+        """
+        # Define the `quick.circuit.Circuit` instance
+        circuit_1 = circuit_framework(3)
+        circuit_2 = circuit_framework(2)
+
+        # Apply a series of gates
+        circuit_1.H(0)
+        circuit_1.CX(0, 2)
+        circuit_2.Z(0)
+        circuit_2.CY(1, 0)
+
+        new_circuit = circuit_1 @ circuit_2
+
+        # Define the equivalent `quick.circuit.Circuit` instance, and
+        # ensure they are equivalent
+        checker_circuit = circuit_framework(5)
+        checker_circuit.H(0)
+        checker_circuit.CX(0, 2)
+        checker_circuit.Z(3)
+        checker_circuit.CY(4, 3)
+
+        assert checker_circuit == new_circuit
+
     @pytest.mark.parametrize("circuit_framework", CIRCUIT_FRAMEWORKS)
     def test_getitem(
             self,
diff --git a/tests/circuit/test_uniformly_controlled_gates.py b/tests/circuit/test_uniformly_controlled_gates.py
index 1ab7f08..867225e 100644
--- a/tests/circuit/test_uniformly_controlled_gates.py
+++ b/tests/circuit/test_uniformly_controlled_gates.py
@@ -20,7 +20,7 @@
 from numpy.testing import assert_almost_equal
 from numpy.typing import NDArray
 import pytest
-from typing import Type
+from scipy.linalg import block_diag
 
 from quick.circuit import Circuit
 from quick.circuit.gate_matrix import PauliX, PauliY, Hadamard, RX, RY
@@ -39,22 +39,6 @@
     UCRZ_unitary_matrix_3qubits_10control,
     UCRZ_unitary_matrix_4qubits_023control,
     UCRZ_unitary_matrix_4qubits_213control,
-    UC_unitary_matrix_no_diagonal_no_simplification_3qubits_01control_HXHX,
-    UC_unitary_matrix_no_diagonal_no_simplification_3qubits_10control_HYHY,
-    UC_unitary_matrix_no_diagonal_no_simplification_4qubits_023control_RXRYRXRYRXRY,
-    UC_unitary_matrix_no_diagonal_no_simplification_4qubits_213control_RXRYRXRYRXRY,
-    UC_unitary_matrix_diagonal_no_simplification_3qubits_01control_HXHX,
-    UC_unitary_matrix_diagonal_no_simplification_3qubits_10control_HYHY,
-    UC_unitary_matrix_diagonal_no_simplification_4qubits_023control_RXRYRXRYRXRY,
-    UC_unitary_matrix_diagonal_no_simplification_4qubits_213control_RXRYRXRYRXRY,
-    UC_unitary_matrix_no_diagonal_simplification_3qubits_01control_HXHX,
-    UC_unitary_matrix_no_diagonal_simplification_3qubits_10control_HYHY,
-    UC_unitary_matrix_no_diagonal_simplification_4qubits_023control_RXRYRXRYRXRY,
-    UC_unitary_matrix_no_diagonal_simplification_4qubits_213control_RXRYRXRYRXRY,
-    UC_unitary_matrix_diagonal_simplification_3qubits_01control_HXHX,
-    UC_unitary_matrix_diagonal_simplification_3qubits_10control_HYHY,
-    UC_unitary_matrix_diagonal_simplification_4qubits_023control_RXRYRXRYRXRY,
-    UC_unitary_matrix_diagonal_simplification_4qubits_213control_RXRYRXRYRXRY
 )
 
 
@@ -284,59 +268,68 @@ def test_Diagonal(
         assert_almost_equal(circuit.get_unitary(), np.diag(diagonal).astype(complex), decimal=8)
 
     @pytest.mark.parametrize("circuit_framework", CIRCUIT_FRAMEWORKS)
-    @pytest.mark.parametrize("single_qubit_gates, control_indices, target_index, expected", [
+    @pytest.mark.parametrize("up_to_diagonal", [True, False])
+    @pytest.mark.parametrize("multiplexor_simplification", [True, False])
+    @pytest.mark.parametrize("single_qubit_gates", [
         [
-            [Hadamard().matrix, PauliX().matrix, Hadamard().matrix, PauliX().matrix],
-            [0, 1],
-            2,
-            UC_unitary_matrix_no_diagonal_no_simplification_3qubits_01control_HXHX
+            Hadamard().matrix,
+            PauliX().matrix,
+            Hadamard().matrix,
+            PauliX().matrix
         ],
         [
-            [Hadamard().matrix, PauliY().matrix, Hadamard().matrix, PauliY().matrix],
-            [1, 0],
-            2,
-            UC_unitary_matrix_no_diagonal_no_simplification_3qubits_10control_HYHY
+            RX(np.pi/2).matrix,
+            RY(np.pi/3).matrix,
+            RX(np.pi/4).matrix,
+            RY(np.pi/5).matrix,
+            RX(np.pi/6).matrix,
+            RY(np.pi/7).matrix,
+            RX(np.pi/8).matrix,
+            RY(np.pi/9).matrix
         ],
         [
-            [
-                RX(np.pi/2).matrix,
-                RY(np.pi/3).matrix,
-                RX(np.pi/4).matrix,
-                RY(np.pi/5).matrix,
-                RX(np.pi/6).matrix,
-                RY(np.pi/7).matrix,
-                RX(np.pi/8).matrix,
-                RY(np.pi/9).matrix
-            ],
-            [0, 2, 3],
-            1,
-            UC_unitary_matrix_no_diagonal_no_simplification_4qubits_023control_RXRYRXRYRXRY
+            RY(np.pi).matrix,
+            RX(np.pi/2).matrix,
+            RY(np.pi/3).matrix,
+            RX(np.pi/4).matrix,
+            RY(np.pi/5).matrix,
+            RX(np.pi/6).matrix,
+            RY(np.pi/7).matrix,
+            RX(np.pi/8).matrix,
+            RY(np.pi/9).matrix,
+            RX(np.pi/10).matrix,
+            RY(np.pi/11).matrix,
+            RX(np.pi/12).matrix,
+            RY(np.pi/13).matrix,
+            RX(np.pi/14).matrix,
+            RY(np.pi/15).matrix,
+            RX(np.pi/16).matrix,
+            RY(np.pi/17).matrix,
+            RX(np.pi/18).matrix,
+            RY(np.pi/19).matrix,
+            RX(np.pi/20).matrix,
+            RY(np.pi/21).matrix,
+            RX(np.pi/22).matrix,
+            RY(np.pi/23).matrix,
+            RX(np.pi/24).matrix,
+            RY(np.pi/25).matrix,
+            RX(np.pi/26).matrix,
+            RY(np.pi/27).matrix,
+            RX(np.pi/28).matrix,
+            RY(np.pi/29).matrix,
+            RX(np.pi/30).matrix,
+            RY(np.pi/31).matrix,
+            RX(np.pi/32).matrix
         ],
-        [
-            [
-                RX(np.pi/2).matrix,
-                RY(np.pi/3).matrix,
-                RX(np.pi/4).matrix,
-                RY(np.pi/5).matrix,
-                RX(np.pi/6).matrix,
-                RY(np.pi/7).matrix,
-                RX(np.pi/8).matrix,
-                RY(np.pi/9).matrix
-            ],
-            [2, 1, 3],
-            0,
-            UC_unitary_matrix_no_diagonal_no_simplification_4qubits_213control_RXRYRXRYRXRY
-        ]
     ])
-    def test_Multiplexor_no_diagonal_no_simplification(
+    def test_Multiplexor(
             self,
             circuit_framework: type[Circuit],
             single_qubit_gates: list[NDArray[np.complex128]],
-            control_indices: list[int],
-            target_index: int,
-            expected: NDArray[np.complex128]
+            up_to_diagonal: bool,
+            multiplexor_simplification: bool
         ) -> None:
-        """ Test the `Multiplexor` gate without diagonal and without simplification.
+        """ Test the `Multiplexor` gate.
 
         Parameters
         ----------
@@ -344,276 +337,59 @@ def test_Multiplexor_no_diagonal_no_simplification(
             The quantum circuit framework.
         `single_qubit_gates` : list[NDArray[np.complex128]]
             The single-qubit gates.
-        `control_indices` : list[int]
-            The control qubits.
-        `target_index` : int
-            The target qubit.
-        `expected` : NDArray[np.complex128]
-            The expected unitary matrix.
+        `up_to_diagonal` : bool, optional, default=False
+            Determines if the gate is implemented up to a diagonal
+            or if it is decomposed completely.
+        `multiplexor_simplification` : bool, optional, default=True
+            Determines if the multiplexor is simplified.
         """
-        # Define the quantum circuit
-        circuit = circuit_framework(len(control_indices) + 1)
-
-        # Apply the Multiplexor gate
-        circuit.Multiplexor(
-            single_qubit_gates,
-            control_indices,
-            target_index,
-            up_to_diagonal=False,
-            multiplexor_simplification=False
+        from quick.circuit.circuit_utils import (
+            extract_single_qubits_and_diagonal,
+            simplify
         )
 
-        # Ensure the unitary matrix is correct
-        assert_almost_equal(circuit.get_unitary(), expected, 8)
-
-    @pytest.mark.parametrize("circuit_framework", CIRCUIT_FRAMEWORKS)
-    @pytest.mark.parametrize("single_qubit_gates, control_indices, target_index, expected", [
-        [
-            [Hadamard().matrix, PauliX().matrix, Hadamard().matrix, PauliX().matrix],
-            [0, 1],
-            2,
-            UC_unitary_matrix_diagonal_no_simplification_3qubits_01control_HXHX
-        ],
-        [
-            [Hadamard().matrix, PauliY().matrix, Hadamard().matrix, PauliY().matrix],
-            [1, 0],
-            2,
-            UC_unitary_matrix_diagonal_no_simplification_3qubits_10control_HYHY
-        ],
-        [
-            [
-                RX(np.pi/2).matrix,
-                RY(np.pi/3).matrix,
-                RX(np.pi/4).matrix,
-                RY(np.pi/5).matrix,
-                RX(np.pi/6).matrix,
-                RY(np.pi/7).matrix,
-                RX(np.pi/8).matrix,
-                RY(np.pi/9).matrix
-            ],
-            [0, 2, 3],
-            1,
-            UC_unitary_matrix_diagonal_no_simplification_4qubits_023control_RXRYRXRYRXRY
-        ],
-        [
-            [
-                RX(np.pi/2).matrix,
-                RY(np.pi/3).matrix,
-                RX(np.pi/4).matrix,
-                RY(np.pi/5).matrix,
-                RX(np.pi/6).matrix,
-                RY(np.pi/7).matrix,
-                RX(np.pi/8).matrix,
-                RY(np.pi/9).matrix
-            ],
-            [2, 1, 3],
-            0,
-            UC_unitary_matrix_diagonal_no_simplification_4qubits_213control_RXRYRXRYRXRY
-        ]
-    ])
-    def test_Multiplexor_diagonal_no_simplification(
-            self,
-            circuit_framework: type[Circuit],
-            single_qubit_gates: list[NDArray[np.complex128]],
-            control_indices: list[int],
-            target_index: int,
-            expected: NDArray[np.complex128]
-        ) -> None:
-        """ Test the `Multiplexor` gate with diagonal and without simplification.
-
-        Parameters
-        ----------
-        `circuit_framework` : type[quick.circuit.Circuit]
-            The quantum circuit framework.
-        `single_qubit_gates` : list[NDArray[np.complex128]]
-            The single-qubit gates.
-        `control_indices` : list[int]
-            The control qubits.
-        `target_index` : int
-            The target qubit.
-        `expected` : NDArray[np.complex128]
-            The expected unitary matrix.
-        """
-        # Define the quantum circuit
-        circuit = circuit_framework(len(control_indices) + 1)
-
-        # Apply the Multiplexor gate
-        circuit.Multiplexor(
-            single_qubit_gates,
-            control_indices,
-            target_index,
-            up_to_diagonal=True,
-            multiplexor_simplification=False
+        num_controls = int(
+            np.log2(
+                len(single_qubit_gates)
+            )
         )
 
-        # Ensure the unitary matrix is correct
-        assert_almost_equal(circuit.get_unitary(), expected, 8)
-
-    @pytest.mark.parametrize("circuit_framework", CIRCUIT_FRAMEWORKS)
-    @pytest.mark.parametrize("single_qubit_gates, control_indices, target_index, expected", [
-        [
-            [Hadamard().matrix, PauliX().matrix, Hadamard().matrix, PauliX().matrix],
-            [0, 1],
-            2,
-            UC_unitary_matrix_no_diagonal_simplification_3qubits_01control_HXHX
-        ],
-        [
-            [Hadamard().matrix, PauliY().matrix, Hadamard().matrix, PauliY().matrix],
-            [1, 0],
-            2,
-            UC_unitary_matrix_no_diagonal_simplification_3qubits_10control_HYHY
-        ],
-        [
-            [
-                RX(np.pi/2).matrix,
-                RY(np.pi/3).matrix,
-                RX(np.pi/4).matrix,
-                RY(np.pi/5).matrix,
-                RX(np.pi/6).matrix,
-                RY(np.pi/7).matrix,
-                RX(np.pi/8).matrix,
-                RY(np.pi/9).matrix
-            ],
-            [0, 2, 3],
-            1,
-            UC_unitary_matrix_no_diagonal_simplification_4qubits_023control_RXRYRXRYRXRY
-        ],
-        [
-            [
-                RX(np.pi/2).matrix,
-                RY(np.pi/3).matrix,
-                RX(np.pi/4).matrix,
-                RY(np.pi/5).matrix,
-                RX(np.pi/6).matrix,
-                RY(np.pi/7).matrix,
-                RX(np.pi/8).matrix,
-                RY(np.pi/9).matrix
-            ],
-            [2, 1, 3],
-            0,
-            UC_unitary_matrix_no_diagonal_simplification_4qubits_213control_RXRYRXRYRXRY
-        ]
-    ])
-    def test_Multiplexor_no_diagonal_simplification(
-            self,
-            circuit_framework: type[Circuit],
-            single_qubit_gates: list[NDArray[np.complex128]],
-            control_indices: list[int],
-            target_index: int,
-            expected: NDArray[np.complex128]
-        ) -> None:
-        """ Test the `Multiplexor` gate without diagonal and with simplification.
+        qubits = list(range(num_controls + 1))
+        target_index = qubits[0]
+        control_indices = qubits[1:]
 
-        Parameters
-        ----------
-        `circuit_framework` : type[quick.circuit.Circuit]
-            The quantum circuit framework.
-        `single_qubit_gates` : list[NDArray[np.complex128]]
-            The single-qubit gates.
-        `control_indices` : list[int]
-            The control qubits.
-        `target_index` : int
-            The target qubit.
-        `expected` : NDArray[np.complex128]
-            The expected unitary matrix.
-        """
         # Define the quantum circuit
-        circuit = circuit_framework(len(control_indices) + 1)
+        circuit = circuit_framework(num_controls + 1)
+        expected = block_diag(*single_qubit_gates)
 
         # Apply the Multiplexor gate
         circuit.Multiplexor(
             single_qubit_gates,
             control_indices,
             target_index,
-            up_to_diagonal=False,
-            multiplexor_simplification=True
+            up_to_diagonal=up_to_diagonal,
+            multiplexor_simplification=multiplexor_simplification
         )
 
-        # Ensure the unitary matrix is correct
-        assert_almost_equal(circuit.get_unitary(), expected, 8)
+        unitary = circuit.get_unitary()
 
-    @pytest.mark.parametrize("circuit_framework", CIRCUIT_FRAMEWORKS)
-    @pytest.mark.parametrize("single_qubit_gates, control_indices, target_index, expected", [
-        [
-            [Hadamard().matrix, PauliX().matrix, Hadamard().matrix, PauliX().matrix],
-            [0, 1],
-            2,
-            UC_unitary_matrix_diagonal_simplification_3qubits_01control_HXHX
-        ],
-        [
-            [Hadamard().matrix, PauliY().matrix, Hadamard().matrix, PauliY().matrix],
-            [1, 0],
-            2,
-            UC_unitary_matrix_diagonal_simplification_3qubits_10control_HYHY
-        ],
-        [
-            [
-                RX(np.pi/2).matrix,
-                RY(np.pi/3).matrix,
-                RX(np.pi/4).matrix,
-                RY(np.pi/5).matrix,
-                RX(np.pi/6).matrix,
-                RY(np.pi/7).matrix,
-                RX(np.pi/8).matrix,
-                RY(np.pi/9).matrix
-            ],
-            [0, 2, 3],
-            1,
-            UC_unitary_matrix_diagonal_simplification_4qubits_023control_RXRYRXRYRXRY
-        ],
-        [
-            [
-                RX(np.pi/2).matrix,
-                RY(np.pi/3).matrix,
-                RX(np.pi/4).matrix,
-                RY(np.pi/5).matrix,
-                RX(np.pi/6).matrix,
-                RY(np.pi/7).matrix,
-                RX(np.pi/8).matrix,
-                RY(np.pi/9).matrix
-            ],
-            [2, 1, 3],
-            0,
-            UC_unitary_matrix_diagonal_simplification_4qubits_213control_RXRYRXRYRXRY
-        ]
-    ])
-    def test_Multiplexor_diagonal_simplification(
-            self,
-            circuit_framework: type[Circuit],
-            single_qubit_gates: list[NDArray[np.complex128]],
-            control_indices: list[int],
-            target_index: int,
-            expected: NDArray[np.complex128]
-        ) -> None:
-        """ Test the `Multiplexor` gate with diagonal and simplification.
+        if multiplexor_simplification:
+            new_controls, single_qubit_gates = simplify(single_qubit_gates, num_controls)
+            control_indices = [qubits[len(qubits) - i] for i in new_controls]
+            control_indices.reverse()
 
-        Parameters
-        ----------
-        `circuit_framework` : type[quick.circuit.Circuit]
-            The quantum circuit framework.
-        `single_qubit_gates` : list[NDArray[np.complex128]]
-            The single-qubit gates.
-        `control_indices` : list[int]
-            The control qubits.
-        `target_index` : int
-            The target qubit.
-        `expected` : NDArray[np.complex128]
-            The expected unitary matrix.
-        """
-        # Define the quantum circuit
-        circuit = circuit_framework(len(control_indices) + 1)
+        if up_to_diagonal:
+            _, diagonal = extract_single_qubits_and_diagonal(
+                single_qubit_gates, len(control_indices) + 1
+            )
+            diagonal_circuit = circuit_framework(circuit.num_qubits)
+            diagonal_circuit.Diagonal(diagonal, [target_index] + control_indices)
+            diagonal_unitary = diagonal_circuit.get_unitary()
 
-        # Apply the Multiplexor gate
-        circuit.Multiplexor(
-            single_qubit_gates,
-            control_indices,
-            target_index,
-            up_to_diagonal=True,
-            multiplexor_simplification=True
-        )
+            unitary = np.dot(diagonal_unitary, unitary)
 
         # Ensure the unitary matrix is correct
-        assert_almost_equal(circuit.get_unitary(), expected, 8)
+        assert_almost_equal(unitary, expected, 8)
 
     @pytest.mark.parametrize("circuit_framework", CIRCUIT_FRAMEWORKS)
     def test_PauliMultiplexor_invalid_num_angles(
diff --git a/tests/metrics/area_law_state.npy b/tests/metrics/area_law_state.npy
new file mode 100644
index 0000000..c227d45
Binary files /dev/null and b/tests/metrics/area_law_state.npy differ
diff --git a/tests/metrics/test_metrics.py b/tests/metrics/test_metrics.py
index 3487d8d..79eee22 100644
--- a/tests/metrics/test_metrics.py
+++ b/tests/metrics/test_metrics.py
@@ -27,6 +27,7 @@
     calculate_entanglement_range,
     calculate_shannon_entropy,
     calculate_entanglement_entropy,
+    calculate_entanglement_entropy_slope,
     calculate_hilbert_schmidt_test
 )
 
@@ -49,6 +50,15 @@ def test_calculate_entanglement_range(self) -> None:
         entanglements = calculate_entanglement_range(qc.get_statevector())
         assert entanglements == [(0, 1), (2, 2), (3, 5)]
 
+    def test_calculate_entanglement_range_single_qubit(self) -> None:
+        """ Test the `calculate_entanglement_range` method with a single qubit.
+        """
+        qc = QiskitCircuit(1)
+        qc.H(0)
+
+        entanglements = calculate_entanglement_range(qc.get_statevector())
+        assert entanglements == [(0, 0)]
+
     def test_calculate_shannon_entropy(self) -> None:
         """ Test the `calculate_shannon_entropy` method.
         """
@@ -56,26 +66,102 @@ def test_calculate_shannon_entropy(self) -> None:
 
         assert_almost_equal(1.7736043871504037, calculate_shannon_entropy(data))
 
-    @pytest.mark.parametrize("data", [
-        np.array([1, 0]),
-        np.array([0, 1, 0, 0]),
-        np.array([0.5, 0.5, 0.5, 0.5]),
-        np.array([0.5, 0.5j, -0.5j, 0.5]),
-        np.array([1/np.sqrt(2), 0, 0, -1/np.sqrt(2)* 1j]),
-        np.array([1/np.sqrt(2)] + (14 * [0]) + [1/np.sqrt(2) * 1j]),
+    @pytest.mark.parametrize("data, expected", [
+        (np.array([1, 0]), 0.0),
+        (np.array([0, 1, 0, 0]), 0.0),
+        (np.array([0.5, 0.5, 0.5, 0.5]), 0.0),
+        (np.array([0.5, 0.5j, -0.5j, 0.5]), 0.0),
+        (np.array([1/np.sqrt(2), 0, 0, -1/np.sqrt(2)* 1j]), 0.0),
+        (np.array([1/np.sqrt(2)] + (14 * [0]) + [1/np.sqrt(2) * 1j]), 0.0),
+        (
+            np.array([
+                [0.5],
+                [0.5],
+                [0.5],
+                [0.5]
+            ]),
+            0.0
+        ),
+        (
+            np.array([
+                [0.84048555+0.j, 0.0510054-0.02325157j],
+                [0.0510054+0.02325157j, 0.15951445+0.j]
+            ], dtype=np.complex128),
+            0.6220438669480641
+        ),
+        (
+            np.array([
+                [0.16521093+0.j, -0.08915021+0.07244625j, -0.14670846-0.10748953j, -0.03544851+0.106916j],
+                [-0.08915021-0.07244625j, 0.28432666+0.j, -0.01778044+0.15666538j, -0.03049137-0.01306784j],
+                [-0.14670846+0.10748953j, -0.01778044-0.15666538j, 0.2941435 +0.j, -0.06158772-0.08660825j],
+                [-0.03544851-0.106916j, -0.03049137+0.01306784j, -0.06158772+0.08660825j, 0.2563189+0.j]
+            ], dtype=np.complex128),
+            1.3705180586061732
+        )
     ])
     def test_calculate_entanglement_entropy(
             self,
-            data: NDArray[np.complex128]
+            data: NDArray[np.complex128],
+            expected: float
         ) -> None:
         """ Test the `calculate_entanglement_entropy` method.
 
         Parameters
         ----------
-        data : NDArray[np.complex128]
+        `data` : NDArray[np.complex128]
             The statevector of the circuit.
+        `expected` : float
+            The expected value.
+        """
+        assert_almost_equal(expected, calculate_entanglement_entropy(data))
+
+    @pytest.mark.parametrize("data", [
+        np.array([1, 2, 3], dtype=np.complex128),
+        np.array([1, 2, 3, 4], dtype=np.complex128),
+        np.array([
+            [1, 2],
+            [3, 4]
+        ], dtype=np.complex128),
+        np.array([
+            [1, 2, 3],
+            [4, 5, 6]
+        ], dtype=np.complex128),
+        np.array([
+            [1],
+            [2],
+            [3]
+        ], dtype=np.complex128)
+    ])
+    def test_calculate_entanglement_entropy_invalid_data(
+            self,
+            data: NDArray[np.complex128]
+        ) -> None:
+        """ Test failure of `calculate_entanglement_entropy` with invalid
+        data values, which are neither density matrix nor statevector.
+
+        Parameters
+        ----------
+        `data` : NDArray[np.complex128]
+            The data to be tested.
+        """
+        with pytest.raises(ValueError):
+            calculate_entanglement_entropy(data)
+
+    def test_calculate_entanglement_entropy_slope_area_law_case(self) -> None:
+        """ Test the `calculate_entanglement_entropy_slope` method with an area-law
+        entangled state.
+        """
+        area_law_state = np.load("tests/metrics/area_law_state.npy")
+        slope = calculate_entanglement_entropy_slope(area_law_state)
+        assert_almost_equal(0.20183287022097673, slope)
+
+    def test_calculate_entanglement_entropy_slope_volume_law_case(self) -> None:
+        """ Test the `calculate_entanglement_entropy_slope` method with a volume-law
+        entangled state.
         """
-        assert_almost_equal(0.0, calculate_entanglement_entropy(data))
+        volume_law_state = np.load("tests/metrics/volume_law_state.npy")
+        slope = calculate_entanglement_entropy_slope(volume_law_state)
+        assert_almost_equal(1.0, slope)
 
     def test_calculate_hilbert_schmidt_test(self) -> None:
         """ Test the `calculate_hilbert_schmidt_test` method.
diff --git a/tests/metrics/volume_law_state.npy b/tests/metrics/volume_law_state.npy
new file mode 100644
index 0000000..28fe0fe
Binary files /dev/null and b/tests/metrics/volume_law_state.npy differ
diff --git a/tests/predicates/test_predicates.py b/tests/predicates/test_predicates.py
index ae6d72a..ddd19b5 100644
--- a/tests/predicates/test_predicates.py
+++ b/tests/predicates/test_predicates.py
@@ -14,18 +14,6 @@
 
 from __future__ import annotations
 
-__all__ = [
-    "test_is_statevector",
-    "test_is_square_matrix",
-    "test_is_diagonal_matrix",
-    "test_is_symmetric_matrix",
-    "test_is_identity_matrix",
-    "test_is_unitary_matrix",
-    "test_is_hermitian_matrix",
-    "test_is_positive_semidefinite_matrix",
-    "test_is_isometry"
-]
-
 import numpy as np
 from numpy.typing import NDArray
 import pytest
@@ -40,7 +28,8 @@
     is_unitary_matrix,
     is_hermitian_matrix,
     is_positive_semidefinite_matrix,
-    is_isometry
+    is_isometry,
+    is_density_matrix
 )
 
 
@@ -50,7 +39,8 @@
     (np.array([1, 0, 0]), 3, True),
     (np.array([1, 2]), 2, False),
     (np.array([1, 2, 3]), 3, False),
-    (np.array([1, 0, 0, 0]), 2, True)
+    (np.array([1, 0, 0, 0]), 2, True),
+    (np.array([[0.5], [0.5], [0.5], [0.5]]), 2, True)
 ])
 def test_is_statevector(
         array: NDArray[np.complex128],
@@ -68,7 +58,7 @@ def test_is_statevector(
     `expected` : bool
         The expected output of the function.
     """
-    assert is_statevector(array, system_size) == expected
+    assert is_statevector(array, system_size) is expected
 
 def test_is_statevector_invalid_system_size() -> None:
     """ Test the `.is_statevector()` method with invalid system size.
@@ -104,7 +94,7 @@ def test_is_square_matrix(
     `expected` : bool
         The expected output of the function.
     """
-    assert is_square_matrix(array) == expected
+    assert is_square_matrix(array) is expected
 
 @pytest.mark.parametrize("array, expected", [
     (np.diag([1, 2, 3]), True),
@@ -139,7 +129,7 @@ def test_is_diagonal_matrix(
     `expected` : bool
         The expected output of the function.
     """
-    assert is_diagonal_matrix(array) == expected
+    assert is_diagonal_matrix(array) is expected
 
 @pytest.mark.parametrize("array, expected", [
     (np.array([
@@ -187,7 +177,7 @@ def test_is_symmetric_matrix(
     `expected` : bool
         The expected output of the function.
     """
-    assert is_symmetric_matrix(array) == expected
+    assert is_symmetric_matrix(array) is expected
 
 @pytest.mark.parametrize("array, expected", [
     (np.eye(2), True),
@@ -213,7 +203,7 @@ def test_is_identity_matrix(
     `expected` : bool
         The expected output of the function.
     """
-    assert is_identity_matrix(array) == expected
+    assert is_identity_matrix(array) is expected
 
 @pytest.mark.parametrize("array, expected", [
     (unitary_group.rvs(2), True),
@@ -239,7 +229,7 @@ def test_is_unitary_matrix(
     `expected` : bool
         The expected output of the function.
     """
-    assert is_unitary_matrix(array) == expected
+    assert is_unitary_matrix(array) is expected
 
 @pytest.mark.parametrize("array, expected", [
     (np.array([
@@ -283,7 +273,7 @@ def test_is_hermitian_matrix(
     `expected` : bool
         The expected output of the function.
     """
-    assert is_hermitian_matrix(array) == expected
+    assert is_hermitian_matrix(array) is expected
 
 @pytest.mark.parametrize("array, expected", [
     (np.array([
@@ -325,7 +315,7 @@ def test_is_positive_semidefinite_matrix(
     `expected` : bool
         The expected output of the function.
     """
-    assert is_positive_semidefinite_matrix(array) == expected
+    assert is_positive_semidefinite_matrix(array) is expected
 
 @pytest.mark.parametrize("array, expected", [
     (np.array([
@@ -362,4 +352,39 @@ def test_is_isometry(
     `expected` : bool
         The expected output of the function.
     """
-    assert is_isometry(array) == expected
\ No newline at end of file
+    assert is_isometry(array) is expected
+
+@pytest.mark.parametrize("array, expected", [
+    (np.array([
+        [0.55282636+0.j, 0.19339888+0.1369917j],
+        [0.19339888-0.1369917j, 0.44717364+0.j]
+    ], dtype=np.complex128), True),
+    (np.array([
+        [0.19834677+0.j, 0.21077084+0.08851485j, 0.07369894-0.03780167j],
+        [0.21077084-0.08851485j, 0.5556912 +0.j, 0.09721694-0.13294078j],
+        [0.07369894+0.03780167j, 0.09721694+0.13294078j, 0.24596203+0.j]
+    ], dtype=np.complex128), True),
+    (np.array([
+        [1, 2 + 1j],
+        [2 + 1j, 3]
+    ]), False),
+    (np.array([
+        [1, 2],
+        [3, 4]
+    ]), False),
+    (np.random.rand(2, 3, 3), False)
+])
+def test_is_density_matrix(
+        array: NDArray[np.complex128],
+        expected: bool
+    ) -> None:
+    """ Test the `is_density_matrix` function with various matrices.
+
+    Parameters
+    ----------
+    `array` : NDArray[np.complex128]
+        The input array to check if it is an isometry.
+    `expected` : bool
+        The expected out of the function.
+    """
+    assert is_density_matrix(array) is expected
\ No newline at end of file
diff --git a/tests/random/test_random.py b/tests/random/test_random.py
index 1b8bc2b..765cdca 100644
--- a/tests/random/test_random.py
+++ b/tests/random/test_random.py
@@ -18,8 +18,12 @@
 
 import pytest
 
-from quick.predicates import is_unitary_matrix
-from quick.random import generate_random_state, generate_random_unitary
+from quick.predicates import is_unitary_matrix, is_statevector, is_density_matrix
+from quick.random import (
+    generate_random_state,
+    generate_random_unitary,
+    generate_random_density_matrix
+)
 
 
 class TestRandom:
@@ -40,8 +44,7 @@ def test_generate_random_state(
         """
         state = generate_random_state(num_qubits)
 
-        assert state.shape == (2 ** num_qubits,)
-        assert pytest.approx(1.0) == abs(state @ state.conj())
+        assert is_statevector(state)
 
     @pytest.mark.parametrize("num_qubits", [1, 2, 3, 4, 5])
     def test_generate_random_unitary(
@@ -58,4 +61,45 @@ def test_generate_random_unitary(
         unitary = generate_random_unitary(num_qubits)
 
         assert unitary.shape == (2 ** num_qubits, 2 ** num_qubits)
-        assert is_unitary_matrix(unitary)
\ No newline at end of file
+        assert is_unitary_matrix(unitary)
+
+    @pytest.mark.parametrize("num_qubits", [1, 2, 3, 4, 5])
+    @pytest.mark.parametrize("generator", ["hilbert-schmidt", "bures"])
+    @pytest.mark.parametrize("rank", [1, 2, 3, None])
+    def test_generate_random_density_matrix(
+            self,
+            num_qubits: int,
+            generator: str,
+            rank: int
+        ) -> None:
+        """ Test the `generate_random_density_matrix` function.
+
+        Parameters
+        ----------
+        `num_qubits` : int
+            The number of qubits in the density matrix.
+        `generator` : str
+            The method to use for generating the density matrix.
+        `rank` : int
+            The rank of the density matrix.
+        """
+        density_matrix = generate_random_density_matrix(
+            num_qubits=num_qubits,
+            rank=rank,
+            generator=generator # type: ignore
+        )
+
+        assert is_density_matrix(density_matrix)
+
+    def test_generate_random_density_matrix_invalid_generator(
+            self
+        ) -> None:
+        """ Test the `generate_random_density_matrix` function with an
+        invalid generator.
+        """
+        with pytest.raises(ValueError):
+            generate_random_density_matrix(
+                num_qubits=2,
+                rank=1,
+                generator="invalid-generator" # type: ignore
+            )
\ No newline at end of file
diff --git a/tests/synthesis/gate_decompositions/two_qubit_decomposition/test_two_qubit_decomposition.py b/tests/synthesis/gate_decompositions/two_qubit_decomposition/test_two_qubit_decomposition.py
index 409b2e3..cfccf39 100644
--- a/tests/synthesis/gate_decompositions/two_qubit_decomposition/test_two_qubit_decomposition.py
+++ b/tests/synthesis/gate_decompositions/two_qubit_decomposition/test_two_qubit_decomposition.py
@@ -17,6 +17,7 @@
 __all__ = ["TestTwoQubitDecomposition"]
 
 import numpy as np
+from numpy.typing import NDArray
 from numpy.testing import assert_almost_equal
 import pytest
 from scipy.stats import unitary_group
@@ -252,6 +253,81 @@ def test_decomp3_supercontrolled(self) -> None:
         # Check that the number of CX gates is 3 or less
         assert num_cx_gates <= 3
 
+    @pytest.mark.parametrize("unitary", [
+        np.array([
+            [2./3, 1./3 + 1.j/3, 7 * np.sqrt(17)/51, (-1 - 1.j) * np.sqrt(17)/51],
+            [1./3 - 1.j/3, -1./3, (-1 + 1.j) * np.sqrt(17)/51, 10 * np.sqrt(17)/51],
+            [7*np.sqrt(17)/51, (-1 - 1.j) * np.sqrt(17)/51, -2./3, -1./3 - 1.j/3],
+            [(-1 + 1.j) * np.sqrt(17)/51, 10 * np.sqrt(17)/51, -1./3 + 1.j/3, 1./3]
+        ]),
+        np.array([
+            [
+                0.043602684126304955 + -0.4986216208233326j, -0.22461079447224863 + -0.09679517443671315j,
+                0.15592626697527698 + 0.13943283228059802j, -0.803224008021238 + 0.027067469117215155j
+            ],
+            [
+                -0.09679517443669944 + 0.22461079447226426j, 0.4986216208232763 + 0.043602684126298856j,
+                0.02706746911718458 + 0.8032240080213412j, -0.13943283228056091 + 0.15592626697531453j
+            ],
+            [
+                0.13943283228059844 + -0.15592626697527806j, 0.027067469117214762 + 0.8032240080212403j,
+                0.49862162082333095 + 0.0436026841263046j, 0.09679517443671384 + -0.22461079447224833j
+            ],
+            [
+                0.8032240080213434 + -0.027067469117184207j, 0.1559262669753156 + 0.13943283228056125j,
+                -0.2246107944722639 + -0.09679517443670013j, -0.043602684126298495 + 0.4986216208232746j
+            ]
+        ]),
+        np.array([
+            [-0.62695238, -0.1993407 , -0.63291226, -0.40818632],
+            [-0.62695237, -0.42741604,  0.61214869,  0.2225314 ],
+            [-0.32700263,  0.43412304, -0.31468734,  0.77818914],
+            [ 0.32700264, -0.76753892, -0.35449671,  0.42223851]
+        ]),
+        np.array([
+            [
+                -0.3812064266367201 + 0.38120642663672005j, -0.08953682318096808 + 0.08953682318096806j,
+                -0.5214184531408846 + 0.5214184531408846j, -0.27347323579354943 + 0.2734732357935494j,
+            ],
+            [
+                0.11105398348218393 - 0.11105398348218391j, 0.145430219977459 - 0.14543021997745897j,
+                0.23096365206101888 - 0.23096365206101882j, -0.6427852354467597 + 0.6427852354467596j,
+            ],
+            [
+                -0.544932087007239 + 0.5449320870072389j, -0.16786656959437854 + 0.16786656959437854j,
+                0.41778724529336947 - 0.4177872452933694j, 0.01799033088883041 - 0.017990330888830407j,
+            ],
+            [
+                -0.213067345160641 + 0.21306734516064096j, 0.6653224962721628 - 0.6653224962721627j,
+                -0.0152448403255109 + 0.015244840325510897j, 0.10823991063233353 - 0.10823991063233351j,
+            ],
+        ])
+    ])
+    def test_m2_correctness(
+            self,
+            unitary: NDArray[np.complex128]
+        ) -> None:
+        """ Test the correctness of the M2 decomposition. This tests
+        many recorded cases of failure of two qubit decomposition on
+        non-Ubuntu OS.
+
+        Parameters
+        ----------
+        `unitary` : NDArray[np.complex128]
+            The two qubit unitary to encode.
+        """
+        # Create a two qubit decomposition object
+        two_qubit_decomposition = TwoQubitDecomposition(output_framework=QiskitCircuit)
+
+        # Initialize a circuit
+        circuit = QiskitCircuit(2)
+
+        # Apply the decomposition
+        two_qubit_decomposition.apply_unitary(circuit, unitary, [0, 1])
+
+        # Check that the circuit is equivalent to the original unitary matrix
+        assert_almost_equal(circuit.get_unitary(), unitary, decimal=8)
+
     def test_invalid_indices_fail(self) -> None:
         """ Test that invalid indices fail.
         """