qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/synthesis/unitary/aqc/approximate.py

@@ -0,0 +1,116 @@
+# 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.
+"""Base classes for an approximate circuit definition."""
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import Optional, SupportsFloat
+import numpy as np
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+
+
+class ApproximateCircuit(QuantumCircuit, ABC):
+    """A base class that represents an approximate circuit."""
+
+    def __init__(self, num_qubits: int, name: Optional[str] = None) -> None:
+        """
+        Args:
+            num_qubits: number of qubit this circuit will span.
+            name: a name of the circuit.
+        """
+        super().__init__(num_qubits, name=name)
+
+    @property
+    @abstractmethod
+    def thetas(self) -> np.ndarray:
+        """
+        The property is not implemented and raises a ``NotImplementedException`` exception.
+
+        Returns:
+            a vector of parameters of this circuit.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def build(self, thetas: np.ndarray) -> None:
+        """
+        Constructs this circuit out of the parameters(thetas). Parameter values must be set before
+            constructing the circuit.
+
+        Args:
+            thetas: a vector of parameters to be set in this circuit.
+        """
+        raise NotImplementedError
+
+
+class ApproximatingObjective(ABC):
+    """
+    A base class for an optimization problem definition. An implementing class must provide at least
+    an implementation of the ``objective`` method. In such case only gradient free optimizers can
+    be used. Both method, ``objective`` and ``gradient``, preferable to have in an implementation.
+    """
+
+    def __init__(self) -> None:
+        # must be set before optimization
+        self._target_matrix: np.ndarray | None = None
+
+    @abstractmethod
+    def objective(self, param_values: np.ndarray) -> SupportsFloat:
+        """
+        Computes a value of the objective function given a vector of parameter values.
+
+        Args:
+            param_values: a vector of parameter values for the optimization problem.
+
+        Returns:
+            a float value of the objective function.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def gradient(self, param_values: np.ndarray) -> np.ndarray:
+        """
+        Computes a gradient with respect to parameters given a vector of parameter values.
+
+        Args:
+            param_values: a vector of parameter values for the optimization problem.
+
+        Returns:
+            an array of gradient values.
+        """
+        raise NotImplementedError
+
+    @property
+    def target_matrix(self) -> np.ndarray:
+        """
+        Returns:
+            a matrix being approximated
+        """
+        return self._target_matrix
+
+    @target_matrix.setter
+    def target_matrix(self, target_matrix: np.ndarray) -> None:
+        """
+        Args:
+            target_matrix: a matrix to approximate in the optimization procedure.
+        """
+        self._target_matrix = target_matrix
+
+    @property
+    @abstractmethod
+    def num_thetas(self) -> int:
+        """
+
+        Returns:
+            the number of parameters in this optimization problem.
+        """
+        raise NotImplementedError

qiskit/synthesis/unitary/aqc/aqc.py

@@ -0,0 +1,175 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2022, 2023.
+#
+# 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 generic implementation of Approximate Quantum Compiler."""
+from __future__ import annotations
+
+import typing
+from functools import partial
+
+from collections.abc import Callable
+from typing import Protocol
+
+import numpy as np
+
+from qiskit.quantum_info import Operator
+
+from .approximate import ApproximateCircuit, ApproximatingObjective
+
+if typing.TYPE_CHECKING:
+    import scipy.optimize
+
+
+class Minimizer(Protocol):
+    """Callable Protocol for minimizer.
+
+    This interface is based on `SciPy's optimize module
+    <https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html>`__.
+
+     This protocol defines a callable taking the following parameters:
+
+         fun
+             The objective function to minimize.
+         x0
+             The initial point for the optimization.
+         jac
+             The gradient of the objective function.
+         bounds
+             Parameters bounds for the optimization. Note that these might not be supported
+             by all optimizers.
+
+     and which returns a SciPy minimization result object.
+    """
+
+    def __call__(
+        self,
+        fun: Callable[[np.ndarray], float],
+        x0: np.ndarray,  # pylint: disable=invalid-name
+        jac: Callable[[np.ndarray], np.ndarray] | None = None,
+        bounds: list[tuple[float, float]] | None = None,
+    ) -> scipy.optimize.OptimizeResult:
+        """Minimize the objective function.
+
+        This interface is based on `SciPy's optimize module <https://docs.scipy.org/doc
+        /scipy/reference/generated/scipy.optimize.minimize.html>`__.
+
+        Args:
+            fun: The objective function to minimize.
+            x0: The initial point for the optimization.
+            jac: The gradient of the objective function.
+            bounds: Parameters bounds for the optimization. Note that these might not be supported
+                by all optimizers.
+
+        Returns:
+             The SciPy minimization result object.
+        """
+        ...  # pylint: disable=unnecessary-ellipsis
+
+
+class AQC:
+    """
+    A generic implementation of the Approximate Quantum Compiler. This implementation is agnostic of
+    the underlying implementation of the approximate circuit, objective, and optimizer. Users may
+    pass corresponding implementations of the abstract classes:
+
+    * The *optimizer* is an implementation of the :class:`~.Minimizer` protocol, a callable used to run
+      the optimization process. The choice of optimizer may affect overall convergence, required time
+      for the optimization process and achieved objective value.
+
+    * The *approximate circuit* represents a template which parameters we want to optimize.  Currently,
+      there's only one implementation based on 4-rotations CNOT unit blocks:
+      :class:`.CNOTUnitCircuit`. See the paper for more details.
+
+    * The *approximate objective* is tightly coupled with the approximate circuit implementation and
+      provides two methods for computing objective function and gradient with respect to approximate
+      circuit parameters. This objective is passed to the optimizer. Currently, there are two
+      implementations based on 4-rotations CNOT unit blocks: :class:`.DefaultCNOTUnitObjective` and
+      its accelerated version :class:`.FastCNOTUnitObjective`. Both implementations share the same
+      idea of maximization the Hilbert-Schmidt product between the target matrix and its
+      approximation. The former implementation approach should be considered as a baseline one. It
+      may suffer from performance issues, and is mostly suitable for a small number of qubits
+      (up to 5 or 6), whereas the latter, accelerated one, can be applied to larger problems.
+
+    * One should take into consideration the exponential growth of matrix size with the number of
+      qubits because the implementation not only creates a potentially large target matrix, but
+      also allocates a number of temporary memory buffers comparable in size to the target matrix.
+    """
+
+    def __init__(
+        self,
+        optimizer: Minimizer | None = None,
+        seed: int | None = None,
+    ):
+        """
+        Args:
+            optimizer: an optimizer to be used in the optimization procedure of the search for
+                the best approximate circuit. By default, the scipy minimizer with the
+                ``L-BFGS-B`` method is used with max iterations set to 1000.
+            seed: a seed value to be used by a random number generator.
+        """
+        import scipy.optimize
+
+        super().__init__()
+        self._optimizer = optimizer or partial(
+            scipy.optimize.minimize, args=(), method="L-BFGS-B", options={"maxiter": 1000}
+        )
+
+        self._seed = seed
+
+    def compile_unitary(
+        self,
+        target_matrix: np.ndarray,
+        approximate_circuit: ApproximateCircuit,
+        approximating_objective: ApproximatingObjective,
+        initial_point: np.ndarray | None = None,
+    ) -> None:
+        """
+        Approximately compiles a circuit represented as a unitary matrix by solving an optimization
+        problem defined by ``approximating_objective`` and using ``approximate_circuit`` as a
+        template for the approximate circuit.
+
+        Args:
+            target_matrix: a unitary matrix to approximate.
+            approximate_circuit: a template circuit that will be filled with the parameter values
+                obtained in the optimization procedure.
+            approximating_objective: a definition of the optimization problem.
+            initial_point: initial values of angles/parameters to start optimization from.
+        """
+        matrix_dim = target_matrix.shape[0]
+        # check if it is actually a special unitary matrix
+        target_det = np.linalg.det(target_matrix)
+        if not np.isclose(target_det, 1):
+            su_matrix = target_matrix / np.power(target_det, (1 / matrix_dim), dtype=complex)
+            global_phase_required = True
+        else:
+            su_matrix = target_matrix
+            global_phase_required = False
+
+        # set the matrix to approximate in the algorithm
+        approximating_objective.target_matrix = su_matrix
+
+        if initial_point is None:
+            np.random.seed(self._seed)
+            initial_point = np.random.uniform(0, 2 * np.pi, approximating_objective.num_thetas)
+
+        opt_result = self._optimizer(
+            fun=approximating_objective.objective,
+            x0=initial_point,
+            jac=approximating_objective.gradient,
+        )
+
+        approximate_circuit.build(opt_result.x)
+
+        approx_matrix = Operator(approximate_circuit).data
+
+        if global_phase_required:
+            alpha = np.angle(np.trace(np.dot(approx_matrix.conj().T, target_matrix)))
+            approximate_circuit.global_phase = alpha

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)