qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/transpiler/synthesis/aqc/fast_gradient/fast_gradient.py

@@ -0,0 +1,225 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2022.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""
+Implementation of the fast objective function class.
+"""
+
+import warnings
+import numpy as np
+
+from .layer import (
+    LayerBase,
+    Layer2Q,
+    Layer1Q,
+    init_layer2q_matrices,
+    init_layer2q_deriv_matrices,
+    init_layer1q_matrices,
+    init_layer1q_deriv_matrices,
+)
+from .pmatrix import PMatrix
+from ..cnot_unit_objective import CNOTUnitObjective
+
+
+class FastCNOTUnitObjective(CNOTUnitObjective):
+    """
+    Implementation of objective function and gradient calculator, which is
+    similar to
+    :class:`~qiskit.transpiler.aqc.DefaultCNOTUnitObjective`
+    but several times faster.
+    """
+
+    def __init__(self, num_qubits: int, cnots: np.ndarray):
+        super().__init__(num_qubits, cnots)
+
+        if not 2 <= num_qubits <= 16:
+            raise ValueError("expects number of qubits in the range [2..16]")
+
+        dim = 2**num_qubits
+        self._ucf_mat = PMatrix(num_qubits)  # U^dagger @ C @ F
+        self._fuc_mat = PMatrix(num_qubits)  # F @ U^dagger @ C
+        self._circ_thetas = np.zeros((self.num_thetas,))  # last thetas used
+
+        # array of C-layers:
+        self._c_layers = np.asarray([object()] * self.num_cnots, dtype=LayerBase)
+        # array of F-layers:
+        self._f_layers = np.asarray([object()] * num_qubits, dtype=LayerBase)
+        # 4x4 C-gate matrices:
+        self._c_gates = np.full((self.num_cnots, 4, 4), fill_value=0, dtype=np.complex128)
+        # derivatives of 4x4 C-gate matrices:
+        self._c_dervs = np.full((self.num_cnots, 4, 4, 4), fill_value=0, dtype=np.complex128)
+        # 4x4 F-gate matrices:
+        self._f_gates = np.full((num_qubits, 2, 2), fill_value=0, dtype=np.complex128)
+        # derivatives of 4x4 F-gate matrices:
+        self._f_dervs = np.full((num_qubits, 3, 2, 2), fill_value=0, dtype=np.complex128)
+        # temporary NxN matrices:
+        self._tmp1 = np.full((dim, dim), fill_value=0, dtype=np.complex128)
+        self._tmp2 = np.full((dim, dim), fill_value=0, dtype=np.complex128)
+
+        # Create layers of 2-qubit gates.
+        for q in range(self.num_cnots):
+            j = int(cnots[0, q])
+            k = int(cnots[1, q])
+            self._c_layers[q] = Layer2Q(num_qubits=num_qubits, j=j, k=k)
+
+        # Create layers of 1-qubit gates.
+        for k in range(num_qubits):
+            self._f_layers[k] = Layer1Q(num_qubits=num_qubits, k=k)
+
+    def objective(self, param_values: np.ndarray) -> float:
+        """
+        Computes the objective function and some intermediate data for
+        the subsequent gradient computation.
+        See description of the base class method.
+        """
+        depth, n = self.num_cnots, self._num_qubits
+
+        # Memorize the last angular parameters used to compute the objective.
+        if self._circ_thetas.size == 0:
+            self._circ_thetas = np.zeros((self.num_thetas,))
+        np.copyto(self._circ_thetas, param_values)
+
+        thetas4d = param_values[: 4 * depth].reshape(depth, 4)
+        thetas3n = param_values[4 * depth :].reshape(n, 3)
+
+        init_layer2q_matrices(thetas=thetas4d, dst=self._c_gates)
+        init_layer2q_deriv_matrices(thetas=thetas4d, dst=self._c_dervs)
+        init_layer1q_matrices(thetas=thetas3n, dst=self._f_gates)
+        init_layer1q_deriv_matrices(thetas=thetas3n, dst=self._f_dervs)
+
+        self._init_layers()
+        self._calc_ucf_fuc()
+        objective_value = self._calc_objective_function()
+        return objective_value
+
+    def gradient(self, param_values: np.ndarray) -> np.ndarray:
+        """
+        Computes the gradient of objective function.
+        See description of the base class method.
+        """
+
+        # If thetas are the same as used for objective value calculation
+        # before calling this function, then we re-use the computations,
+        # otherwise we have to re-compute the objective.
+        tol = float(np.sqrt(np.finfo(float).eps))
+        if not np.allclose(param_values, self._circ_thetas, atol=tol, rtol=tol):
+            self.objective(param_values)
+            warnings.warn("gradient is computed before the objective")
+
+        grad = np.full((param_values.size,), fill_value=0, dtype=np.float64)
+        grad4d = grad[: 4 * self.num_cnots].reshape(self.num_cnots, 4)
+        grad3n = grad[4 * self.num_cnots :].reshape(self._num_qubits, 3)
+        self._calc_gradient4d(grad4d)
+        self._calc_gradient3n(grad3n)
+        return grad
+
+    def _init_layers(self):
+        """
+        Initializes C-layers and F-layers by corresponding gate matrices.
+        """
+        c_gates = self._c_gates
+        c_layers = self._c_layers
+        for q in range(self.num_cnots):
+            c_layers[q].set_from_matrix(mat=c_gates[q])
+
+        f_gates = self._f_gates
+        f_layers = self._f_layers
+        for q in range(self._num_qubits):
+            f_layers[q].set_from_matrix(mat=f_gates[q])
+
+    def _calc_ucf_fuc(self):
+        """
+        Computes matrices ``ucf_mat`` and ``fuc_mat``. Both remain non-finalized.
+        """
+        ucf_mat = self._ucf_mat
+        fuc_mat = self._fuc_mat
+        tmp1 = self._tmp1
+        c_layers = self._c_layers
+        f_layers = self._f_layers
+        depth, n = self.num_cnots, self._num_qubits
+
+        # tmp1 = U^dagger.
+        np.conj(self.target_matrix.T, out=tmp1)
+
+        # ucf_mat = fuc_mat = U^dagger @ C = U^dagger @ C_{depth-1} @ ... @ C_{0}.
+        self._ucf_mat.set_matrix(tmp1)
+        for q in range(depth - 1, -1, -1):
+            ucf_mat.mul_right_q2(c_layers[q], temp_mat=tmp1, dagger=False)
+        fuc_mat.set_matrix(ucf_mat.finalize(temp_mat=tmp1))
+
+        # fuc_mat = F @ U^dagger @ C = F_{n-1} @ ... @ F_{0} @ U^dagger @ C.
+        for q in range(n):
+            fuc_mat.mul_left_q1(f_layers[q], temp_mat=tmp1)
+
+        # ucf_mat = U^dagger @ C @ F = U^dagger @ C @ F_{n-1} @ ... @ F_{0}.
+        for q in range(n - 1, -1, -1):
+            ucf_mat.mul_right_q1(f_layers[q], temp_mat=tmp1, dagger=False)
+
+    def _calc_objective_function(self) -> float:
+        """
+        Computes the value of objective function.
+        """
+        ucf = self._ucf_mat.finalize(temp_mat=self._tmp1)
+        trace_ucf = np.trace(ucf)
+        fobj = abs((2**self._num_qubits) - float(np.real(trace_ucf)))
+
+        return fobj
+
+    def _calc_gradient4d(self, grad4d: np.ndarray):
+        """
+        Calculates a part gradient contributed by 2-qubit gates.
+        """
+        fuc = self._fuc_mat
+        tmp1, tmp2 = self._tmp1, self._tmp2
+        c_gates = self._c_gates
+        c_dervs = self._c_dervs
+        c_layers = self._c_layers
+        for q in range(self.num_cnots):
+            # fuc[q] <-- C[q-1] @ fuc[q-1] @ C[q].conj.T. Note, c_layers[q] has
+            # been initialized in _init_layers(), however, c_layers[q-1] was
+            # reused on the previous step, see below, so we need to restore it.
+            if q > 0:
+                c_layers[q - 1].set_from_matrix(mat=c_gates[q - 1])
+                fuc.mul_left_q2(c_layers[q - 1], temp_mat=tmp1)
+            fuc.mul_right_q2(c_layers[q], temp_mat=tmp1, dagger=True)
+            fuc.finalize(temp_mat=tmp1)
+            # Compute gradient components. We reuse c_layers[q] several times.
+            for i in range(4):
+                c_layers[q].set_from_matrix(mat=c_dervs[q, i])
+                grad4d[q, i] = (-1) * np.real(
+                    fuc.product_q2(layer=c_layers[q], tmp1=tmp1, tmp2=tmp2)
+                )
+
+    def _calc_gradient3n(self, grad3n: np.ndarray):
+        """
+        Calculates a part gradient contributed by 1-qubit gates.
+        """
+        ucf = self._ucf_mat
+        tmp1, tmp2 = self._tmp1, self._tmp2
+        f_gates = self._f_gates
+        f_dervs = self._f_dervs
+        f_layers = self._f_layers
+        for q in range(self._num_qubits):
+            # ucf[q] <-- F[q-1] @ ucf[q-1] @ F[q].conj.T. Note, f_layers[q] has
+            # been initialized in _init_layers(), however, f_layers[q-1] was
+            # reused on the previous step, see below, so we need to restore it.
+            if q > 0:
+                f_layers[q - 1].set_from_matrix(mat=f_gates[q - 1])
+                ucf.mul_left_q1(f_layers[q - 1], temp_mat=tmp1)
+            ucf.mul_right_q1(f_layers[q], temp_mat=tmp1, dagger=True)
+            ucf.finalize(temp_mat=tmp1)
+            # Compute gradient components. We reuse f_layers[q] several times.
+            for i in range(3):
+                f_layers[q].set_from_matrix(mat=f_dervs[q, i])
+                grad3n[q, i] = (-1) * np.real(
+                    ucf.product_q1(layer=f_layers[q], tmp1=tmp1, tmp2=tmp2)
+                )

qiskit/transpiler/synthesis/aqc/fast_gradient/layer.py

@@ -0,0 +1,370 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2022.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""
+Layer classes for the fast gradient implementation.
+"""
+from __future__ import annotations
+from abc import abstractmethod, ABC
+from typing import Optional
+import numpy as np
+from .fast_grad_utils import (
+    bit_permutation_1q,
+    reverse_bits,
+    inverse_permutation,
+    bit_permutation_2q,
+    make_rz,
+    make_ry,
+)
+
+
+class LayerBase(ABC):
+    """
+    Base class for any layer implementation. Each layer here is represented
+    by a 2x2 or 4x4 gate matrix ``G`` (applied to 1 or 2 qubits respectively)
+    interleaved with the identity ones:
+    ``Layer = I kron I kron ... kron G kron ... kron I kron I``
+    """
+
+    @abstractmethod
+    def set_from_matrix(self, mat: np.ndarray):
+        """
+        Updates this layer from an external gate matrix.
+
+        Args:
+            mat: external gate matrix that initializes this layer's one.
+        """
+        raise NotImplementedError()
+
+    @abstractmethod
+    def get_attr(self) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Returns gate matrix, direct and inverse permutations.
+
+        Returns:
+            (1) gate matrix; (2) direct permutation; (3) inverse permutations.
+        """
+        raise NotImplementedError()
+
+
+class Layer1Q(LayerBase):
+    """
+    Layer represents a simple circuit where 1-qubit gate matrix (of size 2x2)
+    interleaves with the identity ones.
+    """
+
+    def __init__(self, num_qubits: int, k: int, g2x2: Optional[np.ndarray] = None):
+        """
+        Args:
+            num_qubits: number of qubits.
+            k: index of the bit where gate is applied.
+            g2x2: 2x2 matrix that makes up this layer along with identity ones,
+                  or None (should be set up later).
+        """
+        super().__init__()
+
+        # 2x2 gate matrix (1-qubit gate).
+        self._gmat = np.full((2, 2), fill_value=0, dtype=np.complex128)
+        if isinstance(g2x2, np.ndarray):
+            np.copyto(self._gmat, g2x2)
+
+        bit_flip = True
+        dim = 2**num_qubits
+        row_perm = reverse_bits(
+            bit_permutation_1q(n=num_qubits, k=k), nbits=num_qubits, enable=bit_flip
+        )
+        col_perm = reverse_bits(np.arange(dim, dtype=np.int64), nbits=num_qubits, enable=bit_flip)
+        self._perm = np.full((dim,), fill_value=0, dtype=np.int64)
+        self._perm[row_perm] = col_perm
+        self._inv_perm = inverse_permutation(self._perm)
+
+    def set_from_matrix(self, mat: np.ndarray):
+        """See base class description."""
+        np.copyto(self._gmat, mat)
+
+    def get_attr(self) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """See base class description."""
+        return self._gmat, self._perm, self._inv_perm
+
+
+class Layer2Q(LayerBase):
+    """
+    Layer represents a simple circuit where 2-qubit gate matrix (of size 4x4)
+    interleaves with the identity ones.
+    """
+
+    def __init__(self, num_qubits: int, j: int, k: int, g4x4: Optional[np.ndarray] = None):
+        """
+        Args:
+            num_qubits: number of qubits.
+            j: index of the first (control) bit.
+            k: index of the second (target) bit.
+            g4x4: 4x4 matrix that makes up this layer along with identity ones,
+                  or None (should be set up later).
+        """
+        super().__init__()
+
+        # 4x4 gate matrix (2-qubit gate).
+        self._gmat = np.full((4, 4), fill_value=0, dtype=np.complex128)
+        if isinstance(g4x4, np.ndarray):
+            np.copyto(self._gmat, g4x4)
+
+        bit_flip = True
+        dim = 2**num_qubits
+        row_perm = reverse_bits(
+            bit_permutation_2q(n=num_qubits, j=j, k=k), nbits=num_qubits, enable=bit_flip
+        )
+        col_perm = reverse_bits(np.arange(dim, dtype=np.int64), nbits=num_qubits, enable=bit_flip)
+        self._perm = np.full((dim,), fill_value=0, dtype=np.int64)
+        self._perm[row_perm] = col_perm
+        self._inv_perm = inverse_permutation(self._perm)
+
+    def set_from_matrix(self, mat: np.ndarray):
+        """See base class description."""
+        np.copyto(self._gmat, mat)
+
+    def get_attr(self) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """See base class description."""
+        return self._gmat, self._perm, self._inv_perm
+
+
+def init_layer1q_matrices(thetas: np.ndarray, dst: np.ndarray) -> np.ndarray:
+    """
+    Initializes 4x4 matrices of 2-qubit gates defined in the paper.
+
+    Args:
+        thetas: depth x 4 matrix of gate parameters for every layer, where
+                "depth" is the number of layers.
+        dst: destination array of size depth x 4 x 4 that will receive gate
+             matrices of each layer.
+
+    Returns:
+        Returns the "dst" array.
+    """
+    n = thetas.shape[0]
+    tmp = np.full((4, 2, 2), fill_value=0, dtype=np.complex128)
+    for k in range(n):
+        th = thetas[k]
+        a = make_rz(th[0], out=tmp[0])
+        b = make_ry(th[1], out=tmp[1])
+        c = make_rz(th[2], out=tmp[2])
+        np.dot(np.dot(a, b, out=tmp[3]), c, out=dst[k])
+    return dst
+
+
+def init_layer1q_deriv_matrices(thetas: np.ndarray, dst: np.ndarray) -> np.ndarray:
+    """
+    Initializes 4x4 derivative matrices of 2-qubit gates defined in the paper.
+
+    Args:
+        thetas: depth x 4 matrix of gate parameters for every layer, where
+                "depth" is the number of layers.
+        dst: destination array of size depth x 4 x 4 x 4 that will receive gate
+             derivative matrices of each layer; there are 4 parameters per gate,
+             hence, 4 derivative matrices per layer.
+
+    Returns:
+        Returns the "dst" array.
+    """
+    n = thetas.shape[0]
+    y = np.asarray([[0, -0.5], [0.5, 0]], dtype=np.complex128)
+    z = np.asarray([[-0.5j, 0], [0, 0.5j]], dtype=np.complex128)
+    tmp = np.full((5, 2, 2), fill_value=0, dtype=np.complex128)
+    for k in range(n):
+        th = thetas[k]
+        a = make_rz(th[0], out=tmp[0])
+        b = make_ry(th[1], out=tmp[1])
+        c = make_rz(th[2], out=tmp[2])
+
+        za = np.dot(z, a, out=tmp[3])
+        np.dot(np.dot(za, b, out=tmp[4]), c, out=dst[k, 0])
+        yb = np.dot(y, b, out=tmp[3])
+        np.dot(a, np.dot(yb, c, out=tmp[4]), out=dst[k, 1])
+        zc = np.dot(z, c, out=tmp[3])
+        np.dot(a, np.dot(b, zc, out=tmp[4]), out=dst[k, 2])
+    return dst
+
+
+def init_layer2q_matrices(thetas: np.ndarray, dst: np.ndarray) -> np.ndarray:
+    """
+    Initializes 4x4 matrices of 2-qubit gates defined in the paper.
+
+    Args:
+        thetas: depth x 4 matrix of gate parameters for every layer, where
+                "depth" is the number of layers.
+        dst: destination array of size depth x 4 x 4 that will receive gate
+             matrices of each layer.
+
+    Returns:
+        Returns the "dst" array.
+    """
+    depth = thetas.shape[0]
+    for k in range(depth):
+        th = thetas[k]
+        cs0 = np.cos(0.5 * th[0]).item()
+        sn0 = np.sin(0.5 * th[0]).item()
+        ep1 = np.exp(0.5j * th[1]).item()
+        en1 = np.exp(-0.5j * th[1]).item()
+        cs2 = np.cos(0.5 * th[2]).item()
+        sn2 = np.sin(0.5 * th[2]).item()
+        cs3 = np.cos(0.5 * th[3]).item()
+        sn3 = np.sin(0.5 * th[3]).item()
+        ep1cs0 = ep1 * cs0
+        ep1sn0 = ep1 * sn0
+        en1cs0 = en1 * cs0
+        en1sn0 = en1 * sn0
+        sn2cs3 = sn2 * cs3
+        sn2sn3 = sn2 * sn3
+        cs2cs3 = cs2 * cs3
+        sn3cs2j = 1j * sn3 * cs2
+        sn2sn3j = 1j * sn2sn3
+
+        flat_dst = dst[k].ravel()
+        flat_dst[:] = [
+            -(sn2sn3j - cs2cs3) * en1cs0,
+            -(sn2cs3 + sn3cs2j) * en1cs0,
+            (sn2cs3 + sn3cs2j) * en1sn0,
+            (sn2sn3j - cs2cs3) * en1sn0,
+            (sn2cs3 - sn3cs2j) * en1cs0,
+            (sn2sn3j + cs2cs3) * en1cs0,
+            -(sn2sn3j + cs2cs3) * en1sn0,
+            (-sn2cs3 + sn3cs2j) * en1sn0,
+            (-sn2sn3j + cs2cs3) * ep1sn0,
+            -(sn2cs3 + sn3cs2j) * ep1sn0,
+            -(sn2cs3 + sn3cs2j) * ep1cs0,
+            (-sn2sn3j + cs2cs3) * ep1cs0,
+            (sn2cs3 - sn3cs2j) * ep1sn0,
+            (sn2sn3j + cs2cs3) * ep1sn0,
+            (sn2sn3j + cs2cs3) * ep1cs0,
+            (sn2cs3 - sn3cs2j) * ep1cs0,
+        ]
+    return dst
+
+
+def init_layer2q_deriv_matrices(thetas: np.ndarray, dst: np.ndarray) -> np.ndarray:
+    """
+    Initializes 4 x 4 derivative matrices of 2-qubit gates defined in the paper.
+
+    Args:
+        thetas: depth x 4 matrix of gate parameters for every layer, where
+                "depth" is the number of layers.
+        dst: destination array of size depth x 4 x 4 x 4 that will receive gate
+             derivative matrices of each layer; there are 4 parameters per gate,
+             hence, 4 derivative matrices per layer.
+
+    Returns:
+        Returns the "dst" array.
+    """
+    depth = thetas.shape[0]
+    for k in range(depth):
+        th = thetas[k]
+        cs0 = np.cos(0.5 * th[0]).item()
+        sn0 = np.sin(0.5 * th[0]).item()
+        ep1 = np.exp(0.5j * th[1]).item() * 0.5
+        en1 = np.exp(-0.5j * th[1]).item() * 0.5
+        cs2 = np.cos(0.5 * th[2]).item()
+        sn2 = np.sin(0.5 * th[2]).item()
+        cs3 = np.cos(0.5 * th[3]).item()
+        sn3 = np.sin(0.5 * th[3]).item()
+        ep1cs0 = ep1 * cs0
+        ep1sn0 = ep1 * sn0
+        en1cs0 = en1 * cs0
+        en1sn0 = en1 * sn0
+        sn2cs3 = sn2 * cs3
+        sn2sn3 = sn2 * sn3
+        sn3cs2 = sn3 * cs2
+        cs2cs3 = cs2 * cs3
+        sn2cs3j = 1j * sn2cs3
+        sn2sn3j = 1j * sn2sn3
+        sn3cs2j = 1j * sn3cs2
+        cs2cs3j = 1j * cs2cs3
+
+        flat_dst = dst[k, 0].ravel()
+        flat_dst[:] = [
+            (sn2sn3j - cs2cs3) * en1sn0,
+            (sn2cs3 + sn3cs2j) * en1sn0,
+            (sn2cs3 + sn3cs2j) * en1cs0,
+            (sn2sn3j - cs2cs3) * en1cs0,
+            (-sn2cs3 + sn3cs2j) * en1sn0,
+            -(sn2sn3j + cs2cs3) * en1sn0,
+            -(sn2sn3j + cs2cs3) * en1cs0,
+            (-sn2cs3 + sn3cs2j) * en1cs0,
+            (-sn2sn3j + cs2cs3) * ep1cs0,
+            -(sn2cs3 + sn3cs2j) * ep1cs0,
+            (sn2cs3 + sn3cs2j) * ep1sn0,
+            (sn2sn3j - cs2cs3) * ep1sn0,
+            (sn2cs3 - sn3cs2j) * ep1cs0,
+            (sn2sn3j + cs2cs3) * ep1cs0,
+            -(sn2sn3j + cs2cs3) * ep1sn0,
+            (-sn2cs3 + sn3cs2j) * ep1sn0,
+        ]
+
+        flat_dst = dst[k, 1].ravel()
+        flat_dst[:] = [
+            -(sn2sn3 + cs2cs3j) * en1cs0,
+            (sn2cs3j - sn3cs2) * en1cs0,
+            -(sn2cs3j - sn3cs2) * en1sn0,
+            (sn2sn3 + cs2cs3j) * en1sn0,
+            -(sn2cs3j + sn3cs2) * en1cs0,
+            (sn2sn3 - cs2cs3j) * en1cs0,
+            (-sn2sn3 + cs2cs3j) * en1sn0,
+            (sn2cs3j + sn3cs2) * en1sn0,
+            (sn2sn3 + cs2cs3j) * ep1sn0,
+            (-sn2cs3j + sn3cs2) * ep1sn0,
+            (-sn2cs3j + sn3cs2) * ep1cs0,
+            (sn2sn3 + cs2cs3j) * ep1cs0,
+            (sn2cs3j + sn3cs2) * ep1sn0,
+            (-sn2sn3 + cs2cs3j) * ep1sn0,
+            (-sn2sn3 + cs2cs3j) * ep1cs0,
+            (sn2cs3j + sn3cs2) * ep1cs0,
+        ]
+
+        flat_dst = dst[k, 2].ravel()
+        flat_dst[:] = [
+            -(sn2cs3 + sn3cs2j) * en1cs0,
+            (sn2sn3j - cs2cs3) * en1cs0,
+            -(sn2sn3j - cs2cs3) * en1sn0,
+            (sn2cs3 + sn3cs2j) * en1sn0,
+            (sn2sn3j + cs2cs3) * en1cs0,
+            (-sn2cs3 + sn3cs2j) * en1cs0,
+            (sn2cs3 - sn3cs2j) * en1sn0,
+            -(sn2sn3j + cs2cs3) * en1sn0,
+            -(sn2cs3 + sn3cs2j) * ep1sn0,
+            (sn2sn3j - cs2cs3) * ep1sn0,
+            (sn2sn3j - cs2cs3) * ep1cs0,
+            -(sn2cs3 + sn3cs2j) * ep1cs0,
+            (sn2sn3j + cs2cs3) * ep1sn0,
+            (-sn2cs3 + sn3cs2j) * ep1sn0,
+            (-sn2cs3 + sn3cs2j) * ep1cs0,
+            (sn2sn3j + cs2cs3) * ep1cs0,
+        ]
+
+        flat_dst = dst[k, 3].ravel()
+        flat_dst[:] = [
+            -(sn2cs3j + sn3cs2) * en1cs0,
+            (sn2sn3 - cs2cs3j) * en1cs0,
+            (-sn2sn3 + cs2cs3j) * en1sn0,
+            (sn2cs3j + sn3cs2) * en1sn0,
+            -(sn2sn3 + cs2cs3j) * en1cs0,
+            (sn2cs3j - sn3cs2) * en1cs0,
+            -(sn2cs3j - sn3cs2) * en1sn0,
+            (sn2sn3 + cs2cs3j) * en1sn0,
+            -(sn2cs3j + sn3cs2) * ep1sn0,
+            (sn2sn3 - cs2cs3j) * ep1sn0,
+            (sn2sn3 - cs2cs3j) * ep1cs0,
+            -(sn2cs3j + sn3cs2) * ep1cs0,
+            -(sn2sn3 + cs2cs3j) * ep1sn0,
+            (sn2cs3j - sn3cs2) * ep1sn0,
+            (sn2cs3j - sn3cs2) * ep1cs0,
+            -(sn2sn3 + cs2cs3j) * ep1cs0,
+        ]
+    return dst