qiskit 1.3.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/circuit/library/arithmetic/adders/adder.py

@@ -0,0 +1,210 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+"""Compute the sum of two equally sized qubit registers."""
+
+from __future__ import annotations
+
+from qiskit.circuit import QuantumCircuit, Gate
+from qiskit.utils.deprecation import deprecate_func
+
+
+class Adder(QuantumCircuit):
+    r"""Compute the sum of two equally sized qubit registers.
+
+    For two registers :math:`|a\rangle_n` and :math:`|b\rangle_n` with :math:`n` qubits each, an
+    adder performs the following operation
+
+    .. math::
+
+        |a\rangle_n |b\rangle_n \mapsto |a\rangle_n |a + b\rangle_{n + 1}.
+
+    The quantum register :math:`|a\rangle_n` (and analogously :math:`|b\rangle_n`)
+
+    .. math::
+
+        |a\rangle_n = |a_0\rangle \otimes \cdots \otimes |a_{n - 1}\rangle,
+
+    for :math:`a_i \in \{0, 1\}`, is associated with the integer value
+
+    .. math::
+
+        a = 2^{0}a_{0} + 2^{1}a_{1} + \cdots + 2^{n - 1}a_{n - 1}.
+
+    """
+
+    @deprecate_func(
+        since="1.3",
+        additional_msg=(
+            "Use the adder gates provided in qiskit.circuit.library.arithmetic instead. "
+            "The gate type depends on the adder kind: fixed, half, full are represented by "
+            "ModularAdderGate, HalfAdderGate, FullAdderGate, respectively. For different adder "
+            "implementations, see https://docs.quantum.ibm.com/api/qiskit/synthesis.",
+        ),
+        pending=True,
+    )
+    def __init__(self, num_state_qubits: int, name: str = "Adder") -> None:
+        """
+        Args:
+            num_state_qubits: The number of qubits in each of the registers.
+            name: The name of the circuit.
+        """
+        super().__init__(name=name)
+        self._num_state_qubits = num_state_qubits
+
+    @property
+    def num_state_qubits(self) -> int:
+        """The number of state qubits, i.e. the number of bits in each input register.
+
+        Returns:
+            The number of state qubits.
+        """
+        return self._num_state_qubits
+
+
+class HalfAdderGate(Gate):
+    r"""Compute the sum of two equally-sized qubit registers, including a carry-out bit.
+
+    For two registers :math:`|a\rangle_n` and :math:`|b\rangle_n` with :math:`n` qubits each, an
+    adder performs the following operation
+
+    .. math::
+
+        |a\rangle_n |b\rangle_n \mapsto |a\rangle_n |a + b\rangle_{n + 1}.
+
+    The quantum register :math:`|a\rangle_n` (and analogously :math:`|b\rangle_n`)
+
+    .. math::
+
+        |a\rangle_n = |a_0\rangle \otimes \cdots \otimes |a_{n - 1}\rangle,
+
+    for :math:`a_i \in \{0, 1\}`, is associated with the integer value
+
+    .. math::
+
+        a = 2^{0}a_{0} + 2^{1}a_{1} + \cdots + 2^{n - 1}a_{n - 1}.
+
+    """
+
+    def __init__(self, num_state_qubits: int, label: str | None = None) -> None:
+        """
+        Args:
+            num_state_qubits: The number of qubits in each of the registers.
+            name: The name of the circuit.
+        """
+        if num_state_qubits < 1:
+            raise ValueError("Need at least 1 state qubit.")
+
+        super().__init__("HalfAdder", 2 * num_state_qubits + 1, [], label=label)
+        self._num_state_qubits = num_state_qubits
+
+    @property
+    def num_state_qubits(self) -> int:
+        """The number of state qubits, i.e. the number of bits in each input register.
+
+        Returns:
+            The number of state qubits.
+        """
+        return self._num_state_qubits
+
+
+class ModularAdderGate(Gate):
+    r"""Compute the sum modulo :math:`2^n` of two :math:`n`-sized qubit registers.
+
+    For two registers :math:`|a\rangle_n` and :math:`|b\rangle_n` with :math:`n` qubits each, an
+    adder performs the following operation
+
+    .. math::
+
+        |a\rangle_n |b\rangle_n \mapsto |a\rangle_n |a + b \text{ mod } 2^n\rangle_n.
+
+    The quantum register :math:`|a\rangle_n` (and analogously :math:`|b\rangle_n`)
+
+    .. math::
+
+        |a\rangle_n = |a_0\rangle \otimes \cdots \otimes |a_{n - 1}\rangle,
+
+    for :math:`a_i \in \{0, 1\}`, is associated with the integer value
+
+    .. math::
+
+        a = 2^{0}a_{0} + 2^{1}a_{1} + \cdots + 2^{n - 1}a_{n - 1}.
+
+    """
+
+    def __init__(self, num_state_qubits: int, label: str | None = None) -> None:
+        """
+        Args:
+            num_state_qubits: The number of qubits in each of the registers.
+            name: The name of the circuit.
+        """
+        if num_state_qubits < 1:
+            raise ValueError("Need at least 1 state qubit.")
+
+        super().__init__("ModularAdder", 2 * num_state_qubits, [], label=label)
+        self._num_state_qubits = num_state_qubits
+
+    @property
+    def num_state_qubits(self) -> int:
+        """The number of state qubits, i.e. the number of bits in each input register.
+
+        Returns:
+            The number of state qubits.
+        """
+        return self._num_state_qubits
+
+
+class FullAdderGate(Gate):
+    r"""Compute the sum of two :math:`n`-sized qubit registers, including carry-in and -out bits.
+
+    For two registers :math:`|a\rangle_n` and :math:`|b\rangle_n` with :math:`n` qubits each, an
+    adder performs the following operation
+
+    .. math::
+
+        |c_{\text{in}}\rangle_1 |a\rangle_n |b\rangle_n
+        \mapsto |a\rangle_n |c_{\text{in}} + a + b \rangle_{n + 1}.
+
+    The quantum register :math:`|a\rangle_n` (and analogously :math:`|b\rangle_n`)
+
+    .. math::
+
+        |a\rangle_n = |a_0\rangle \otimes \cdots \otimes |a_{n - 1}\rangle,
+
+    for :math:`a_i \in \{0, 1\}`, is associated with the integer value
+
+    .. math::
+
+        a = 2^{0}a_{0} + 2^{1}a_{1} + \cdots + 2^{n - 1}a_{n - 1}.
+
+    """
+
+    def __init__(self, num_state_qubits: int, label: str | None = None) -> None:
+        """
+        Args:
+            num_state_qubits: The number of qubits in each of the registers.
+            name: The name of the circuit.
+        """
+        if num_state_qubits < 1:
+            raise ValueError("Need at least 1 state qubit.")
+
+        super().__init__("FullAdder", 2 * num_state_qubits + 2, [], label=label)
+        self._num_state_qubits = num_state_qubits
+
+    @property
+    def num_state_qubits(self) -> int:
+        """The number of state qubits, i.e. the number of bits in each input register.
+
+        Returns:
+            The number of state qubits.
+        """
+        return self._num_state_qubits

qiskit/circuit/library/arithmetic/adders/cdkm_ripple_carry_adder.py

@@ -0,0 +1,123 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+"""Compute the sum of two qubit registers using ripple-carry approach."""
+
+from qiskit.synthesis.arithmetic import adder_ripple_c04
+from .adder import Adder
+
+
+class CDKMRippleCarryAdder(Adder):
+    r"""A ripple-carry circuit to perform in-place addition on two qubit registers.
+
+    As an example, a ripple-carry adder circuit that performs addition on two 3-qubit sized
+    registers with a carry-in bit (``kind="full"``) is as follows:
+
+    .. code-block:: text
+
+                ┌──────┐                                     ┌──────┐
+         cin_0: ┤2     ├─────────────────────────────────────┤2     ├
+                │      │┌──────┐                     ┌──────┐│      │
+           a_0: ┤0     ├┤2     ├─────────────────────┤2     ├┤0     ├
+                │      ││      │┌──────┐     ┌──────┐│      ││      │
+           a_1: ┤  MAJ ├┤0     ├┤2     ├─────┤2     ├┤0     ├┤  UMA ├
+                │      ││      ││      │     │      ││      ││      │
+           a_2: ┤      ├┤  MAJ ├┤0     ├──■──┤0     ├┤  UMA ├┤      ├
+                │      ││      ││      │  │  │      ││      ││      │
+           b_0: ┤1     ├┤      ├┤  MAJ ├──┼──┤  UMA ├┤      ├┤1     ├
+                └──────┘│      ││      │  │  │      ││      │└──────┘
+           b_1: ────────┤1     ├┤      ├──┼──┤      ├┤1     ├────────
+                        └──────┘│      │  │  │      │└──────┘
+           b_2: ────────────────┤1     ├──┼──┤1     ├────────────────
+                                └──────┘┌─┴─┐└──────┘
+        cout_0: ────────────────────────┤ X ├────────────────────────
+                                        └───┘
+
+    Here *MAJ* and *UMA* gates correspond to the gates introduced in [1]. Note that
+    in this implementation the input register qubits are ordered as all qubits from
+    the first input register, followed by all qubits from the second input register.
+
+    Two different kinds of adders are supported. By setting the ``kind`` argument, you can also
+    choose a half-adder, which doesn't have a carry-in, and a fixed-sized-adder, which has neither
+    carry-in nor carry-out, and thus acts on fixed register sizes. Unlike the full-adder,
+    these circuits need one additional helper qubit.
+
+    The circuit diagram for the fixed-point adder (``kind="fixed"``) on 3-qubit sized inputs is
+
+    .. code-block:: text
+
+                ┌──────┐┌──────┐                ┌──────┐┌──────┐
+           a_0: ┤0     ├┤2     ├────────────────┤2     ├┤0     ├
+                │      ││      │┌──────┐┌──────┐│      ││      │
+           a_1: ┤      ├┤0     ├┤2     ├┤2     ├┤0     ├┤      ├
+                │      ││      ││      ││      ││      ││      │
+           a_2: ┤      ├┤  MAJ ├┤0     ├┤0     ├┤  UMA ├┤      ├
+                │      ││      ││      ││      ││      ││      │
+           b_0: ┤1 MAJ ├┤      ├┤  MAJ ├┤  UMA ├┤      ├┤1 UMA ├
+                │      ││      ││      ││      ││      ││      │
+           b_1: ┤      ├┤1     ├┤      ├┤      ├┤1     ├┤      ├
+                │      │└──────┘│      ││      │└──────┘│      │
+           b_2: ┤      ├────────┤1     ├┤1     ├────────┤      ├
+                │      │        └──────┘└──────┘        │      │
+        help_0: ┤2     ├────────────────────────────────┤2     ├
+                └──────┘                                └──────┘
+
+    It has one less qubit than the full-adder since it doesn't have the carry-out, but uses
+    a helper qubit instead of the carry-in, so it only has one less qubit, not two.
+
+    .. seealso::
+
+        The following generic gate objects perform additions, like this circuit class,
+        but allow the compiler to select the optimal decomposition based on the context.
+        Specific implementations can be set via the :class:`.HLSConfig`, e.g. this circuit
+        can be chosen via ``Adder=["ripple_c04"]``.
+
+        :class:`.ModularAdderGate`: A generic inplace adder, modulo :math:`2^n`. This
+            is functionally equivalent to ``kind="fixed"``.
+
+        :class:`.HalfAdderGate`: A generic inplace adder. This
+            is functionally equivalent to ``kind="half"``.
+
+        :class:`.FullAdderGate`: A generic inplace adder, with a carry-in bit. This
+            is functionally equivalent to ``kind="full"``.
+
+    **References:**
+
+    [1] Cuccaro et al., A new quantum ripple-carry addition circuit, 2004.
+    `arXiv:quant-ph/0410184 <https://arxiv.org/pdf/quant-ph/0410184.pdf>`_
+
+    [2] Vedral et al., Quantum Networks for Elementary Arithmetic Operations, 1995.
+    `arXiv:quant-ph/9511018 <https://arxiv.org/pdf/quant-ph/9511018.pdf>`_
+
+    """
+
+    def __init__(
+        self, num_state_qubits: int, kind: str = "full", name: str = "CDKMRippleCarryAdder"
+    ) -> None:
+        r"""
+        Args:
+            num_state_qubits: The number of qubits in either input register for
+                state :math:`|a\rangle` or :math:`|b\rangle`. The two input
+                registers must have the same number of qubits.
+            kind: The kind of adder, can be ``'full'`` for a full adder, ``'half'`` for a half
+                adder, or ``'fixed'`` for a fixed-sized adder. A full adder includes both carry-in
+                and carry-out, a half only carry-out, and a fixed-sized adder neither carry-in
+                nor carry-out.
+            name: The name of the circuit object.
+        Raises:
+            ValueError: If ``num_state_qubits`` is lower than 1.
+        """
+        super().__init__(num_state_qubits, name=name)
+        circuit = adder_ripple_c04(num_state_qubits, kind)
+
+        self.add_register(*circuit.qregs)
+        self.append(circuit.to_gate(), self.qubits)

qiskit/circuit/library/arithmetic/adders/draper_qft_adder.py

@@ -0,0 +1,129 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+"""Compute the sum of two qubit registers using QFT."""
+
+import numpy as np
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit.library.basis_change import QFT
+
+from .adder import Adder
+
+
+class DraperQFTAdder(Adder):
+    r"""A circuit that uses QFT to perform in-place addition on two qubit registers.
+
+    For registers with :math:`n` qubits, the QFT adder can perform addition modulo
+    :math:`2^n` (with ``kind="fixed"``) or ordinary addition by adding a carry qubits (with
+    ``kind="half"``).
+
+    As an example, a non-fixed_point QFT adder circuit that performs addition on two 2-qubit sized
+    registers is as follows:
+
+    .. code-block:: text
+
+         a_0:   ─────────■──────■────────────────────────■────────────────
+                         │      │                        │
+         a_1:   ─────────┼──────┼────────■──────■────────┼────────────────
+                ┌──────┐ │P(π)  │        │      │        │       ┌───────┐
+         b_0:   ┤0     ├─■──────┼────────┼──────┼────────┼───────┤0      ├
+                │      │        │P(π/2)  │P(π)  │        │       │       │
+         b_1:   ┤1 qft ├────────■────────■──────┼────────┼───────┤1 iqft ├
+                │      │                        │P(π/2)  │P(π/4) │       │
+        cout_0: ┤2     ├────────────────────────■────────■───────┤2      ├
+                └──────┘                                         └───────┘
+
+    .. seealso::
+
+        The following generic gate objects perform additions, like this circuit class,
+        but allow the compiler to select the optimal decomposition based on the context.
+        Specific implementations can be set via the :class:`.HLSConfig`, e.g. this
+        circuit can be chosen via ``Adder=["qft_d00"]``.
+
+        :class:`.ModularAdderGate`: A generic inplace adder, modulo :math:`2^n`. This
+            is functionally equivalent to ``kind="fixed"``.
+
+        :class:`.HalfAdderGate`: A generic inplace adder. This
+            is functionally equivalent to ``kind="half"``.
+
+    **References:**
+
+    [1] T. G. Draper, Addition on a Quantum Computer, 2000.
+    `arXiv:quant-ph/0008033 <https://arxiv.org/pdf/quant-ph/0008033.pdf>`_
+
+    [2] Ruiz-Perez et al., Quantum arithmetic with the Quantum Fourier Transform, 2017.
+    `arXiv:1411.5949 <https://arxiv.org/pdf/1411.5949.pdf>`_
+
+    [3] Vedral et al., Quantum Networks for Elementary Arithmetic Operations, 1995.
+    `arXiv:quant-ph/9511018 <https://arxiv.org/pdf/quant-ph/9511018.pdf>`_
+
+    """
+
+    def __init__(
+        self, num_state_qubits: int, kind: str = "fixed", name: str = "DraperQFTAdder"
+    ) -> None:
+        r"""
+        Args:
+            num_state_qubits: The number of qubits in either input register for
+                state :math:`|a\rangle` or :math:`|b\rangle`. The two input
+                registers must have the same number of qubits.
+            kind: The kind of adder, can be ``'half'`` for a half adder or
+                ``'fixed'`` for a fixed-sized adder. A half adder contains a carry-out to represent
+                the most-significant bit, but the fixed-sized adder doesn't and hence performs
+                addition modulo ``2 ** num_state_qubits``.
+            name: The name of the circuit object.
+        Raises:
+            ValueError: If ``num_state_qubits`` is lower than 1.
+        """
+        if kind == "full":
+            raise ValueError("The DraperQFTAdder only supports 'half' and 'fixed' as ``kind``.")
+
+        if num_state_qubits < 1:
+            raise ValueError("The number of qubits must be at least 1.")
+
+        super().__init__(num_state_qubits, name=name)
+
+        qr_a = QuantumRegister(num_state_qubits, name="a")
+        qr_b = QuantumRegister(num_state_qubits, name="b")
+        qr_list = [qr_a, qr_b]
+
+        if kind == "half":
+            qr_z = QuantumRegister(1, name="cout")
+            qr_list.append(qr_z)
+
+        # add registers
+        self.add_register(*qr_list)
+
+        # define register containing the sum and number of qubits for QFT circuit
+        qr_sum = qr_b[:] if kind == "fixed" else qr_b[:] + qr_z[:]
+        num_qubits_qft = num_state_qubits if kind == "fixed" else num_state_qubits + 1
+
+        circuit = QuantumCircuit(*self.qregs, name=name)
+
+        # build QFT adder circuit
+        circuit.append(QFT(num_qubits_qft, do_swaps=False).to_gate(), qr_sum[:])
+
+        for j in range(num_state_qubits):
+            for k in range(num_state_qubits - j):
+                lam = np.pi / (2**k)
+                circuit.cp(lam, qr_a[j], qr_b[j + k])
+
+        if kind == "half":
+            for j in range(num_state_qubits):
+                lam = np.pi / (2 ** (j + 1))
+                circuit.cp(lam, qr_a[num_state_qubits - j - 1], qr_z[0])
+
+        circuit.append(QFT(num_qubits_qft, do_swaps=False).inverse().to_gate(), qr_sum[:])
+
+        self.append(circuit.to_gate(), self.qubits)

qiskit/circuit/library/arithmetic/adders/vbe_ripple_carry_adder.py

@@ -0,0 +1,95 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+"""Compute the sum of two qubit registers using Classical Addition."""
+
+from __future__ import annotations
+from qiskit.synthesis.arithmetic import adder_ripple_v95
+from .adder import Adder
+
+
+class VBERippleCarryAdder(Adder):
+    r"""The VBE ripple carry adder [1].
+
+    This circuit performs inplace addition of two equally-sized quantum registers.
+    As an example, a classical adder circuit that performs full addition (i.e. including
+    a carry-in bit) on two 2-qubit sized registers is as follows:
+
+    .. code-block:: text
+
+                  ┌────────┐                       ┌───────────┐┌──────┐
+           cin_0: ┤0       ├───────────────────────┤0          ├┤0     ├
+                  │        │                       │           ││      │
+             a_0: ┤1       ├───────────────────────┤1          ├┤1     ├
+                  │        │┌────────┐     ┌──────┐│           ││  Sum │
+             a_1: ┤        ├┤1       ├──■──┤1     ├┤           ├┤      ├
+                  │        ││        │  │  │      ││           ││      │
+             b_0: ┤2 Carry ├┤        ├──┼──┤      ├┤2 Carry_dg ├┤2     ├
+                  │        ││        │┌─┴─┐│      ││           │└──────┘
+             b_1: ┤        ├┤2 Carry ├┤ X ├┤2 Sum ├┤           ├────────
+                  │        ││        │└───┘│      ││           │
+          cout_0: ┤        ├┤3       ├─────┤      ├┤           ├────────
+                  │        ││        │     │      ││           │
+        helper_0: ┤3       ├┤0       ├─────┤0     ├┤3          ├────────
+                  └────────┘└────────┘     └──────┘└───────────┘
+
+
+    Here *Carry* and *Sum* gates correspond to the gates introduced in [1].
+    *Carry_dg* correspond to the inverse of the *Carry* gate. Note that
+    in this implementation the input register qubits are ordered as all qubits from
+    the first input register, followed by all qubits from the second input register.
+    This is different ordering as compared to Figure 2 in [1], which leads to a different
+    drawing of the circuit.
+
+    .. seealso::
+
+        The following generic gate objects perform additions, like this circuit class,
+        but allow the compiler to select the optimal decomposition based on the context.
+        Specific implementations can be set via the :class:`.HLSConfig`, e.g. this circuit
+        can be chosen via ``Adder=["ripple_v95"]``.
+
+        :class:`.ModularAdderGate`: A generic inplace adder, modulo :math:`2^n`. This
+            is functionally equivalent to ``kind="fixed"``.
+
+        :class:`.HalfAdderGate`: A generic inplace adder. This
+            is functionally equivalent to ``kind="half"``.
+
+        :class:`.FullAdderGate`: A generic inplace adder, with a carry-in bit. This
+            is functionally equivalent to ``kind="full"``.
+
+    **References:**
+
+    [1] Vedral et al., Quantum Networks for Elementary Arithmetic Operations, 1995.
+    `arXiv:quant-ph/9511018 <https://arxiv.org/pdf/quant-ph/9511018.pdf>`_
+
+    """
+
+    def __init__(
+        self, num_state_qubits: int, kind: str = "full", name: str = "VBERippleCarryAdder"
+    ) -> None:
+        """
+        Args:
+            num_state_qubits: The size of the register.
+            kind: The kind of adder, can be ``'full'`` for a full adder, ``'half'`` for a half
+                adder, or ``'fixed'`` for a fixed-sized adder. A full adder includes both carry-in
+                and carry-out, a half only carry-out, and a fixed-sized adder neither carry-in
+                nor carry-out.
+            name: The name of the circuit.
+
+        Raises:
+            ValueError: If ``num_state_qubits`` is lower than 1.
+        """
+        super().__init__(num_state_qubits, name=name)
+        circuit = adder_ripple_v95(num_state_qubits, kind)
+
+        self.add_register(*circuit.qregs)
+        self.append(circuit.to_gate(), self.qubits)

qiskit/circuit/library/arithmetic/exact_reciprocal.py

@@ -0,0 +1,88 @@
+# 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
+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")
+        circuit = QuantumCircuit(qr_state, qr_flag, name=name)
+
+        angles = [0.0]
+        nl = 2 ** (num_state_qubits - 1) if 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(scaling * nl / i, 1, abs_tol=1e-5):
+                angles.append(np.pi)
+            elif scaling * nl / i < 1:
+                angles.append(2 * np.arcsin(scaling * nl / i))
+            else:
+                angles.append(0.0)
+
+        circuit.compose(
+            UCRYGate(angles), [qr_flag[0]] + qr_state[: len(qr_state) - neg_vals], inplace=True
+        )
+
+        if neg_vals:
+            circuit.compose(
+                UCRYGate([-theta for theta in angles]).control(),
+                [qr_state[-1]] + [qr_flag[0]] + qr_state[:-1],
+                inplace=True,
+            )
+            angles_neg = [0.0]
+            for i in range(1, nl):
+                if isclose(scaling * (-1) / (1 - i / nl), -1, abs_tol=1e-5):
+                    angles_neg.append(-np.pi)
+                elif np.abs(scaling * (-1) / (1 - i / nl)) < 1:
+                    angles_neg.append(2 * np.arcsin(scaling * (-1) / (1 - i / nl)))
+                else:
+                    angles_neg.append(0.0)
+            circuit.compose(
+                UCRYGate(angles_neg).control(),
+                [qr_state[-1]] + [qr_flag[0]] + qr_state[:-1],
+                inplace=True,
+            )
+
+        super().__init__(*circuit.qregs, name=name)
+        self.compose(circuit.to_gate(), qubits=self.qubits, inplace=True)