qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/circuit/library/arithmetic/exact_reciprocal.py

@@ -0,0 +1,131 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2019, 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.
+"""Exact reciprocal rotation."""
+
+from math import isclose
+import numpy as np
+from qiskit.circuit import QuantumCircuit, QuantumRegister, Gate
+from qiskit.circuit.library.generalized_gates import UCRYGate
+
+
+class ExactReciprocal(QuantumCircuit):
+    r"""Exact reciprocal
+
+    .. math::
+
+        |x\rangle |0\rangle \mapsto \cos(1/x)|x\rangle|0\rangle + \sin(1/x)|x\rangle |1\rangle
+    """
+
+    def __init__(
+        self, num_state_qubits: int, scaling: float, neg_vals: bool = False, name: str = "1/x"
+    ) -> None:
+        r"""
+        Args:
+            num_state_qubits: The number of qubits representing the value to invert.
+            scaling: Scaling factor :math:`s` of the reciprocal function, i.e. to compute
+                :math:`s / x`.
+            neg_vals: Whether :math:`x` might represent negative values. In this case the first
+                qubit is the sign, with :math:`|1\rangle` for negative and :math:`|0\rangle` for
+                positive.  For the negative case it is assumed that the remaining string represents
+                :math:`1 - x`. This is because :math:`e^{-2 \pi i x} = e^{2 \pi i (1 - x)}` for
+                :math:`x \in [0,1)`.
+            name: The name of the object.
+
+        .. note::
+
+            It is assumed that the binary string :math:`x` represents a number < 1.
+        """
+        qr_state = QuantumRegister(num_state_qubits, "state")
+        qr_flag = QuantumRegister(1, "flag")
+        super().__init__(qr_state, qr_flag, name=name)
+
+        reciprocal = ExactReciprocalGate(num_state_qubits, scaling, neg_vals, label=name)
+        self.append(reciprocal, self.qubits)
+
+
+class ExactReciprocalGate(Gate):
+    r"""Implements an exact reciprocal function.
+
+    For a state :math:`|x\rangle` and a scaling factor :math:`s`, this gate implements the operation
+
+    .. math::
+
+        |x\rangle |0\rangle \mapsto
+            \cos\left(\arcsin\left(s\frac{2^n}{x}\right)\right)|x\rangle|0\rangle +
+            \left(s\frac{2^n}{x}\right)|x\rangle|1\rangle.
+
+    States representing :math:`x = 0` or :math:`s 2^n / x \geq 1` are left unchanged, since
+    this function would not be defined.
+    """
+
+    def __init__(
+        self, num_state_qubits: int, scaling: float, neg_vals: bool = False, label: str = "1/x"
+    ) -> None:
+        r"""
+        Args:
+            num_state_qubits: The number of qubits representing the value to invert.
+            scaling: Scaling factor :math:`s` of the reciprocal function, i.e. to compute
+                :math:`s / x`.
+            neg_vals: Whether :math:`x` might represent negative values. In this case the first
+                qubit is the sign, with :math:`|1\rangle` for negative and :math:`|0\rangle` for
+                positive.  For the negative case it is assumed that the remaining string represents
+                :math:`1 - x`. This is because :math:`e^{-2 \pi i x} = e^{2 \pi i (1 - x)}` for
+                :math:`x \in [0,1)`.
+            label: The label of the object.
+
+        .. note::
+
+            It is assumed that the binary string :math:`x` represents a number < 1.
+        """
+        super().__init__("ExactReciprocal", num_state_qubits + 1, [], label=label)
+
+        self.scaling = scaling
+        self.neg_vals = neg_vals
+
+    def _define(self):
+        num_state_qubits = self.num_qubits - 1
+        qr_state = QuantumRegister(num_state_qubits, "state")
+        qr_flag = QuantumRegister(1, "flag")
+        circuit = QuantumCircuit(qr_state, qr_flag)
+
+        angles = [0.0]
+        nl = 2 ** (num_state_qubits - 1) if self.neg_vals else 2**num_state_qubits
+
+        # Angles to rotate by scaling / x, where x = i / nl
+        for i in range(1, nl):
+            if isclose(self.scaling * nl / i, 1, abs_tol=1e-5):
+                angles.append(np.pi)
+            elif self.scaling * nl / i < 1:
+                angles.append(2 * np.arcsin(self.scaling * nl / i))
+            else:
+                angles.append(0.0)
+
+        circuit.append(UCRYGate(angles), [qr_flag[0]] + qr_state[: len(qr_state) - self.neg_vals])
+
+        if self.neg_vals:
+            circuit.append(
+                UCRYGate([-theta for theta in angles]).control(),
+                [qr_state[-1]] + [qr_flag[0]] + qr_state[:-1],
+            )
+            angles_neg = [0.0]
+            for i in range(1, nl):
+                if isclose(self.scaling * (-1) / (1 - i / nl), -1, abs_tol=1e-5):
+                    angles_neg.append(-np.pi)
+                elif np.abs(self.scaling * (-1) / (1 - i / nl)) < 1:
+                    angles_neg.append(2 * np.arcsin(self.scaling * (-1) / (1 - i / nl)))
+                else:
+                    angles_neg.append(0.0)
+            circuit.append(
+                UCRYGate(angles_neg).control(), [qr_state[-1]] + [qr_flag[0]] + qr_state[:-1]
+            )
+
+        self.definition = circuit

qiskit/circuit/library/arithmetic/functional_pauli_rotations.py

@@ -0,0 +1,114 @@
+# 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.
+
+
+"""Base class for functional Pauli rotations."""
+
+from typing import Optional
+
+from abc import ABC, abstractmethod
+from ..blueprintcircuit import BlueprintCircuit
+
+
+class FunctionalPauliRotations(BlueprintCircuit, ABC):
+    """Base class for functional Pauli rotations."""
+
+    def __init__(
+        self, num_state_qubits: Optional[int] = None, basis: str = "Y", name: str = "F"
+    ) -> None:
+        r"""Create a new functional Pauli rotation circuit.
+
+        Args:
+            num_state_qubits: The number of qubits representing the state :math:`|x\rangle`.
+            basis: The kind of Pauli rotation to use. Must be 'X', 'Y' or 'Z'.
+            name: The name of the circuit object.
+        """
+        super().__init__(name=name)
+
+        # define internal parameters
+        self._num_state_qubits = None
+        self._basis = None
+
+        # store parameters
+        self.num_state_qubits = num_state_qubits
+        self.basis = basis
+
+    @property
+    def basis(self) -> str:
+        """The kind of Pauli rotation to be used.
+
+        Set the basis to 'X', 'Y' or 'Z' for controlled-X, -Y, or -Z rotations respectively.
+
+        Returns:
+            The kind of Pauli rotation used in controlled rotation.
+        """
+        return self._basis
+
+    @basis.setter
+    def basis(self, basis: str) -> None:
+        """Set the kind of Pauli rotation to be used.
+
+        Args:
+            basis: The Pauli rotation to be used.
+
+        Raises:
+            ValueError: The provided basis in not X, Y or Z.
+        """
+        basis = basis.lower()
+        if self._basis is None or basis != self._basis:
+            if basis not in ["x", "y", "z"]:
+                raise ValueError(f"The provided basis must be X, Y or Z, not {basis}")
+            self._invalidate()
+            self._basis = basis
+
+    @property
+    def num_state_qubits(self) -> int:
+        r"""The number of state qubits representing the state :math:`|x\rangle`.
+
+        Returns:
+            The number of state qubits.
+        """
+        return self._num_state_qubits
+
+    @num_state_qubits.setter
+    def num_state_qubits(self, num_state_qubits: Optional[int]) -> None:
+        """Set the number of state qubits.
+
+        Note that this may change the underlying quantum register, if the number of state qubits
+        changes.
+
+        Args:
+            num_state_qubits: The new number of qubits.
+        """
+        if self._num_state_qubits is None or num_state_qubits != self._num_state_qubits:
+            self._invalidate()
+            self._num_state_qubits = num_state_qubits
+
+            self._reset_registers(num_state_qubits)
+
+    @abstractmethod
+    def _reset_registers(self, num_state_qubits: Optional[int]) -> None:
+        """Reset the registers according to the new number of state qubits.
+
+        Args:
+            num_state_qubits: The new number of qubits.
+        """
+        raise NotImplementedError
+
+    @property
+    def num_ancilla_qubits(self) -> int:
+        """The minimum number of ancilla qubits in the circuit.
+
+        Returns:
+            The minimal number of ancillas required.
+        """
+        return 0

qiskit/circuit/library/arithmetic/integer_comparator.py

@@ -0,0 +1,200 @@
+# 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.
+
+
+"""Integer Comparator."""
+
+from __future__ import annotations
+
+from qiskit.circuit import QuantumRegister, AncillaRegister, Gate
+from qiskit.circuit.exceptions import CircuitError
+from qiskit.synthesis.arithmetic.comparators import (
+    synth_integer_comparator_2s,
+    synth_integer_comparator_greedy,
+)
+from ..blueprintcircuit import BlueprintCircuit
+
+
+class IntegerComparator(BlueprintCircuit):
+    r"""Integer Comparator.
+
+    Operator compares basis states :math:`|i\rangle_n` against a classically given integer
+    :math:`L` of fixed value and flips a target qubit if :math:`i \geq L`
+    (or :math:`<` depending on the parameter ``geq``):
+
+    .. math::
+
+        |i\rangle_n |0\rangle \mapsto |i\rangle_n |i \geq L\rangle
+
+    This operation is based on two's complement implementation of binary subtraction but only
+    uses carry bits and no actual result bits. If the most significant carry bit
+    (the results bit) is 1, the :math:`\geq` condition is ``True`` otherwise it is ``False``.
+    """
+
+    def __init__(
+        self,
+        num_state_qubits: int | None = None,
+        value: int | None = None,
+        geq: bool = True,
+        name: str = "cmp",
+    ) -> None:
+        """Create a new fixed value comparator circuit.
+
+        Args:
+            num_state_qubits: Number of state qubits. If this is set it will determine the number
+                of qubits required for the circuit.
+            value: The fixed value to compare with.
+            geq: If True, evaluate a ``>=`` condition, else ``<``.
+            name: Name of the circuit.
+        """
+        super().__init__(name=name)
+
+        self._value = None
+        self._geq = None
+        self._num_state_qubits = None
+
+        self.value = value
+        self.geq = geq
+        self.num_state_qubits = num_state_qubits
+
+    @property
+    def value(self) -> int:
+        """The value to compare the qubit register to.
+
+        Returns:
+            The value against which the value of the qubit register is compared.
+        """
+        return self._value
+
+    @value.setter
+    def value(self, value: int) -> None:
+        if value != self._value:
+            self._invalidate()
+            self._value = value
+
+    @property
+    def geq(self) -> bool:
+        """Return whether the comparator compares greater or less equal.
+
+        Returns:
+            True, if the comparator compares ``>=``, False if ``<``.
+        """
+        return self._geq
+
+    @geq.setter
+    def geq(self, geq: bool) -> None:
+        """Set whether the comparator compares greater or less equal.
+
+        Args:
+            geq: If True, the comparator compares ``>=``, if False ``<``.
+        """
+        if geq != self._geq:
+            self._invalidate()
+            self._geq = geq
+
+    @property
+    def num_state_qubits(self) -> int:
+        """The number of qubits encoding the state for the comparison.
+
+        Returns:
+            The number of state qubits.
+        """
+        return self._num_state_qubits
+
+    @num_state_qubits.setter
+    def num_state_qubits(self, num_state_qubits: int | None) -> None:
+        """Set the number of state qubits.
+
+        Note that this will change the quantum registers.
+
+        Args:
+            num_state_qubits: The new number of state qubits.
+        """
+        if self._num_state_qubits is None or num_state_qubits != self._num_state_qubits:
+            self._invalidate()  # reset data
+            self._num_state_qubits = num_state_qubits
+
+            if num_state_qubits is not None:
+                # set the new qubit registers
+                qr_state = QuantumRegister(num_state_qubits, name="state")
+                q_compare = QuantumRegister(1, name="compare")
+
+                self.qregs = [qr_state, q_compare]
+
+                # add ancillas is required
+                num_ancillas = num_state_qubits - 1
+                if num_ancillas > 0:
+                    qr_ancilla = AncillaRegister(num_ancillas)
+                    self.add_register(qr_ancilla)
+
+    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("Number of state qubits is not set.")
+
+        if self._value is None:
+            valid = False
+            if raise_on_failure:
+                raise AttributeError("No comparison value set.")
+
+        required_num_qubits = 2 * self.num_state_qubits
+        if self.num_qubits != required_num_qubits:
+            valid = False
+            if raise_on_failure:
+                raise CircuitError("Number of qubits does not match required number of qubits.")
+
+        return valid
+
+    def _build(self) -> None:
+        """If not already built, build the circuit."""
+        if self._is_built:
+            return
+
+        super()._build()
+
+        circuit = synth_integer_comparator_2s(self.num_state_qubits, self.value, self.geq)
+        self.append(circuit.to_gate(), self.qubits)
+
+
+class IntegerComparatorGate(Gate):
+    r"""Perform a :math:`\geq` (or :math:`<`) on a qubit register against a classical integer.
+
+    This operator compares basis states :math:`|i\rangle_n` against a classically given integer
+    :math:`L` of fixed value and flips a target qubit if :math:`i \geq L`
+    (or :math:`<` depending on the parameter ``geq``):
+
+    .. math::
+
+        |i\rangle_n |0\rangle \mapsto |i\rangle_n |i \geq L\rangle
+
+    """
+
+    def __init__(
+        self, num_state_qubits: int, value: int, geq: bool = True, label: str | None = None
+    ):
+        r"""
+        Args:
+            num_state_qubits: The number of qubits in the registers.
+            value: The value :math:`L` to compre to.
+            geq: If ``True`` compute :math:`i \geq L`, otherwise compute :math:`i < L`.
+            label: An optional label for the gate.
+        """
+        super().__init__("IntComp", num_state_qubits + 1, [], label=label)
+        self.value = value
+        self.geq = geq
+
+    def _define(self):
+        self.definition = synth_integer_comparator_greedy(self.num_qubits - 1, self.value, self.geq)