qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/circuit/library/arithmetic/__init__.py

@@ -0,0 +1,40 @@
+# 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.
+
+"""The arithmetic circuit library."""
+
+from .functional_pauli_rotations import FunctionalPauliRotations
+from .integer_comparator import IntegerComparator, IntegerComparatorGate
+from .linear_pauli_rotations import LinearPauliRotations, LinearPauliRotationsGate
+from .piecewise_linear_pauli_rotations import (
+    PiecewiseLinearPauliRotations,
+    PiecewiseLinearPauliRotationsGate,
+)
+from .piecewise_polynomial_pauli_rotations import (
+    PiecewisePolynomialPauliRotations,
+    PiecewisePolynomialPauliRotationsGate,
+)
+from .polynomial_pauli_rotations import PolynomialPauliRotations, PolynomialPauliRotationsGate
+from .weighted_adder import WeightedAdder, WeightedSumGate
+from .quadratic_form import QuadraticForm, QuadraticFormGate
+from .linear_amplitude_function import LinearAmplitudeFunction, LinearAmplitudeFunctionGate
+from .piecewise_chebyshev import PiecewiseChebyshev, PiecewiseChebyshevGate
+from .exact_reciprocal import ExactReciprocal, ExactReciprocalGate
+from .adders import (
+    VBERippleCarryAdder,
+    CDKMRippleCarryAdder,
+    DraperQFTAdder,
+    ModularAdderGate,
+    HalfAdderGate,
+    FullAdderGate,
+)
+from .multipliers import HRSCumulativeMultiplier, RGQFTMultiplier, MultiplierGate

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

@@ -0,0 +1,18 @@
+# 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.
+
+"""The adder circuit library."""
+
+from .cdkm_ripple_carry_adder import CDKMRippleCarryAdder
+from .draper_qft_adder import DraperQFTAdder
+from .vbe_ripple_carry_adder import VBERippleCarryAdder
+from .adder import ModularAdderGate, HalfAdderGate, FullAdderGate

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

@@ -0,0 +1,235 @@
+# 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="2.1",
+        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://quantum.cloud.ibm.com/docs/api/qiskit/synthesis.",
+        ),
+        removal_timeline="in Qiskit 3.0",
+    )
+    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
+
+    def _define(self):
+        """Populates self.definition with some decomposition of this gate."""
+        from qiskit.synthesis.arithmetic import adder_ripple_r25
+
+        # This particular decomposition does not use any ancilla qubits.
+        # Note that the transpiler may choose a different decomposition
+        # based on the number of ancilla qubits available.
+        self.definition = adder_ripple_r25(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
+
+    def _define(self):
+        """Populates self.definition with some decomposition of this gate."""
+        from qiskit.synthesis.arithmetic import adder_qft_d00
+
+        # This particular decomposition does not use any ancilla qubits.
+        # Note that the transpiler may choose a different decomposition
+        # based on the number of ancilla qubits available.
+        self.definition = adder_qft_d00(self.num_state_qubits, kind="fixed")
+
+
+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
+
+    def _define(self):
+        """Populates self.definition with a decomposition of this gate."""
+        from qiskit.synthesis.arithmetic import adder_ripple_c04
+
+        # In the case of a full adder, this method does not use any ancilla qubits
+        self.definition = adder_ripple_c04(self.num_state_qubits, kind="full")

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:`.AdderGate`: 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 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:`.AdderGate`: 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:`.AdderGate`: 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)