qiskit 1.3.0b1__cp39-abi3-macosx_10_9_x86_64.whl

qiskit/circuit/library/arithmetic/polynomial_pauli_rotations.py

@@ -0,0 +1,335 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2020.
+#
+# 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.
+
+
+"""Polynomially controlled Pauli-rotations."""
+
+from __future__ import annotations
+
+from itertools import product
+
+from qiskit.circuit import QuantumRegister, QuantumCircuit
+from qiskit.circuit.exceptions import CircuitError
+
+from .functional_pauli_rotations import FunctionalPauliRotations
+
+
+def _binomial_coefficients(n):
+    """Return a dictionary of binomial coefficients
+
+    Based-on/forked from sympy's binomial_coefficients() function [#]
+
+    .. [#] https://github.com/sympy/sympy/blob/sympy-1.5.1/sympy/ntheory/multinomial.py
+    """
+
+    data = {(0, n): 1, (n, 0): 1}
+    temp = 1
+    for k in range(1, n // 2 + 1):
+        temp = (temp * (n - k + 1)) // k
+        data[k, n - k] = data[n - k, k] = temp
+    return data
+
+
+def _large_coefficients_iter(m, n):
+    """Return an iterator of multinomial coefficients
+
+    Based-on/forked from sympy's multinomial_coefficients_iterator() function [#]
+
+    .. [#] https://github.com/sympy/sympy/blob/sympy-1.5.1/sympy/ntheory/multinomial.py
+    """
+    if m < 2 * n or n == 1:
+        coefficients = _multinomial_coefficients(m, n)
+        for key, value in coefficients.items():
+            yield (key, value)
+    else:
+        coefficients = _multinomial_coefficients(n, n)
+        coefficients_dict = {}
+        for key, value in coefficients.items():
+            coefficients_dict[tuple(filter(None, key))] = value
+        coefficients = coefficients_dict
+
+        temp = [n] + [0] * (m - 1)
+        temp_a = tuple(temp)
+        b = tuple(filter(None, temp_a))
+        yield (temp_a, coefficients[b])
+        if n:
+            j = 0  # j will be the leftmost nonzero position
+        else:
+            j = m
+        # enumerate tuples in co-lex order
+        while j < m - 1:
+            # compute next tuple
+            temp_j = temp[j]
+            if j:
+                temp[j] = 0
+                temp[0] = temp_j
+            if temp_j > 1:
+                temp[j + 1] += 1
+                j = 0
+            else:
+                j += 1
+                temp[j] += 1
+
+            temp[0] -= 1
+            temp_a = tuple(temp)
+            b = tuple(filter(None, temp_a))
+            yield (temp_a, coefficients[b])
+
+
+def _multinomial_coefficients(m, n):
+    """Return an iterator of multinomial coefficients
+
+    Based-on/forked from sympy's multinomial_coefficients() function [#]
+
+    .. [#] https://github.com/sympy/sympy/blob/sympy-1.5.1/sympy/ntheory/multinomial.py
+    """
+    if not m:
+        if n:
+            return {}
+        return {(): 1}
+    if m == 2:
+        return _binomial_coefficients(n)
+    if m >= 2 * n and n > 1:
+        return dict(_large_coefficients_iter(m, n))
+    if n:
+        j = 0
+    else:
+        j = m
+    temp = [n] + [0] * (m - 1)
+    res = {tuple(temp): 1}
+    while j < m - 1:
+        temp_j = temp[j]
+        if j:
+            temp[j] = 0
+            temp[0] = temp_j
+        if temp_j > 1:
+            temp[j + 1] += 1
+            j = 0
+            start = 1
+            v = 0
+        else:
+            j += 1
+            start = j + 1
+            v = res[tuple(temp)]
+            temp[j] += 1
+        for k in range(start, m):
+            if temp[k]:
+                temp[k] -= 1
+                v += res[tuple(temp)]
+                temp[k] += 1
+        temp[0] -= 1
+        res[tuple(temp)] = (v * temp_j) // (n - temp[0])
+    return res
+
+
+class PolynomialPauliRotations(FunctionalPauliRotations):
+    r"""A circuit implementing polynomial Pauli rotations.
+
+    For a polynomial :math:`p(x)`, a basis state :math:`|i\rangle` and a target qubit
+    :math:`|0\rangle` this operator acts as:
+
+    .. math::
+
+        |i\rangle |0\rangle \mapsto \cos\left(\frac{p(i)}{2}\right) |i\rangle |0\rangle
+        + \sin\left(\frac{p(i)}{2}\right) |i\rangle |1\rangle
+
+    Let n be the number of qubits representing the state, d the degree of p(x) and q_i the qubits,
+    where q_0 is the least significant qubit. Then for
+
+    .. math::
+
+        x = \sum_{i=0}^{n-1} 2^i q_i,
+
+    we can write
+
+    .. math::
+
+        p(x) = \sum_{j=0}^{j=d} c_j x^j
+
+    where :math:`c` are the input coefficients, ``coeffs``.
+    """
+
+    def __init__(
+        self,
+        num_state_qubits: int | None = None,
+        coeffs: list[float] | None = None,
+        basis: str = "Y",
+        name: str = "poly",
+    ) -> None:
+        """Prepare an approximation to a state with amplitudes specified by a polynomial.
+
+        Args:
+            num_state_qubits: The number of qubits representing the state.
+            coeffs: The coefficients of the polynomial. ``coeffs[i]`` is the coefficient of the
+                i-th power of x. Defaults to linear: [0, 1].
+            basis: The type of Pauli rotation ('X', 'Y', 'Z').
+            name: The name of the circuit.
+        """
+        # set default internal parameters
+        self._coeffs = coeffs or [0, 1]
+
+        # initialize super (after setting coeffs)
+        super().__init__(num_state_qubits=num_state_qubits, basis=basis, name=name)
+
+    @property
+    def coeffs(self) -> list[float]:
+        """The coefficients of the polynomial.
+
+        ``coeffs[i]`` is the coefficient of the i-th power of the function input :math:`x`,
+        that means that the rotation angles are based on the coefficients value,
+        following the formula
+
+        .. math::
+
+            c_j x^j ,  j=0, ..., d
+
+        where :math:`d` is the degree of the polynomial :math:`p(x)` and :math:`c` are the coefficients
+        ``coeffs``.
+
+        Returns:
+            The coefficients of the polynomial.
+        """
+        return self._coeffs
+
+    @coeffs.setter
+    def coeffs(self, coeffs: list[float]) -> None:
+        """Set the coefficients of the polynomial.
+
+        ``coeffs[i]`` is the coefficient of the i-th power of x.
+
+        Args:
+            The coefficients of the polynomial.
+        """
+        self._invalidate()
+        self._coeffs = coeffs
+
+    @property
+    def degree(self) -> int:
+        """Return the degree of the polynomial, equals to the number of coefficients minus 1.
+
+        Returns:
+            The degree of the polynomial. If the coefficients have not been set, return 0.
+        """
+        if self.coeffs:
+            return len(self.coeffs) - 1
+        return 0
+
+    def _reset_registers(self, num_state_qubits):
+        """Reset the registers."""
+        if num_state_qubits is not None:
+            # set new register of appropriate size
+            qr_state = QuantumRegister(num_state_qubits, name="state")
+            qr_target = QuantumRegister(1, name="target")
+
+            self.qregs = [qr_state, qr_target]
+        else:
+            self.qregs = []
+
+    def _check_configuration(self, raise_on_failure: bool = True) -> bool:
+        """Check if the current configuration is valid."""
+        valid = True
+
+        if self.num_state_qubits is None:
+            valid = False
+            if raise_on_failure:
+                raise AttributeError("The number of qubits has not been set.")
+
+        if self.num_qubits < self.num_state_qubits + 1:
+            valid = False
+            if raise_on_failure:
+                raise CircuitError(
+                    "Not enough qubits in the circuit, need at least "
+                    f"{self.num_state_qubits + 1}."
+                )
+
+        return valid
+
+    def _get_rotation_coefficients(self) -> dict[tuple[int, ...], float]:
+        """Compute the coefficient of each monomial.
+
+        Returns:
+            A dictionary with pairs ``{control_state: rotation angle}`` where ``control_state``
+            is a tuple of ``0`` or ``1`` bits.
+        """
+        # determine the control states
+        all_combinations = list(product([0, 1], repeat=self.num_state_qubits))
+        valid_combinations = []
+        for combination in all_combinations:
+            if 0 < sum(combination) <= self.degree:
+                valid_combinations += [combination]
+
+        rotation_coeffs = {control_state: 0.0 for control_state in valid_combinations}
+
+        # compute the coefficients for the control states
+        for i, coeff in enumerate(self.coeffs[1:]):
+            i += 1  # since we skip the first element we need to increase i by one
+
+            # iterate over the multinomial coefficients
+            for comb, num_combs in _multinomial_coefficients(self.num_state_qubits, i).items():
+                control_state: tuple[int, ...] = ()
+                power = 1
+                for j, qubit in enumerate(comb):
+                    if qubit > 0:  # means we control on qubit i
+                        control_state += (1,)
+                        power *= 2 ** (j * qubit)
+                    else:
+                        control_state += (0,)
+
+                # Add angle
+                rotation_coeffs[control_state] += coeff * num_combs * power
+
+        return rotation_coeffs
+
+    def _build(self):
+        """If not already built, build the circuit."""
+        if self._is_built:
+            return
+
+        super()._build()
+
+        circuit = QuantumCircuit(*self.qregs, name=self.name)
+        qr_state = circuit.qubits[: self.num_state_qubits]
+        qr_target = circuit.qubits[self.num_state_qubits]
+
+        rotation_coeffs = self._get_rotation_coefficients()
+
+        if self.basis == "x":
+            circuit.rx(self.coeffs[0], qr_target)
+        elif self.basis == "y":
+            circuit.ry(self.coeffs[0], qr_target)
+        else:
+            circuit.rz(self.coeffs[0], qr_target)
+
+        for c in rotation_coeffs:
+            qr_control = []
+            for i, _ in enumerate(c):
+                if c[i] > 0:
+                    qr_control.append(qr_state[i])
+
+            # apply controlled rotations
+            if len(qr_control) > 1:
+                if self.basis == "x":
+                    circuit.mcrx(rotation_coeffs[c], qr_control, qr_target)
+                elif self.basis == "y":
+                    circuit.mcry(rotation_coeffs[c], qr_control, qr_target)
+                else:
+                    circuit.mcrz(rotation_coeffs[c], qr_control, qr_target)
+
+            elif len(qr_control) == 1:
+                if self.basis == "x":
+                    circuit.crx(rotation_coeffs[c], qr_control[0], qr_target)
+                elif self.basis == "y":
+                    circuit.cry(rotation_coeffs[c], qr_control[0], qr_target)
+                else:
+                    circuit.crz(rotation_coeffs[c], qr_control[0], qr_target)
+
+        self.append(circuit.to_gate(), self.qubits)

qiskit/circuit/library/arithmetic/quadratic_form.py

@@ -0,0 +1,198 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2020.
+#
+# 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 circuit implementing a quadratic form on binary variables."""
+
+from typing import Union, Optional, List
+import math
+
+import numpy as np
+
+from qiskit.circuit import QuantumCircuit, QuantumRegister, ParameterExpression
+from ..basis_change import QFT
+
+
+class QuadraticForm(QuantumCircuit):
+    r"""Implements a quadratic form on binary variables encoded in qubit registers.
+
+    A quadratic form on binary variables is a quadratic function :math:`Q` acting on a binary
+    variable of :math:`n` bits, :math:`x = x_0 ... x_{n-1}`. For an integer matrix :math:`A`,
+    an integer vector :math:`b` and an integer :math:`c` the function can be written as
+
+    .. math::
+
+        Q(x) = x^T A x + x^T b + c
+
+    If :math:`A`, :math:`b` or :math:`c` contain scalar values, this circuit computes only
+    an approximation of the quadratic form.
+
+    Provided with :math:`m` qubits to encode the value, this circuit computes :math:`Q(x) \mod 2^m`
+    in [two's complement](https://stackoverflow.com/questions/1049722/what-is-2s-complement)
+    representation.
+
+    .. math::
+
+        |x\rangle_n |0\rangle_m \mapsto |x\rangle_n |(Q(x) + 2^m) \mod 2^m \rangle_m
+
+    Since we use two's complement e.g. the value of :math:`Q(x) = 3` requires 2 bits to represent
+    the value and 1 bit for the sign: `3 = '011'` where the first `0` indicates a positive value.
+    On the other hand, :math:`Q(x) = -3` would be `-3 = '101'`, where the first `1` indicates
+    a negative value and `01` is the two's complement of `3`.
+
+    If the value of :math:`Q(x)` is too large to be represented with `m` qubits, the resulting
+    bitstring is :math:`(Q(x) + 2^m) \mod 2^m)`.
+
+    The implementation of this circuit is discussed in [1], Fig. 6.
+
+    References:
+        [1]: Gilliam et al., Grover Adaptive Search for Constrained Polynomial Binary Optimization.
+             `arXiv:1912.04088 <https://arxiv.org/pdf/1912.04088.pdf>`_
+
+    """
+
+    def __init__(
+        self,
+        num_result_qubits: Optional[int] = None,
+        quadratic: Optional[
+            Union[np.ndarray, List[List[Union[float, ParameterExpression]]]]
+        ] = None,
+        linear: Optional[Union[np.ndarray, List[Union[float, ParameterExpression]]]] = None,
+        offset: Optional[Union[float, ParameterExpression]] = None,
+        little_endian: bool = True,
+    ) -> None:
+        r"""
+        Args:
+            num_result_qubits: The number of qubits to encode the result. Called :math:`m` in
+                the class documentation.
+            quadratic: A matrix containing the quadratic coefficients, :math:`A`.
+            linear: An array containing the linear coefficients, :math:`b`.
+            offset: A constant offset, :math:`c`.
+            little_endian: Encode the result in little endianness.
+
+        Raises:
+            ValueError: If ``linear`` and ``quadratic`` have mismatching sizes.
+            ValueError: If ``num_result_qubits`` is unspecified but cannot be determined because
+                some values of the quadratic form are parameterized.
+        """
+        # check inputs match
+        if quadratic is not None and linear is not None:
+            if len(quadratic) != len(linear):
+                raise ValueError("Mismatching sizes of quadratic and linear.")
+
+        # temporarily set quadratic and linear to [] instead of None so we can iterate over them
+        if quadratic is None:
+            quadratic = []
+
+        if linear is None:
+            linear = []
+
+        if offset is None:
+            offset = 0
+
+        num_input_qubits = np.max([1, len(linear), len(quadratic)])
+
+        # deduce number of result bits if not added
+        if num_result_qubits is None:
+            # check no value is parameterized
+            if (
+                any(any(isinstance(q_ij, ParameterExpression) for q_ij in q_i) for q_i in quadratic)
+                or any(isinstance(l_i, ParameterExpression) for l_i in linear)
+                or isinstance(offset, ParameterExpression)
+            ):
+                raise ValueError(
+                    "If the number of result qubits is not specified, the quadratic "
+                    "form matrices/vectors/offset may not be parameterized."
+                )
+            num_result_qubits = self.required_result_qubits(quadratic, linear, offset)
+
+        qr_input = QuantumRegister(num_input_qubits)
+        qr_result = QuantumRegister(num_result_qubits)
+        circuit = QuantumCircuit(qr_input, qr_result, name="Q(x)")
+
+        # set quadratic and linear again to None if they were None
+        if len(quadratic) == 0:
+            quadratic = None
+
+        if len(linear) == 0:
+            linear = None
+
+        scaling = np.pi * 2 ** (1 - num_result_qubits)
+
+        # initial QFT (just hadamards)
+        circuit.h(qr_result)
+
+        if little_endian:
+            qr_result = qr_result[::-1]
+
+        # constant coefficient
+        if offset != 0:
+            for i, q_i in enumerate(qr_result):
+                circuit.p(scaling * 2**i * offset, q_i)
+
+        # the linear part consists of the vector and the diagonal of the
+        # matrix, since x_i * x_i = x_i, as x_i is a binary variable
+        for j in range(num_input_qubits):
+            value = linear[j] if linear is not None else 0
+            value += quadratic[j][j] if quadratic is not None else 0
+            if value != 0:
+                for i, q_i in enumerate(qr_result):
+                    circuit.cp(scaling * 2**i * value, qr_input[j], q_i)
+
+        # the quadratic part adds A_ij and A_ji as x_i x_j == x_j x_i
+        if quadratic is not None:
+            for j in range(num_input_qubits):
+                for k in range(j + 1, num_input_qubits):
+                    value = quadratic[j][k] + quadratic[k][j]
+                    if value != 0:
+                        for i, q_i in enumerate(qr_result):
+                            circuit.mcp(scaling * 2**i * value, [qr_input[j], qr_input[k]], q_i)
+
+        # add the inverse QFT
+        iqft = QFT(num_result_qubits, do_swaps=False).inverse().reverse_bits()
+        circuit.compose(iqft, qubits=qr_result[:], inplace=True)
+
+        super().__init__(*circuit.qregs, name="Q(x)")
+        self.compose(circuit.to_gate(), qubits=self.qubits, inplace=True)
+
+    @staticmethod
+    def required_result_qubits(
+        quadratic: Union[np.ndarray, List[List[float]]],
+        linear: Union[np.ndarray, List[float]],
+        offset: float,
+    ) -> int:
+        """Get the number of required result qubits.
+
+        Args:
+            quadratic: A matrix containing the quadratic coefficients.
+            linear: An array containing the linear coefficients.
+            offset: A constant offset.
+
+        Returns:
+            The number of qubits needed to represent the value of the quadratic form
+            in twos complement.
+        """
+
+        bounds = []  # bounds = [minimum value, maximum value]
+        for condition in [lambda x: x < 0, lambda x: x > 0]:
+            bound = 0.0
+            bound += sum(sum(q_ij for q_ij in q_i if condition(q_ij)) for q_i in quadratic)
+            bound += sum(l_i for l_i in linear if condition(l_i))
+            bound += offset if condition(offset) else 0
+            bounds.append(bound)
+
+        # the minimum number of qubits is the number of qubits needed to represent
+        # the minimum/maximum value plus one sign qubit
+        num_qubits_for_min = math.ceil(math.log2(max(-bounds[0], 1)))
+        num_qubits_for_max = math.ceil(math.log2(bounds[1] + 1))
+        num_result_qubits = 1 + max(num_qubits_for_min, num_qubits_for_max)
+
+        return num_result_qubits