qiskit 2.0.3__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

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

qiskit/synthesis/unitary/aqc/elementary_operations.py

@@ -0,0 +1,108 @@
+# 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 a number of elementary functions that are required for the AQC routines to work.
+"""
+
+import numpy as np
+
+from qiskit.circuit.library.standard_gates import RXGate, RZGate, RYGate
+
+
+def place_unitary(unitary: np.ndarray, n: int, j: int) -> np.ndarray:
+    """
+    Computes I(j - 1) tensor product U tensor product I(n - j), where U is a unitary matrix
+    of size ``(2, 2)``.
+
+    Args:
+        unitary: a unitary matrix of size ``(2, 2)``.
+        n: num qubits.
+        j: position where to place a unitary.
+
+    Returns:
+        a unitary of n qubits with u in position j.
+    """
+    return np.kron(np.kron(np.eye(2**j), unitary), np.eye(2 ** (n - 1 - j)))
+
+
+def place_cnot(n: int, j: int, k: int) -> np.ndarray:
+    """
+    Places a CNOT from j to k.
+
+    Args:
+        n: number of qubits.
+        j: control qubit.
+        k: target qubit.
+
+    Returns:
+        a unitary of n qubits with CNOT placed at ``j`` and ``k``.
+    """
+    if j < k:
+        unitary = np.kron(
+            np.kron(np.eye(2**j), [[1, 0], [0, 0]]), np.eye(2 ** (n - 1 - j))
+        ) + np.kron(
+            np.kron(
+                np.kron(np.kron(np.eye(2**j), [[0, 0], [0, 1]]), np.eye(2 ** (k - j - 1))),
+                [[0, 1], [1, 0]],
+            ),
+            np.eye(2 ** (n - 1 - k)),
+        )
+    else:
+        unitary = np.kron(
+            np.kron(np.eye(2**j), [[1, 0], [0, 0]]), np.eye(2 ** (n - 1 - j))
+        ) + np.kron(
+            np.kron(
+                np.kron(np.kron(np.eye(2**k), [[0, 1], [1, 0]]), np.eye(2 ** (j - k - 1))),
+                [[0, 0], [0, 1]],
+            ),
+            np.eye(2 ** (n - 1 - j)),
+        )
+    return unitary
+
+
+def rx_matrix(phi: float) -> np.ndarray:
+    """
+    Computes an RX rotation by the angle of ``phi``.
+
+    Args:
+        phi: rotation angle.
+
+    Returns:
+        an RX rotation matrix.
+    """
+    return RXGate(phi).to_matrix()
+
+
+def ry_matrix(phi: float) -> np.ndarray:
+    """
+    Computes an RY rotation by the angle of ``phi``.
+
+    Args:
+        phi: rotation angle.
+
+    Returns:
+        an RY rotation matrix.
+    """
+    return RYGate(phi).to_matrix()
+
+
+def rz_matrix(phi: float) -> np.ndarray:
+    """
+    Computes an RZ rotation by the angle of ``phi``.
+
+    Args:
+        phi: rotation angle.
+
+    Returns:
+        an RZ rotation matrix.
+    """
+    return RZGate(phi).to_matrix()

qiskit/synthesis/unitary/aqc/fast_gradient/__init__.py

@@ -0,0 +1,164 @@
+# 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.
+
+r"""
+================================================================================
+Fast implementation of objective function class
+(:mod:`qiskit.synthesis.unitary.aqc.fast_gradient`)
+================================================================================
+
+.. currentmodule:: qiskit.synthesis.unitary.aqc.fast_gradient
+
+Extension to the implementation of Approximate Quantum Compiler as described in the paper [1].
+
+Interface
+=========
+
+The main public class of this module is FastCNOTUnitObjective. It replaces the default objective
+function implementation :class:`.DefaultCNOTUnitObjective` for faster computation.
+The individual classes include the public one (FastCNOTUnitObjective) and few
+internal ones:
+
+.. autosummary::
+    :toctree: ../stubs
+    :template: autosummary/class_no_inherited_members.rst
+
+    FastCNOTUnitObjective
+    LayerBase
+    Layer1Q
+    Layer2Q
+    PMatrix
+
+
+Mathematical Details
+====================
+
+In what follows we briefly outline the main ideas underlying the accelerated implementation
+of objective function class.
+
+* The key ingredient of approximate compiling is the efficient optimization procedure
+  that minimizes :math:`\|V - U\|_{\mathrm{F}}` on a classical computer, where :math:`U`
+  is a given (target) unitary matrix and :math:`V` is a matrix of approximating quantum
+  circuit. Alternatively, we maximize the Hilbert-Schmidt product between :math:`U` and
+  :math:`V` as outlined in the main part of the documentation.
+
+* The circuit :math:`V` can be represented as a sequence of 2-qubit gates (layers)
+  applied one after another. The corresponding matrix takes the form:
+  :math:`V = C_0 C_1 \ldots C_{L-1} F`, where :math:`L` is the length of the sequence
+  (number of layers). If the total number of qubits :math:`n > 2`, every
+  :math:`C_i = C_i(\Theta_i)` is a sparse, :math:`2^n \times 2^n` matrix of 2-qubit gate
+  (CNOT unit block) parameterized by a sub-set of parameters :math:`\Theta_i`
+  (4 parameters per unit block), and :math:`F` is a matrix that comprises the action
+  of all 1-qubit gates in front of approximating circuit. See the paper [1] for details.
+
+* Over the course of optimization we compute the value of objective function and its
+  gradient, which implies computation of :math:`V` and its derivatives
+  :math:`{\partial V}/{\partial \Theta_i}` for all :math:`i`, given the current estimation
+  of all the parameters :math:`\Theta`.
+
+* A naive implementation of the product :math:`V = C_0 C_1 \ldots C_{L-1} F` and its
+  derivatives would include computation and memorization of forward and backward partial
+  products as required by the backtracking algorithm. This is wasteful in terms of
+  performance and resource allocation.
+
+* Minimization of :math:`\|V - U\|_{\mathrm{F}}^2` is equivalent to maximization of
+  :math:`\text{Re}\left(\text{Tr}\left(U^{\dagger} V\right)\right)`. By cyclic permutation
+  of the sequence of matrices under trace operation, we can avoid memorization of intermediate
+  partial products of gate matrices :math:`C_i`. Note, matrix size grows exponentially with
+  the number of qubits, quickly becoming prohibitively large.
+
+* Sparse structure of :math:`C_i` can be exploited to speed up matrix-matrix multiplication.
+  However, using sparse matrices as such does not give performance gain because sparse patterns
+  tend to violate data proximity inside the cache memory of modern CPUs. Instead, we make use
+  of special structure of gate matrices :math:`C_i` coupled with permutation ones. Although
+  permutation is not cache friendly either, its impact is seemingly less severe than that
+  of sparse matrix multiplication (at least in Python implementation).
+
+* On every optimization iteration we, first, compute :math:`V = C_0 C_1 \ldots C_{L-1} F`
+  given the current estimation of all the parameters :math:`\Theta`.
+
+* As for the gradient of objective function, it can be shown (by moving cyclically around
+  an individual matrices under trace operation) that:
+
+.. math::
+    \text{Tr}\left( U^{\dagger} \frac{\partial V}{\partial \Theta_{l,k}} \right) =
+    \langle \text{vec}\left(E_l\right), \text{vec}\left(
+    \frac{\partial C_l}{\partial \Theta_{l,k}}\right) \rangle,
+
+where :math:`\Theta_{l,k}` is a :math:`k`-th parameter of :math:`l`-th CNOT unit block,
+and :math:`E_l=C_{l-1}\left(C_{l-2}\left(\cdots\left(C_0\left(U^{\dagger}V
+C_0^{\dagger}\right)C_1^{\dagger}\right) \cdots\right)C_{l-1}^{\dagger}\right)C_l^{\dagger}`
+is an intermediate matrix.
+
+* For every :math:`l`-th gradient component, we compute the trace using the matrix
+  :math:`E_l`, then this matrix is updated by multiplication on left and on the right
+  by corresponding gate matrices :math:`C_l` and :math:`C_{l+1}^{\dagger}` respectively
+  and proceed to the next gradient component.
+
+* We save computations and resources by not storing intermediate partial products of
+  :math:`C_i`.  Instead, incrementally updated matrix :math:`E_l` keeps all related
+  information. Also, vectorization of involved matrices (see the above formula) allows
+  us to replace matrix-matrix multiplication by "cheaper" vector-vector one under the
+  trace operation.
+
+* The matrices :math:`C_i` are sparse. However, even for relatively small matrices
+  (< 1M elements) sparse-dense multiplication can be very slow. Construction of sparse
+  matrices takes a time as well.  We should update every gate matrix on each iteration
+  of optimization loop.
+
+* In fact, any gate matrix :math:`C_i` can be transformed to what we call a standard
+  form: :math:`C_i = P^T \widetilde{C}_i P`, where :math:`P` is an easily computable
+  permutation matrix and :math:`\widetilde{C}_i` has a block-diagonal layout:
+
+.. math::
+    \widetilde{C}_i = \left(
+    \begin{array}{ccc}
+    G_{4 \times 4} & \ddots & 0 \\
+    \ddots & \ddots & \ddots \\
+    0 & \ddots & G_{4 \times 4}
+    \end{array}
+    \right)
+
+* The 2-qubit gate matrix :math:`G_{4 \times 4}` is repeated along diagonal of the full
+  :math:`2^n \times 2^n` :math:`\widetilde{C}_i`.
+
+* We do not actually create neither matrix :math:`\widetilde{C}_i` nor :math:`P`.
+  In fact, only :math:`G_{4 \times 4}` and a permutation array (of size :math:`2^n`)
+  are kept in memory.
+
+* Consider left-hand side multiplication by some dense, :math:`2^n \times 2^n` matrix :math:`M`:
+
+.. math::
+    C_i M = P^T \widetilde{C}_i P M = P^T \left( \widetilde{C}_i \left( P M \right) \right)
+
+* First, we permute rows of :math:`M`, which is equivalent to the product :math:`P M`, but
+  without expensive multiplication of two :math:`2^n \times 2^n` matrices.
+
+* Second, we compute :math:`\widetilde{C}_i P M` multiplying every block-diagonal sub-matrix
+  :math:`G_{4 \times 4}` by the corresponding rows of :math:`P M`. This is the dense-dense
+  matrix multiplication, which is very well optimized on modern CPUs. Important: the total
+  number of operations is :math:`O(2^{2 n})` in contrast to :math:`O(2^{3 n})` as in general
+  case.
+
+* Third, we permute rows of :math:`\widetilde{C}_i P M` by applying :math:`P^T`.
+
+* Right-hand side multiplication is done in a similar way.
+
+* In summary, we save computational resources by exploiting some properties of 2-qubit gate
+  matrices :math:`C_i` and using hardware optimized multiplication of dense matrices. There
+  is still a room for further improvement, of course.
+
+References:
+
+    [1]: Liam Madden, Andrea Simonetto, Best Approximate Quantum Compiling Problems.
+    `arXiv:2106.05649 <https://arxiv.org/abs/2106.05649>`_
+"""