qiskit 1.3.0b1__cp39-abi3-macosx_10_9_x86_64.whl

qiskit/synthesis/unitary/aqc/cnot_structures.py

@@ -0,0 +1,300 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+These are the CNOT structure methods: anything that you need for creating CNOT structures.
+"""
+import logging
+import math
+
+import numpy as np
+
+_NETWORK_LAYOUTS = ["sequ", "spin", "cart", "cyclic_spin", "cyclic_line"]
+_CONNECTIVITY_TYPES = ["full", "line", "star"]
+
+
+logger = logging.getLogger(__name__)
+
+
+def _lower_limit(num_qubits: int) -> int:
+    """
+    Returns lower limit on the number of CNOT units that guarantees exact representation of
+    a unitary operator by quantum gates.
+
+    Args:
+        num_qubits: number of qubits.
+
+    Returns:
+        lower limit on the number of CNOT units.
+    """
+    num_cnots = math.ceil((4**num_qubits - 3 * num_qubits - 1) / 4.0)
+    return num_cnots
+
+
+def make_cnot_network(
+    num_qubits: int,
+    network_layout: str = "spin",
+    connectivity_type: str = "full",
+    depth: int = 0,
+) -> np.ndarray:
+    """
+    Generates a network consisting of building blocks each containing a CNOT gate and possibly some
+    single-qubit ones. This network models a quantum operator in question. Note, each building
+    block has 2 input and outputs corresponding to a pair of qubits. What we actually return here
+    is a chain of indices of qubit pairs shared by every building block in a row.
+
+    Args:
+        num_qubits: number of qubits.
+        network_layout: type of network geometry, ``{"sequ", "spin", "cart", "cyclic_spin",
+            "cyclic_line"}``.
+        connectivity_type: type of inter-qubit connectivity, ``{"full", "line", "star"}``.
+        depth: depth of the CNOT-network, i.e. the number of layers, where each layer consists of
+            a single CNOT-block; default value will be selected, if ``L <= 0``.
+
+    Returns:
+        A matrix of size ``(2, N)`` matrix that defines layers in cnot-network, where ``N``
+            is either equal ``L``, or defined by a concrete type of the network.
+
+    Raises:
+         ValueError: if unsupported type of CNOT-network layout or number of qubits or combination
+            of parameters are passed.
+    """
+    if num_qubits < 2:
+        raise ValueError("Number of qubits must be greater or equal to 2")
+
+    if depth <= 0:
+        new_depth = _lower_limit(num_qubits)
+        logger.debug(
+            "Number of CNOT units chosen as the lower limit: %d, got a non-positive value: %d",
+            new_depth,
+            depth,
+        )
+        depth = new_depth
+
+    if network_layout == "sequ":
+        links = _get_connectivity(num_qubits=num_qubits, connectivity=connectivity_type)
+        return _sequential_network(num_qubits=num_qubits, links=links, depth=depth)
+
+    elif network_layout == "spin":
+        return _spin_network(num_qubits=num_qubits, depth=depth)
+
+    elif network_layout == "cart":
+        cnots = _cartan_network(num_qubits=num_qubits)
+        logger.debug(
+            "Optimal lower bound: %d; Cartan CNOTs: %d", _lower_limit(num_qubits), cnots.shape[1]
+        )
+        return cnots
+
+    elif network_layout == "cyclic_spin":
+        if connectivity_type != "full":
+            raise ValueError(f"'{network_layout}' layout expects 'full' connectivity")
+
+        return _cyclic_spin_network(num_qubits, depth)
+
+    elif network_layout == "cyclic_line":
+        if connectivity_type != "line":
+            raise ValueError(f"'{network_layout}' layout expects 'line' connectivity")
+
+        return _cyclic_line_network(num_qubits, depth)
+    else:
+        raise ValueError(
+            f"Unknown type of CNOT-network layout, expects one of {_NETWORK_LAYOUTS}, "
+            f"got {network_layout}"
+        )
+
+
+def _get_connectivity(num_qubits: int, connectivity: str) -> dict:
+    """
+    Generates connectivity structure between qubits.
+
+    Args:
+        num_qubits: number of qubits.
+        connectivity: type of connectivity structure, ``{"full", "line", "star"}``.
+
+    Returns:
+        dictionary of allowed links between qubits.
+
+    Raises:
+         ValueError: if unsupported type of CNOT-network layout is passed.
+    """
+    if num_qubits == 1:
+        links = {0: [0]}
+
+    elif connectivity == "full":
+        # Full connectivity between qubits.
+        links = {i: list(range(num_qubits)) for i in range(num_qubits)}
+
+    elif connectivity == "line":
+        # Every qubit is connected to its immediate neighbors only.
+        links = {i: [i - 1, i, i + 1] for i in range(1, num_qubits - 1)}
+
+        # first qubit
+        links[0] = [0, 1]
+
+        # last qubit
+        links[num_qubits - 1] = [num_qubits - 2, num_qubits - 1]
+
+    elif connectivity == "star":
+        # Every qubit is connected to the first one only.
+        links = {i: [0, i] for i in range(1, num_qubits)}
+
+        # first qubit
+        links[0] = list(range(num_qubits))
+
+    else:
+        raise ValueError(
+            f"Unknown connectivity type, expects one of {_CONNECTIVITY_TYPES}, got {connectivity}"
+        )
+    return links
+
+
+def _sequential_network(num_qubits: int, links: dict, depth: int) -> np.ndarray:
+    """
+    Generates a sequential network.
+
+    Args:
+        num_qubits: number of qubits.
+        links: dictionary of connectivity links.
+        depth: depth of the network (number of layers of building blocks).
+
+    Returns:
+        A matrix of ``(2, N)`` that defines layers in qubit network.
+    """
+    layer = 0
+    cnots = np.zeros((2, depth), dtype=int)
+    while True:
+        for i in range(0, num_qubits - 1):
+            for j in range(i + 1, num_qubits):
+                if j in links[i]:
+                    cnots[0, layer] = i
+                    cnots[1, layer] = j
+                    layer += 1
+                    if layer >= depth:
+                        return cnots
+
+
+def _spin_network(num_qubits: int, depth: int) -> np.ndarray:
+    """
+    Generates a spin-like network.
+
+    Args:
+        num_qubits: number of qubits.
+        depth: depth of the network (number of layers of building blocks).
+
+    Returns:
+        A matrix of size ``2 x L`` that defines layers in qubit network.
+    """
+    layer = 0
+    cnots = np.zeros((2, depth), dtype=int)
+    while True:
+        for i in range(0, num_qubits - 1, 2):
+            cnots[0, layer] = i
+            cnots[1, layer] = i + 1
+            layer += 1
+            if layer >= depth:
+                return cnots
+
+        for i in range(1, num_qubits - 1, 2):
+            cnots[0, layer] = i
+            cnots[1, layer] = i + 1
+            layer += 1
+            if layer >= depth:
+                return cnots
+
+
+def _cartan_network(num_qubits: int) -> np.ndarray:
+    """
+    Cartan decomposition in a recursive way, starting from n = 3.
+
+    Args:
+        num_qubits: number of qubits.
+
+    Returns:
+        2xN matrix that defines layers in qubit network, where N is the
+             depth of Cartan decomposition.
+
+    Raises:
+        ValueError: if number of qubits is less than 3.
+    """
+    n = num_qubits
+    if n > 3:
+        cnots = np.asarray([[0, 0, 0], [1, 1, 1]])
+        mult = np.asarray([[n - 2, n - 3, n - 2, n - 3], [n - 1, n - 1, n - 1, n - 1]])
+        for _ in range(n - 2):
+            cnots = np.hstack((np.tile(np.hstack((cnots, mult)), 3), cnots))
+            mult[0, -1] -= 1
+            mult = np.tile(mult, 2)
+    elif n == 3:
+        cnots = np.asarray(
+            [
+                [0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0],
+                [1, 1, 1, 2, 2, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 1, 1, 1],
+            ]
+        )
+    else:
+        raise ValueError(f"The number of qubits must be >= 3, got {n}.")
+
+    return cnots
+
+
+def _cyclic_spin_network(num_qubits: int, depth: int) -> np.ndarray:
+    """
+    Same as in the spin-like network, but the first and the last qubits are also connected.
+
+    Args:
+        num_qubits: number of qubits.
+        depth: depth of the network (number of layers of building blocks).
+
+    Returns:
+        A matrix of size ``2 x L`` that defines layers in qubit network.
+    """
+
+    cnots = np.zeros((2, depth), dtype=int)
+    z = 0
+    while True:
+        for i in range(0, num_qubits, 2):
+            if i + 1 <= num_qubits - 1:
+                cnots[0, z] = i
+                cnots[1, z] = i + 1
+                z += 1
+            if z >= depth:
+                return cnots
+
+        for i in range(1, num_qubits, 2):
+            if i + 1 <= num_qubits - 1:
+                cnots[0, z] = i
+                cnots[1, z] = i + 1
+                z += 1
+            elif i == num_qubits - 1:
+                cnots[0, z] = i
+                cnots[1, z] = 0
+                z += 1
+            if z >= depth:
+                return cnots
+
+
+def _cyclic_line_network(num_qubits: int, depth: int) -> np.ndarray:
+    """
+    Generates a line based CNOT structure.
+
+    Args:
+        num_qubits: number of qubits.
+        depth: depth of the network (number of layers of building blocks).
+
+    Returns:
+        A matrix of size ``2 x L`` that defines layers in qubit network.
+    """
+
+    cnots = np.zeros((2, depth), dtype=int)
+    for i in range(depth):
+        cnots[0, i] = (i + 0) % num_qubits
+        cnots[1, i] = (i + 1) % num_qubits
+    return cnots

qiskit/synthesis/unitary/aqc/cnot_unit_circuit.py

@@ -0,0 +1,103 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+This is the Parametric Circuit class: anything that you need for a circuit
+to be parametrized and used for approximate compiling optimization.
+"""
+from __future__ import annotations
+from typing import Optional
+
+import numpy as np
+
+from .approximate import ApproximateCircuit
+
+
+class CNOTUnitCircuit(ApproximateCircuit):
+    """A class that represents an approximate circuit based on CNOT unit blocks."""
+
+    def __init__(
+        self,
+        num_qubits: int,
+        cnots: np.ndarray,
+        tol: Optional[float] = 0.0,
+        name: Optional[str] = None,
+    ) -> None:
+        """
+        Args:
+            num_qubits: the number of qubits in this circuit.
+            cnots: an array of dimensions ``(2, L)`` indicating where the CNOT units will be placed.
+            tol: angle parameter less or equal this (small) value is considered equal zero and
+                corresponding gate is not inserted into the output circuit (because it becomes
+                identity one in this case).
+            name: name of this circuit
+
+        Raises:
+            ValueError: if an unsupported parameter is passed.
+        """
+        super().__init__(num_qubits=num_qubits, name=name)
+
+        if cnots.ndim != 2 or cnots.shape[0] != 2:
+            raise ValueError("CNOT structure must be defined as an array of the size (2, N)")
+
+        self._cnots = cnots
+        self._num_cnots = cnots.shape[1]
+        self._tol = tol
+
+        # Thetas to be optimized by the AQC algorithm
+        self._thetas: np.ndarray | None = None
+
+    @property
+    def thetas(self) -> np.ndarray:
+        """
+        Returns a vector of rotation angles used by CNOT units in this circuit.
+
+        Returns:
+            Parameters of the rotation gates in this circuit.
+        """
+        return self._thetas
+
+    def build(self, thetas: np.ndarray) -> None:
+        """
+        Constructs a Qiskit quantum circuit out of the parameters (angles) of this circuit. If a
+            parameter value is less in absolute value than the specified tolerance then the
+            corresponding rotation gate will be skipped in the circuit.
+        """
+        n = self.num_qubits
+        self._thetas = thetas
+        cnots = self._cnots
+
+        for k in range(n):
+            # add initial three rotation gates for each qubit
+            p = 4 * self._num_cnots + 3 * k
+            k = n - k - 1
+            if np.abs(thetas[2 + p]) > self._tol:
+                self.rz(thetas[2 + p], k)
+            if np.abs(thetas[1 + p]) > self._tol:
+                self.ry(thetas[1 + p], k)
+            if np.abs(thetas[0 + p]) > self._tol:
+                self.rz(thetas[0 + p], k)
+
+        for c in range(self._num_cnots):
+            p = 4 * c
+            # Extract where the CNOT goes
+            q1 = n - 1 - int(cnots[0, c])
+            q2 = n - 1 - int(cnots[1, c])
+            # Construct a CNOT unit
+            self.cx(q1, q2)
+            if np.abs(thetas[0 + p]) > self._tol:
+                self.ry(thetas[0 + p], q1)
+            if np.abs(thetas[1 + p]) > self._tol:
+                self.rz(thetas[1 + p], q1)
+            if np.abs(thetas[2 + p]) > self._tol:
+                self.ry(thetas[2 + p], q2)
+            if np.abs(thetas[3 + p]) > self._tol:
+                self.rx(thetas[3 + p], q2)

qiskit/synthesis/unitary/aqc/cnot_unit_objective.py

@@ -0,0 +1,299 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+A definition of the approximate circuit compilation optimization problem based on CNOT unit
+definition.
+"""
+from __future__ import annotations
+import typing
+from abc import ABC
+
+import numpy as np
+from numpy import linalg as la
+
+from .approximate import ApproximatingObjective
+from .elementary_operations import ry_matrix, rz_matrix, place_unitary, place_cnot, rx_matrix
+
+
+class CNOTUnitObjective(ApproximatingObjective, ABC):
+    """
+    A base class for a problem definition based on CNOT unit. This class may have different
+    subclasses for objective and gradient computations.
+    """
+
+    def __init__(self, num_qubits: int, cnots: np.ndarray) -> None:
+        """
+        Args:
+            num_qubits: number of qubits.
+            cnots: a CNOT structure to be used in the optimization procedure.
+        """
+        super().__init__()
+        self._num_qubits = num_qubits
+        self._cnots = cnots
+        self._num_cnots = cnots.shape[1]
+
+    @property
+    def num_cnots(self):
+        """
+        Returns:
+            A number of CNOT units to be used by the approximate circuit.
+        """
+        return self._num_cnots
+
+    @property
+    def num_thetas(self):
+        """
+        Returns:
+            Number of parameters (angles) of rotation gates in this circuit.
+        """
+        return 3 * self._num_qubits + 4 * self._num_cnots
+
+
+class DefaultCNOTUnitObjective(CNOTUnitObjective):
+    """A naive implementation of the objective function based on CNOT units."""
+
+    def __init__(self, num_qubits: int, cnots: np.ndarray) -> None:
+        """
+        Args:
+            num_qubits: number of qubits.
+            cnots: a CNOT structure to be used in the optimization procedure.
+        """
+        super().__init__(num_qubits, cnots)
+
+        # last objective computations to be re-used by gradient
+        self._last_thetas: np.ndarray | None = None
+        self._cnot_right_collection: np.ndarray | None = None
+        self._cnot_left_collection: np.ndarray | None = None
+        self._rotation_matrix: int | np.ndarray | None = None
+        self._cnot_matrix: np.ndarray | None = None
+
+    def objective(self, param_values: np.ndarray) -> typing.SupportsFloat:
+        # rename parameters just to make shorter and make use of our dictionary
+        thetas = param_values
+        n = self._num_qubits
+        d = int(2**n)
+        cnots = self._cnots
+        num_cnots = self.num_cnots
+
+        # to save intermediate computations we define the following matrices
+        # this is the collection of cnot unit matrices ordered from left to
+        # right as in the circuit, not matrix product
+        cnot_unit_collection = np.zeros((d, d * num_cnots), dtype=complex)
+        # this is the collection of matrix products of the cnot units up
+        # to the given position from the right of the circuit
+        cnot_right_collection = np.zeros((d, d * num_cnots), dtype=complex)
+        # this is the collection of matrix products of the cnot units up
+        # to the given position from the left of the circuit
+        cnot_left_collection = np.zeros((d, d * num_cnots), dtype=complex)
+        # first, we construct each cnot unit matrix
+        for cnot_index in range(num_cnots):
+            theta_index = 4 * cnot_index
+
+            # cnot qubit indices for the cnot unit identified by cnot_index
+            q1 = int(cnots[0, cnot_index])
+            q2 = int(cnots[1, cnot_index])
+
+            # rotations that are applied on the q1 qubit
+            ry1 = ry_matrix(thetas[0 + theta_index])
+            rz1 = rz_matrix(thetas[1 + theta_index])
+
+            # rotations that are applied on the q2 qubit
+            ry2 = ry_matrix(thetas[2 + theta_index])
+            rx2 = rx_matrix(thetas[3 + theta_index])
+
+            # combine the rotations on qubits q1 and q2
+            single_q1 = np.dot(rz1, ry1)
+            single_q2 = np.dot(rx2, ry2)
+
+            # we place single qubit matrices at the corresponding locations in the (2^n, 2^n) matrix
+            full_q1 = place_unitary(single_q1, n, q1)
+            full_q2 = place_unitary(single_q2, n, q2)
+
+            # we place a cnot matrix at the qubits q1 and q2 in the full matrix
+            cnot_q1q2 = place_cnot(n, q1, q2)
+
+            # compute the cnot unit matrix and store in cnot_unit_collection
+            cnot_unit_collection[:, d * cnot_index : d * (cnot_index + 1)] = la.multi_dot(
+                [full_q2, full_q1, cnot_q1q2]
+            )
+
+        # this is the matrix corresponding to the intermediate matrix products
+        # it will end up being the matrix product of all the cnot unit matrices
+        # first we multiply from the right-hand side of the circuit
+        cnot_matrix = np.eye(d)
+        for cnot_index in range(num_cnots - 1, -1, -1):
+            cnot_matrix = np.dot(
+                cnot_matrix, cnot_unit_collection[:, d * cnot_index : d * (cnot_index + 1)]
+            )
+            cnot_right_collection[:, d * cnot_index : d * (cnot_index + 1)] = cnot_matrix
+        # now we multiply from the left-hand side of the circuit
+        cnot_matrix = np.eye(d)
+        for cnot_index in range(num_cnots):
+            cnot_matrix = np.dot(
+                cnot_unit_collection[:, d * cnot_index : d * (cnot_index + 1)], cnot_matrix
+            )
+            cnot_left_collection[:, d * cnot_index : d * (cnot_index + 1)] = cnot_matrix
+
+        # this is the matrix corresponding to the initial rotations
+        # we start with 1 and kronecker product each qubit's rotations
+        rotation_matrix: int | np.ndarray = 1
+        for q in range(n):
+            theta_index = 4 * num_cnots + 3 * q
+            rz0 = rz_matrix(thetas[0 + theta_index])
+            ry1 = ry_matrix(thetas[1 + theta_index])
+            rz2 = rz_matrix(thetas[2 + theta_index])
+            rotation_matrix = np.kron(rotation_matrix, la.multi_dot([rz0, ry1, rz2]))
+
+        # the matrix corresponding to the full circuit is the cnot part and
+        # rotation part multiplied together
+        circuit_matrix = np.dot(cnot_matrix, rotation_matrix)
+
+        # compute error
+        error = 0.5 * (la.norm(circuit_matrix - self._target_matrix, "fro") ** 2)
+
+        # cache computations for gradient
+        self._last_thetas = thetas
+        self._cnot_left_collection = cnot_left_collection
+        self._cnot_right_collection = cnot_right_collection
+        self._rotation_matrix = rotation_matrix
+        self._cnot_matrix = cnot_matrix
+
+        return error
+
+    def gradient(self, param_values: np.ndarray) -> np.ndarray:
+        # just to make shorter
+        thetas = param_values
+        # if given thetas are the same as used at the previous objective computations, then
+        # we re-use computations, otherwise we have to re-compute objective
+        if not np.all(np.isclose(thetas, self._last_thetas)):
+            self.objective(thetas)
+
+        # the partial derivative of the circuit with respect to an angle
+        # is the same circuit with the corresponding pauli gate, multiplied
+        # by a global phase of -1j / 2, next to the rotation gate (it commutes)
+        pauli_x = np.multiply(-1j / 2, np.asarray([[0, 1], [1, 0]]))
+        pauli_y = np.multiply(-1j / 2, np.asarray([[0, -1j], [1j, 0]]))
+        pauli_z = np.multiply(-1j / 2, np.asarray([[1, 0], [0, -1]]))
+
+        n = self._num_qubits
+        d = int(2**n)
+        cnots = self._cnots
+        num_cnots = self.num_cnots
+
+        # the partial derivative of the cost function is -Re<V',U>
+        # where V' is the partial derivative of the circuit
+        # first we compute the partial derivatives in the cnot part
+        der = np.zeros(4 * num_cnots + 3 * n)
+        for cnot_index in range(num_cnots):
+            theta_index = 4 * cnot_index
+
+            # cnot qubit indices for the cnot unit identified by cnot_index
+            q1 = int(cnots[0, cnot_index])
+            q2 = int(cnots[1, cnot_index])
+
+            # rotations that are applied on the q1 qubit
+            ry1 = ry_matrix(thetas[0 + theta_index])
+            rz1 = rz_matrix(thetas[1 + theta_index])
+
+            # rotations that are applied on the q2 qubit
+            ry2 = ry_matrix(thetas[2 + theta_index])
+            rx2 = rx_matrix(thetas[3 + theta_index])
+
+            # combine the rotations on qubits q1 and q2
+            # note we have to insert an extra pauli gate to take the derivative
+            # of the appropriate rotation gate
+            for i in range(4):
+                if i == 0:
+                    single_q1 = la.multi_dot([rz1, pauli_y, ry1])
+                    single_q2 = np.dot(rx2, ry2)
+                elif i == 1:
+                    single_q1 = la.multi_dot([pauli_z, rz1, ry1])
+                    single_q2 = np.dot(rx2, ry2)
+                elif i == 2:
+                    single_q1 = np.dot(rz1, ry1)
+                    single_q2 = la.multi_dot([rx2, pauli_y, ry2])
+                else:
+                    single_q1 = np.dot(rz1, ry1)
+                    single_q2 = la.multi_dot([pauli_x, rx2, ry2])
+
+                # we place single qubit matrices at the corresponding locations in
+                # the (2^n, 2^n) matrix
+                full_q1 = place_unitary(single_q1, n, q1)
+                full_q2 = place_unitary(single_q2, n, q2)
+
+                # we place a cnot matrix at the qubits q1 and q2 in the full matrix
+                cnot_q1q2 = place_cnot(n, q1, q2)
+
+                # partial derivative of that particular cnot unit, size of (2^n, 2^n)
+                der_cnot_unit = la.multi_dot([full_q2, full_q1, cnot_q1q2])
+                # der_cnot_unit is multiplied by the matrix product of cnot units to the left
+                # of it (if there are any) and to the right of it (if there are any)
+                if cnot_index == 0:
+                    der_cnot_matrix = np.dot(
+                        self._cnot_right_collection[:, d : 2 * d],
+                        der_cnot_unit,
+                    )
+                elif num_cnots - 1 == cnot_index:
+                    der_cnot_matrix = np.dot(
+                        der_cnot_unit,
+                        self._cnot_left_collection[:, d * (num_cnots - 2) : d * (num_cnots - 1)],
+                    )
+                else:
+                    der_cnot_matrix = la.multi_dot(
+                        [
+                            self._cnot_right_collection[
+                                :, d * (cnot_index + 1) : d * (cnot_index + 2)
+                            ],
+                            der_cnot_unit,
+                            self._cnot_left_collection[:, d * (cnot_index - 1) : d * cnot_index],
+                        ]
+                    )
+
+                # the matrix corresponding to the full circuit partial derivative
+                # is the partial derivative of the cnot part multiplied by the usual
+                # rotation part
+                der_circuit_matrix = np.dot(der_cnot_matrix, self._rotation_matrix)
+                # we compute the partial derivative of the cost function
+                der[i + theta_index] = -np.real(
+                    np.trace(np.dot(der_circuit_matrix.conj().T, self._target_matrix))
+                )
+
+        # now we compute the partial derivatives in the rotation part
+        # we start with 1 and kronecker product each qubit's rotations
+        for i in range(3 * n):
+            der_rotation_matrix: int | np.ndarray = 1
+            for q in range(n):
+                theta_index = 4 * num_cnots + 3 * q
+                rz0 = rz_matrix(thetas[0 + theta_index])
+                ry1 = ry_matrix(thetas[1 + theta_index])
+                rz2 = rz_matrix(thetas[2 + theta_index])
+                # for the appropriate rotation gate that we are taking
+                # the partial derivative of, we have to insert the
+                # corresponding pauli matrix
+                if i - 3 * q == 0:
+                    rz0 = np.dot(pauli_z, rz0)
+                elif i - 3 * q == 1:
+                    ry1 = np.dot(pauli_y, ry1)
+                elif i - 3 * q == 2:
+                    rz2 = np.dot(pauli_z, rz2)
+                der_rotation_matrix = np.kron(der_rotation_matrix, la.multi_dot([rz0, ry1, rz2]))
+
+            # the matrix corresponding to the full circuit partial derivative
+            # is the usual cnot part multiplied by the partial derivative of
+            # the rotation part
+            der_circuit_matrix = np.dot(self._cnot_matrix, der_rotation_matrix)
+            # we compute the partial derivative of the cost function
+            der[4 * num_cnots + i] = -np.real(
+                np.trace(np.dot(der_circuit_matrix.conj().T, self._target_matrix))
+            )
+
+        return der