qiskit 1.4.2__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/circuit/library/arithmetic/piecewise_chebyshev.py

@@ -17,11 +17,14 @@ from typing import Callable
 import numpy as np
 from numpy.polynomial.chebyshev import Chebyshev
 
-from qiskit.circuit import QuantumRegister, AncillaRegister
+from qiskit.circuit import QuantumCircuit, QuantumRegister, AncillaRegister, Gate
 from qiskit.circuit.library.blueprintcircuit import BlueprintCircuit
 from qiskit.circuit.exceptions import CircuitError
 
-from .piecewise_polynomial_pauli_rotations import PiecewisePolynomialPauliRotations
+from .piecewise_polynomial_pauli_rotations import (
+    PiecewisePolynomialPauliRotations,
+    PiecewisePolynomialPauliRotationsGate,
+)
 
 
 class PiecewiseChebyshev(BlueprintCircuit):
@@ -346,9 +349,154 @@ class PiecewiseChebyshev(BlueprintCircuit):
             self.num_state_qubits, self.breakpoints, self.polynomials, name=self.name
         )
 
-        # qr_state = self.qubits[: self.num_state_qubits]
-        # qr_target = [self.qubits[self.num_state_qubits]]
-        # qr_ancillas = self.qubits[self.num_state_qubits + 1 :]
-
         # Apply polynomial approximation
         self.append(poly_r.to_gate(), self.qubits)
+
+
+class PiecewiseChebyshevGate(Gate):
+    r"""Piecewise Chebyshev approximation to an input function.
+
+    For a given function :math:`f(x)` and degree :math:`d`, this class implements a piecewise
+    polynomial Chebyshev approximation on :math:`n` qubits to :math:`f(x)` on the given intervals.
+    All the polynomials in the approximation are of degree :math:`d`.
+
+    The values of the parameters are calculated according to [1] and see [2] for a more
+    detailed explanation of the circuit construction and how it acts on the qubits.
+
+    Examples:
+
+        .. plot::
+           :alt: Example of generating a circuit with the piecewise Chebyshev gate.
+           :include-source:
+
+            import numpy as np
+            from qiskit import QuantumCircuit
+            from qiskit.circuit.library.arithmetic import PiecewiseChebyshevGate
+
+            f_x, num_state_qubits, degree, breakpoints = lambda x: np.arcsin(1 / x), 2, 2, [2, 4]
+            pw_approximation = PiecewiseChebyshevGate(f_x, num_state_qubits, degree, breakpoints)
+
+            qc = QuantumCircuit(pw_approximation.num_qubits)
+            qc.h(list(range(num_state_qubits)))
+            qc.append(pw_approximation, qc.qubits)
+            qc.draw(output="mpl")
+
+    References:
+
+        [1]: Haener, T., Roetteler, M., & Svore, K. M. (2018).
+             Optimizing Quantum Circuits for Arithmetic.
+             `arXiv:1805.12445 <http://arxiv.org/abs/1805.12445>`_
+        [2]: Carrera Vazquez, A., Hiptmair, H., & Woerner, S. (2022).
+             Enhancing the Quantum Linear Systems Algorithm Using Richardson Extrapolation.
+             `ACM Transactions on Quantum Computing 3, 1, Article 2 <https://doi.org/10.1145/3490631>`_
+    """
+
+    def __init__(
+        self,
+        f_x: float | Callable[[int], float],
+        num_state_qubits: int,
+        degree: int | None = None,
+        breakpoints: list[int] | None = None,
+        label: str | None = None,
+    ) -> None:
+        r"""
+        Args:
+            f_x: the function to be approximated. Constant functions should be specified
+             as f_x = constant.
+            num_state_qubits: number of qubits representing the state.
+            degree: the degree of the polynomials.
+                Defaults to ``1``.
+            breakpoints: the breakpoints to define the piecewise-linear function.
+                Defaults to the full interval.
+            label: A label for the gate.
+        """
+        # Store parameters
+        self.f_x = f_x
+        self.degree = degree if degree is not None else 1
+        self.num_state_qubits = num_state_qubits
+
+        # validate the breakpoints
+        if breakpoints is None:
+            breakpoints = [0]
+
+        # If the last breakpoint is < num_states, add the identity polynomial
+        num_states = 2**num_state_qubits
+        if breakpoints[-1] < num_states:
+            breakpoints = breakpoints + [num_states]
+
+        # If the first breakpoint is > 0, add the identity polynomial
+        if breakpoints[0] > 0:
+            breakpoints = [0] + breakpoints
+
+        self.breakpoints = breakpoints
+
+        num_compare = int(len(breakpoints) > 2)
+        super().__init__("PiecewiseChebyshev", num_state_qubits + num_compare + 1, [], label)
+
+        # after initialization, build the polynomials
+        self.polynomials = self._build_polynomials()
+
+    def _build_polynomials(self):
+        """The polynomials for the piecewise approximation.
+
+        Returns:
+            The polynomials for the piecewise approximation.
+
+        Raises:
+            TypeError: If the input function is not in the correct format.
+        """
+
+        # note this must be the private attribute since we handle missing breakpoints at
+        # 0 and 2 ^ num_qubits here (e.g. if the function we approximate is not defined at 0
+        # and the user takes that into account we just add an identity)
+        breakpoints = self.breakpoints
+
+        # Need to take into account the case in which no breakpoints were provided in first place
+        num_state_qubits = self.num_qubits - 1
+        if breakpoints == [0]:
+            breakpoints = [0, 2**num_state_qubits]
+
+        num_intervals = len(breakpoints)
+
+        # Calculate the polynomials
+        polynomials = []
+        for i in range(0, num_intervals - 1):
+            # Calculate the polynomial approximating the function on the current interval
+            try:
+                # If the function is constant don't call Chebyshev (not necessary and gives errors)
+                if isinstance(self.f_x, (float, int)):
+                    # Append directly to list of polynomials
+                    polynomials.append([self.f_x])
+                else:
+                    poly = Chebyshev.interpolate(
+                        self.f_x, self.degree, domain=[breakpoints[i], breakpoints[i + 1]]
+                    )
+                    # Convert polynomial to the standard basis and rescale it for the rotation gates
+                    poly = 2 * poly.convert(kind=np.polynomial.Polynomial).coef
+                    # Convert to list and append
+                    polynomials.append(poly.tolist())
+            except ValueError as err:
+                raise TypeError(
+                    " <lambda>() missing 1 required positional argument: '"
+                    + self.f_x.__code__.co_varnames[0]
+                    + "'."
+                    + " Constant functions should be specified as 'f_x = constant'."
+                ) from err
+
+        # If the last breakpoint is < 2 ** num_qubits, add the identity polynomial
+        if breakpoints[-1] < 2**num_state_qubits:
+            polynomials = polynomials + [[2 * np.arcsin(1)]]
+
+        # If the first breakpoint is > 0, add the identity polynomial
+        if breakpoints[0] > 0:
+            polynomials = [[2 * np.arcsin(1)]] + polynomials
+
+        return polynomials
+
+    def _define(self):
+        poly_r = PiecewisePolynomialPauliRotationsGate(
+            self.num_state_qubits, self.breakpoints, self.polynomials
+        )
+
+        self.definition = QuantumCircuit(poly_r.num_qubits)
+        self.definition.append(poly_r, self.definition.qubits)

qiskit/circuit/library/arithmetic/piecewise_linear_pauli_rotations.py

@@ -14,14 +14,15 @@
 """Piecewise-linearly-controlled rotation."""
 
 from __future__ import annotations
+from collections.abc import Sequence
 import numpy as np
 
-from qiskit.circuit import QuantumRegister, AncillaRegister, QuantumCircuit
+from qiskit.circuit import QuantumRegister, AncillaRegister, QuantumCircuit, Gate
 from qiskit.circuit.exceptions import CircuitError
 
 from .functional_pauli_rotations import FunctionalPauliRotations
-from .linear_pauli_rotations import LinearPauliRotations
-from .integer_comparator import IntegerComparator
+from .linear_pauli_rotations import LinearPauliRotations, LinearPauliRotationsGate
+from .integer_comparator import IntegerComparator, IntegerComparatorGate
 
 
 class PiecewiseLinearPauliRotations(FunctionalPauliRotations):
@@ -272,6 +273,115 @@ class PiecewiseLinearPauliRotations(FunctionalPauliRotations):
                 circuit.append(lin_r.to_gate().control(), qr_compare[:] + qr_state[:] + qr_target)
 
                 # uncompute comparator
-                circuit.append(comp.to_gate().inverse(), qr[:] + qr_helper[: comp.num_ancillas])
+                circuit.append(comp.to_gate(), qr[:] + qr_helper[: comp.num_ancillas])
 
         self.append(circuit.to_gate(), self.qubits)
+
+
+class PiecewiseLinearPauliRotationsGate(Gate):
+    r"""Piecewise-linearly-controlled Pauli rotations.
+
+    For a piecewise linear (not necessarily continuous) function :math:`f(x)`, which is defined
+    through breakpoints, slopes and offsets as follows.
+    Suppose the breakpoints :math:`(x_0, ..., x_J)` are a subset of :math:`[0, 2^n-1]`, where
+    :math:`n` is the number of state qubits. Further on, denote the corresponding slopes and
+    offsets by :math:`a_j` and :math:`b_j` respectively.
+    Then f(x) is defined as:
+
+    .. math::
+
+        f(x) = \begin{cases}
+            0, x < x_0 \\
+            a_j (x - x_j) + b_j, x_j \leq x < x_{j+1}
+            \end{cases}
+
+    where we implicitly assume :math:`x_{J+1} = 2^n`.
+    """
+
+    def __init__(
+        self,
+        num_state_qubits: int | None = None,
+        breakpoints: list[int] | None = None,
+        slopes: Sequence[float] | None = None,
+        offsets: Sequence[float] | None = None,
+        basis: str = "Y",
+        label: str | None = None,
+    ) -> None:
+        """Construct piecewise-linearly-controlled Pauli rotations.
+
+        Args:
+            num_state_qubits: The number of qubits representing the state.
+            breakpoints: The breakpoints to define the piecewise-linear function.
+                Defaults to ``[0]``.
+            slopes: The slopes for different segments of the piecewise-linear function.
+                Defaults to ``[1]``.
+            offsets: The offsets for different segments of the piecewise-linear function.
+                Defaults to ``[0]``.
+            basis: The type of Pauli rotation (``'X'``, ``'Y'``, ``'Z'``).
+            label: The label of the gate.
+        """
+        self.breakpoints = breakpoints if breakpoints is not None else [0]
+        self.slopes = slopes if slopes is not None else [1]
+        self.offsets = offsets if offsets is not None else [0]
+        self.basis = basis
+
+        num_compare_bits = 1 if len(self.breakpoints) > 1 else 0
+        super().__init__("PwLinPauliRot", num_state_qubits + 1 + num_compare_bits, [], label=label)
+
+    def _define(self):
+        circuit = QuantumCircuit(self.num_qubits, name=self.name)
+
+        if len(self.breakpoints) == 1:
+            qr_state = circuit.qubits[: self.num_qubits - 1]
+            qr_target = [circuit.qubits[-1]]
+            qr_compare = []
+        else:
+            qr_state = circuit.qubits[: self.num_qubits - 2]
+            qr_target = [circuit.qubits[-2]]
+            qr_compare = [circuit.qubits[-1]]
+
+        num_state_qubits = len(qr_state)
+
+        mapped_slopes = np.zeros_like(self.slopes)
+        for i, slope in enumerate(self.slopes):
+            mapped_slopes[i] = slope - sum(mapped_slopes[:i])
+
+        mapped_offsets = np.zeros_like(self.offsets)
+        for i, (offset, slope, point) in enumerate(
+            zip(self.offsets, self.slopes, self.breakpoints)
+        ):
+            mapped_offsets[i] = offset - slope * point - sum(mapped_offsets[:i])
+
+        # apply comparators and controlled linear rotations
+        contains_zero_breakpoint = np.isclose(self.breakpoints[0], 0)
+        for i, point in enumerate(self.breakpoints):
+            if i == 0 and contains_zero_breakpoint:
+                # apply rotation
+                lin_r = LinearPauliRotationsGate(
+                    num_state_qubits=num_state_qubits,
+                    slope=mapped_slopes[i],
+                    offset=mapped_offsets[i],
+                    basis=self.basis,
+                )
+                circuit.append(lin_r, qr_state[:] + qr_target)
+
+            else:
+                # apply Comparator
+                comp = IntegerComparatorGate(num_state_qubits=num_state_qubits, value=point)
+                qr = qr_state[:] + qr_compare[:]  # add ancilla as compare qubit
+
+                circuit.append(comp, qr[:])
+
+                # apply controlled rotation
+                lin_r = LinearPauliRotationsGate(
+                    num_state_qubits=num_state_qubits,
+                    slope=mapped_slopes[i],
+                    offset=mapped_offsets[i],
+                    basis=self.basis,
+                )
+                circuit.append(lin_r.control(), qr_compare[:] + qr_state[:] + qr_target)
+
+                # uncompute comparator (which is its self-inverse)
+                circuit.append(comp, qr[:])
+
+        self.definition = circuit

qiskit/circuit/library/arithmetic/piecewise_polynomial_pauli_rotations.py

@@ -16,12 +16,12 @@ from __future__ import annotations
 from typing import List, Optional
 import numpy as np
 
-from qiskit.circuit import QuantumRegister, AncillaRegister, QuantumCircuit
+from qiskit.circuit import QuantumRegister, AncillaRegister, QuantumCircuit, Gate
 from qiskit.circuit.exceptions import CircuitError
 
 from .functional_pauli_rotations import FunctionalPauliRotations
-from .polynomial_pauli_rotations import PolynomialPauliRotations
-from .integer_comparator import IntegerComparator
+from .polynomial_pauli_rotations import PolynomialPauliRotations, PolynomialPauliRotationsGate
+from .integer_comparator import IntegerComparator, IntegerComparatorGate
 
 
 class PiecewisePolynomialPauliRotations(FunctionalPauliRotations):
@@ -101,8 +101,8 @@ class PiecewisePolynomialPauliRotations(FunctionalPauliRotations):
             breakpoints: The breakpoints to define the piecewise-linear function.
                 Defaults to ``[0]``.
             coeffs: The coefficients of the polynomials for different segments of the
-            piecewise-linear function. ``coeffs[j][i]`` is the coefficient of the i-th power of x
-            for the j-th polynomial.
+                piecewise-linear function. ``coeffs[j][i]`` is the coefficient of the i-th power of x
+                for the j-th polynomial.
                 Defaults to linear: ``[[1]]``.
             basis: The type of Pauli rotation (``'X'``, ``'Y'``, ``'Z'``).
             name: The name of the circuit.
@@ -187,16 +187,7 @@ class PiecewisePolynomialPauliRotations(FunctionalPauliRotations):
         Returns:
             The mapped coefficients.
         """
-        mapped_coeffs = []
-
-        # First polynomial
-        mapped_coeffs.append(self._hom_coeffs[0])
-        for i in range(1, len(self._hom_coeffs)):
-            mapped_coeffs.append([])
-            for j in range(0, self._degree + 1):
-                mapped_coeffs[i].append(self._hom_coeffs[i][j] - self._hom_coeffs[i - 1][j])
-
-        return mapped_coeffs
+        return _map_coeffs(self._hom_coeffs)
 
     @property
     def contains_zero_breakpoint(self) -> bool | np.bool_:
@@ -315,3 +306,188 @@ class PiecewisePolynomialPauliRotations(FunctionalPauliRotations):
                 )
 
         self.append(circuit.to_gate(), self.qubits)
+
+
+class PiecewisePolynomialPauliRotationsGate(Gate):
+    r"""Piecewise-polynomially-controlled Pauli rotations.
+
+    This class implements a piecewise polynomial (not necessarily continuous) function,
+    :math:`f(x)`, on qubit amplitudes, which is defined through breakpoints and coefficients as
+    follows.
+    Suppose the breakpoints :math:`(x_0, ..., x_J)` are a subset of :math:`[0, 2^n-1]`, where
+    :math:`n` is the number of state qubits. Further on, denote the corresponding coefficients by
+    :math:`[a_{j,1},...,a_{j,d}]`, where :math:`d` is the highest degree among all polynomials.
+
+    Then :math:`f(x)` is defined as:
+
+    .. math::
+
+        f(x) = \begin{cases}
+            0, x < x_0 \\
+            \sum_{i=0}^{i=d}a_{j,i}/2 x^i, x_j \leq x < x_{j+1}
+            \end{cases}
+
+    where if given the same number of breakpoints as polynomials, we implicitly assume
+    :math:`x_{J+1} = 2^n`.
+
+    .. note::
+
+        Note the :math:`1/2` factor in the coefficients of :math:`f(x)`, this is consistent with
+        Qiskit's Pauli rotations.
+
+    Examples:
+        >>> from qiskit import QuantumCircuit
+        >>> from qiskit.circuit.library.arithmetic.piecewise_polynomial_pauli_rotations import\
+        ... PiecewisePolynomialPauliRotations
+        >>> qubits, breakpoints, coeffs = (2, [0, 2], [[0, -1.2],[-1, 1, 3]])
+        >>> poly_r = PiecewisePolynomialPauliRotations(num_state_qubits=qubits,
+        ...breakpoints=breakpoints, coeffs=coeffs)
+        >>>
+        >>> qc = QuantumCircuit(poly_r.num_qubits)
+        >>> qc.h(list(range(qubits)));
+        >>> qc.append(poly_r.to_instruction(), list(range(qc.num_qubits)));
+        >>> qc.draw()
+             ┌───┐┌──────────┐
+        q_0: ┤ H ├┤0         ├
+             ├───┤│          │
+        q_1: ┤ H ├┤1         ├
+             └───┘│          │
+        q_2: ─────┤2         ├
+                  │  pw_poly │
+        q_3: ─────┤3         ├
+                  │          │
+        q_4: ─────┤4         ├
+                  │          │
+        q_5: ─────┤5         ├
+                  └──────────┘
+
+    References:
+        [1]: Haener, T., Roetteler, M., & Svore, K. M. (2018).
+             Optimizing Quantum Circuits for Arithmetic.
+             `arXiv:1805.12445 <http://arxiv.org/abs/1805.12445>`_
+
+        [2]: Carrera Vazquez, A., Hiptmair, R., & Woerner, S. (2022).
+             Enhancing the Quantum Linear Systems Algorithm using Richardson Extrapolation.
+             `ACM Transactions on Quantum Computing 3, 1, Article 2 <https://doi.org/10.1145/3490631>`_
+    """
+
+    def __init__(
+        self,
+        num_state_qubits: int,
+        breakpoints: list[int] | None = None,
+        coeffs: list[list[float]] | None = None,
+        basis: str = "Y",
+        label: str | None = None,
+    ) -> None:
+        """
+        Args:
+            num_state_qubits: The number of qubits representing the state.
+            breakpoints: The breakpoints to define the piecewise-linear function.
+                Defaults to ``[0]``.
+            coeffs: The coefficients of the polynomials for different segments of the
+                piecewise-linear function. ``coeffs[j][i]`` is the coefficient of the i-th power of x
+                for the j-th polynomial.
+                Defaults to linear: ``[[1]]``.
+            basis: The type of Pauli rotation (``'X'``, ``'Y'``, ``'Z'``).
+            label: An optional label for the gate.
+        """
+
+        if coeffs is None:
+            degree = 0
+            coeffs = [[1]]
+        else:
+            # store a list of coefficients as homogeneous polynomials adding 0's where necessary
+            degree = len(max(coeffs, key=len)) - 1
+            coeffs = [poly + [0] * (degree + 1 - len(poly)) for poly in coeffs]
+
+        # ensure the breakpoint contains 2 ** num_state_qubits
+        breakpoints = breakpoints.copy()
+        if breakpoints is None:
+            breakpoints = [0, 2**num_state_qubits]
+        elif breakpoints[-1] < 2**num_state_qubits:
+            breakpoints.append(2**num_state_qubits)
+
+        self.coeffs = coeffs
+        self.breakpoints = breakpoints
+        self.basis = basis
+
+        self.num_compare = int(len(self.breakpoints) > 2)
+        super().__init__(
+            "PiecewisePolyPauli", num_state_qubits + self.num_compare + 1, [], label=label
+        )
+
+    def evaluate(self, x: float) -> float:
+        """Classically evaluate the piecewise polynomial rotation.
+
+        Args:
+            x: Value to be evaluated at.
+
+        Returns:
+            Value of piecewise polynomial function at x.
+        """
+        mapped_coeffs = _map_coeffs(self.coeffs)
+
+        y = 0
+        for i, breakpt in enumerate(self.breakpoints):
+            y = y + (x >= breakpt) * (np.poly1d(mapped_coeffs[i][::-1])(x))
+
+        return y
+
+    def _define(self):
+        num_state_qubits = self.num_qubits - self.num_compare - 1
+        circuit = QuantumCircuit(self.num_qubits, name=self.name)
+        qr_state = circuit.qubits[:num_state_qubits]
+
+        if len(self.breakpoints) > 2:
+            qr_target = [circuit.qubits[-2]]
+            qr_compare = [circuit.qubits[-1]]
+        else:
+            qr_target = [circuit.qubits[-1]]
+            qr_compare = []
+
+        # apply comparators and controlled linear rotations
+        contains_zero_breakpoint = np.isclose(self.breakpoints[0], 0)
+        mapped_coeffs = _map_coeffs(self.coeffs)
+
+        for i, point in enumerate(self.breakpoints[:-1]):
+            if i == 0 and contains_zero_breakpoint:
+                # apply rotation
+                poly_r = PolynomialPauliRotationsGate(
+                    num_state_qubits=num_state_qubits,
+                    coeffs=mapped_coeffs[i],
+                    basis=self.basis,
+                )
+                circuit.append(poly_r, qr_state[:] + qr_target)
+
+            else:
+                # apply Comparator
+                comp = IntegerComparatorGate(num_state_qubits=num_state_qubits, value=point)
+                qr_state_full = qr_state[:] + qr_compare  # add compare qubit
+
+                circuit.append(comp, qr_state_full[:])
+
+                # apply controlled rotation
+                poly_r = PolynomialPauliRotationsGate(
+                    num_state_qubits=num_state_qubits,
+                    coeffs=mapped_coeffs[i],
+                    basis=self.basis,
+                )
+                circuit.append(poly_r.control(), qr_compare + qr_state[:] + qr_target)
+
+                # uncompute comparator
+                circuit.append(comp, qr_state_full[:])
+
+        self.definition = circuit
+
+
+def _map_coeffs(coeffs):
+    mapped_coeffs = []
+    mapped_coeffs.append(coeffs[0])
+
+    degree = len(coeffs[0]) - 1  # all coeffs should have the same length by now
+    for i in range(1, len(coeffs)):
+        mapped_coeffs.append([])
+        for j in range(0, degree + 1):
+            mapped_coeffs[i].append(coeffs[i][j] - coeffs[i - 1][j])
+
+    return mapped_coeffs