qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/synthesis/arithmetic/adders/cdkm_ripple_carry_adder.py

@@ -0,0 +1,154 @@
+# 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.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit import QuantumRegister, AncillaRegister
+
+
+def adder_ripple_c04(num_state_qubits: int, kind: str = "half") -> QuantumCircuit:
+    r"""A ripple-carry circuit to perform in-place addition on two qubit registers.
+
+    This circuit uses :math:`2n + O(1)` CCX gates and :math:`5n + O(1)` CX gates,
+    at a depth of :math:`2n + O(1)` [1]. The constant depends on the kind
+    of adder implemented.
+
+    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:
+
+    .. parsed-literal::
+
+                ┌──────┐                                     ┌──────┐
+         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
+
+    .. parsed-literal::
+
+                ┌──────┐┌──────┐                ┌──────┐┌──────┐
+           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.
+
+    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.
+
+    Raises:
+        ValueError: If ``num_state_qubits`` is lower than 1.
+
+    **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>`_
+
+    """
+    if num_state_qubits < 1:
+        raise ValueError("The number of qubits must be at least 1.")
+
+    circuit = QuantumCircuit()
+
+    if kind == "full":
+        qr_c = QuantumRegister(1, name="cin")
+        circuit.add_register(qr_c)
+    else:
+        qr_c = AncillaRegister(1, name="help")
+
+    qr_a = QuantumRegister(num_state_qubits, name="a")
+    qr_b = QuantumRegister(num_state_qubits, name="b")
+    circuit.add_register(qr_a, qr_b)
+
+    if kind in ["full", "half"]:
+        qr_z = QuantumRegister(1, name="cout")
+        circuit.add_register(qr_z)
+
+    if kind != "full":
+        circuit.add_register(qr_c)
+
+    # build carry circuit for majority of 3 bits in-place
+    # corresponds to MAJ gate in [1]
+    qc_maj = QuantumCircuit(3, name="MAJ")
+    qc_maj.cx(0, 1)
+    qc_maj.cx(0, 2)
+    qc_maj.ccx(2, 1, 0)
+    maj_gate = qc_maj.to_gate()
+
+    # build circuit for reversing carry operation
+    # corresponds to UMA gate in [1]
+    qc_uma = QuantumCircuit(3, name="UMA")
+    qc_uma.ccx(2, 1, 0)
+    qc_uma.cx(0, 2)
+    qc_uma.cx(2, 1)
+    uma_gate = qc_uma.to_gate()
+
+    # build ripple-carry adder circuit
+    circuit.append(maj_gate, [qr_a[0], qr_b[0], qr_c[0]])
+
+    for i in range(num_state_qubits - 1):
+        circuit.append(maj_gate, [qr_a[i + 1], qr_b[i + 1], qr_a[i]])
+
+    if kind in ["full", "half"]:
+        circuit.cx(qr_a[-1], qr_z[0])
+
+    for i in reversed(range(num_state_qubits - 1)):
+        circuit.append(uma_gate, [qr_a[i + 1], qr_b[i + 1], qr_a[i]])
+
+    circuit.append(uma_gate, [qr_a[0], qr_b[0], qr_c[0]])
+
+    return circuit

qiskit/synthesis/arithmetic/adders/draper_qft_adder.py

@@ -0,0 +1,107 @@
+# 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 QFTGate
+
+
+def adder_qft_d00(
+    num_state_qubits: int, kind: str = "half", annotated: bool = False
+) -> QuantumCircuit:
+    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"``). The fixed adder uses :math:`(3n^2 - n)/2` :class:`.CPhaseGate` operators,
+    with an additional :math:`n` for the half adder.
+
+    As an example, a non-fixed_point QFT adder circuit that performs addition on two 2-qubit sized
+    registers is as follows:
+
+    .. parsed-literal::
+
+        a_0: ─────────■──────■────────■──────────────────────────────────
+                      │      │        │
+        a_1: ─────────┼──────┼────────┼────────■──────■──────────────────
+             ┌──────┐ │      │        │P(π/4)  │      │P(π/2) ┌─────────┐
+        b_0: ┤0     ├─┼──────┼────────■────────┼──────■───────┤0        ├
+             │      │ │      │P(π/2)           │P(π)          │         │
+        b_1: ┤1 Qft ├─┼──────■─────────────────■──────────────┤1 qft_dg ├
+             │      │ │P(π)                                   │         │
+       cout: ┤2     ├─■───────────────────────────────────────┤2        ├
+             └──────┘                                         └─────────┘
+
+    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``.
+        annotated: If ``True``, creates appropriate control and inverse operations as
+            ``AnnotatedOperation`` objects.
+
+    **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>`_
+
+    """
+
+    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.")
+
+    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
+    circuit = QuantumCircuit(*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_sum = num_state_qubits if kind == "fixed" else num_state_qubits + 1
+
+    # build QFT adder circuit
+    qft = QFTGate(num_sum)
+    circuit.append(qft, qr_sum[:])
+
+    for j in range(num_state_qubits):
+        for k in range(num_sum - j):
+            lam = np.pi / (2**k)
+            # note: if we were able to remove the final swaps from the QFTGate, we could
+            # simply use qr_sum[(j + k)] here and avoid synthesizing two swap networks, which
+            # can be elided and cancelled by the compiler
+            circuit.cp(lam, qr_a[j], qr_sum[~(j + k)])
+
+    circuit.append(qft.inverse(annotated=annotated), qr_sum[:])
+
+    return circuit

qiskit/synthesis/arithmetic/adders/rv_ripple_carry_adder.py

@@ -0,0 +1,156 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2025.
+#
+# 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 without any ancillary qubits."""
+
+from __future__ import annotations
+from math import ceil
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit import QuantumRegister
+
+
+def _mcx_ladder(n_mcx: int, alpha: int):
+    r"""Implements a log-depth MCX ladder circuit as outlined in Algorithm 2 of [1]. The circuit
+    relies on log-depth decomposition of MCX gate that uses conditionally clean ancillae of [2].
+    Selecting :math:`\alpha=1` creates a CX ladder as shown in Fig. 2 of [1] and selecting
+    :math:`\alpha=2` creates a Toffoli ladder as shown in Fig. 3 of [1].
+
+    Args:
+        n_mcx: Number of MCX gates in the ladder.
+        alpha: Number of controls per MCX gate.
+
+    Returns:
+        QuantumCircuit: The MCX ladder circuit.
+
+    References:
+        1. Remaud and Vandaele, Ancilla-free Quantum Adder with Sublinear Depth, 2025.
+        `arXiv:2501.16802 <https://arxiv.org/abs/2501.16802>`__
+
+        2. Khattar and Gidney, Rise of conditionally clean ancillae for optimizing quantum circuits
+        `arXiv:2407.17966 <https://arxiv.org/abs/2407.17966>`__
+    """
+
+    def helper(qubit_indices, alphas) -> list[list[int]]:
+        k = len(alphas) + 1
+        if k == 1:
+            return []
+        if k == 2:
+            return [qubit_indices[: alphas[0] + 1]]
+
+        x_bar = [qubit_indices[alphas[0]]]
+        alpha_bar = []
+        right_pairs = [qubit_indices[0 : alphas[0] + 1]]
+        left_pairs = [qubit_indices[alphas[k - 3] : alphas[-1] + 1]]
+
+        for i in range(1, ceil(k / 2) - 1):
+            left_pairs += [qubit_indices[alphas[2 * i - 2] : alphas[2 * i - 1] + 1]]
+            right_pairs += [qubit_indices[alphas[2 * i - 1] : alphas[2 * i] + 1]]
+            x_bar += (
+                qubit_indices[alphas[2 * i - 2] + 1 : alphas[2 * i - 1]]
+                + qubit_indices[alphas[2 * i - 1] + 1 : alphas[2 * i] + 1]
+            )
+            alpha_bar.append(alphas[2 * i] - alphas[0] - i)
+
+        if k % 2 == 0:
+            x_bar += qubit_indices[alphas[k - 4] + 1 : alphas[k - 3] + 1]
+            alpha_bar.append(alphas[k - 3] - alphas[0] - int(k / 2) + 2)
+
+        return left_pairs + helper(x_bar, alpha_bar) + right_pairs
+
+    n = n_mcx * alpha + 1
+    qc = QuantumCircuit(n)
+    qubit_indices, alphas = list(range(n)), list(range(alpha, n, alpha))
+    mcxs = helper(qubit_indices, alphas)
+    for mcx in mcxs:
+        qc.mcx(mcx[:-1], mcx[-1])
+
+    return qc
+
+
+def adder_ripple_r25(num_qubits: int) -> QuantumCircuit:
+    # pylint: disable=line-too-long
+    r"""The RV ripple carry adder [1].
+    Construct an ancilla-free quantum adder circuit with sublinear depth based on the RV ripple-carry
+    adder shown in [1]. The implementation has a depth of :math:`O(\log^2 n)` and uses
+    math:`O(n \log n)` gates.
+
+    As an example, a ripple-carry adder circuit that performs addition on two 4-qubit sized
+    registers is as follows:
+
+    .. parsed-literal::
+
+                                       ┌───────────┐                    ┌────────┐
+         a_0: ─────────────────────────┤0          ├────────────────────┤0       ├───────────────■─────────────────
+                             ┌────────┐│           │                    │        │┌───────────┐  │
+         a_1: ──■────────────┤0       ├┤2          ├──■─────────────────┤2       ├┤0          ├──┼────■────────────
+                │            │        ││           │  │                 │        ││           │  │    │
+         a_2: ──┼────■───────┤1       ├┤4          ├──┼────■────────────┤4       ├┤1 LAD_1_dg ├──┼────┼────■───────
+                │    │       │        ││           │  │    │            │        ││           │  │    │    │
+         a_3: ──┼────┼────■──┤2       ├┤6          ├──┼────┼────■───────┤6 LAD_2 ├┤2          ├──┼────┼────┼────■──
+                │    │    │  │        ││           │  │    │    │       │        │└───────────┘┌─┴─┐  │    │    │
+         b_0: ──┼────┼────┼──┤        ├┤1 LAD_2_dg ├──┼────┼────┼───────┤1       ├─────────────┤ X ├──┼────┼────┼──
+              ┌─┴─┐  │    │  │  LAD_1 ││           │┌─┴─┐  │    │  ┌───┐│        │    ┌───┐    └───┘┌─┴─┐  │    │
+         b_1: ┤ X ├──┼────┼──┤        ├┤3          ├┤ X ├──┼────┼──┤ X ├┤3       ├────┤ X ├─────────┤ X ├──┼────┼──
+              └───┘┌─┴─┐  │  │        ││           │└───┘┌─┴─┐  │  ├───┤│        │    ├───┤         └───┘┌─┴─┐  │
+         b_2: ─────┤ X ├──┼──┤        ├┤5          ├─────┤ X ├──┼──┤ X ├┤5       ├────┤ X ├──────────────┤ X ├──┼──
+                   └───┘┌─┴─┐│        ││           │     └───┘┌─┴─┐└───┘└────────┘    └───┘              └───┘┌─┴─┐
+         b_3: ──────────┤ X ├┤        ├┤7          ├──────────┤ X ├───────────────────────────────────────────┤ X ├
+                        └───┘│        ││           │          └───┘                                           └───┘
+        cout: ───────────────┤3       ├┤8          ├───────────────────────────────────────────────────────────────
+                             └────────┘└───────────┘
+
+    Here *LAD_1* and *LAD_2* are the CX and CCX ladders respectively 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.
+
+    Args:
+        num_qubits: The size of the register.
+
+    Returns:
+        The quantum circuit implementing the RV ripple carry adder.
+
+    Raises:
+        ValueError: If ``num_state_qubits`` is lower than 1.
+
+    **References:**
+
+    1. Remaud and Vandaele, Ancilla-free Quantum Adder with Sublinear Depth, 2025.
+    `arXiv:2501.16802 <https://arxiv.org/abs/2501.16802>`__
+
+    """
+
+    if num_qubits < 1:
+        raise ValueError("The number of qubits must be at least 1.")
+
+    qr_a = QuantumRegister(num_qubits, "a")
+    qr_b = QuantumRegister(num_qubits, "b")
+    qr_z = QuantumRegister(1, "cout")
+    qc = QuantumCircuit(qr_a, qr_b, qr_z)
+
+    if num_qubits == 1:
+        qc.ccx(qr_a[0], qr_b[0], qr_z[0])
+        qc.cx(qr_a[0], qr_b[0])
+        return qc
+
+    ab_interleaved = [q for pair in zip(qr_a, qr_b) for q in pair]
+
+    qc.cx(qr_a[1:], qr_b[1:])
+    qc.compose(_mcx_ladder(num_qubits - 1, 1), qr_a[1:] + qr_z[:], inplace=True)
+    qc.compose(_mcx_ladder(num_qubits, 2).inverse(), ab_interleaved + qr_z[:], inplace=True)
+    qc.cx(qr_a[1:], qr_b[1:])
+    qc.x(qr_b[1 : max(2, num_qubits - 1)])
+    qc.compose(_mcx_ladder(num_qubits - 1, 2), ab_interleaved[:-1], inplace=True)
+    qc.x(qr_b[1 : max(2, num_qubits - 1)])
+    qc.compose(_mcx_ladder(num_qubits - 2, 1).inverse(), qr_a[1:], inplace=True)
+    qc.cx(qr_a, qr_b)
+
+    return qc

qiskit/synthesis/arithmetic/adders/vbe_ripple_carry_adder.py

@@ -0,0 +1,161 @@
+# 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.circuit import Bit
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit import QuantumRegister, AncillaRegister
+
+
+def adder_ripple_v95(num_state_qubits: int, kind: str = "half") -> QuantumCircuit:
+    r"""The VBE ripple carry adder [1].
+
+    This method uses :math:`4n + O(1)` CCX gates and :math:`4n + 1` CX gates at a depth
+    of :math:`6n - 2` [2].
+
+    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:
+
+    .. parsed-literal::
+
+                  ┌────────┐                       ┌───────────┐┌──────┐
+           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.
+
+    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.
+
+    Raises:
+        ValueError: If ``num_state_qubits`` is lower than 1.
+
+    **References:**
+
+    [1] Vedral et al., Quantum Networks for Elementary Arithmetic Operations, 1995.
+    `arXiv:quant-ph/9511018 <https://arxiv.org/pdf/quant-ph/9511018.pdf>`_
+
+    [2] Cuccaro et al., A new quantum ripple-carry addition circuit, 2004.
+    `arXiv:quant-ph/0410184 <https://arxiv.org/pdf/quant-ph/0410184.pdf>`_
+
+    """
+    if num_state_qubits < 1:
+        raise ValueError("The number of qubits must be at least 1.")
+
+    # define the input registers
+    registers: list[QuantumRegister | list[Bit]] = []
+    if kind == "full":
+        qr_cin = QuantumRegister(1, name="cin")
+        registers.append(qr_cin)
+    else:
+        qr_cin = QuantumRegister(0)
+
+    qr_a = QuantumRegister(num_state_qubits, name="a")
+    qr_b = QuantumRegister(num_state_qubits, name="b")
+
+    registers += [qr_a, qr_b]
+
+    if kind in ["half", "full"]:
+        qr_cout = QuantumRegister(1, name="cout")
+        registers.append(qr_cout)
+    else:
+        qr_cout = QuantumRegister(0)
+
+    if num_state_qubits > 1:
+        qr_help = AncillaRegister(num_state_qubits - 1, name="helper")
+        registers.append(qr_help)
+    else:
+        qr_help = AncillaRegister(0)
+
+    circuit = QuantumCircuit(*registers)
+
+    # the code is simplified a lot if we create a list of all carries and helpers
+    carries = qr_cin[:] + qr_help[:] + qr_cout[:]
+
+    # corresponds to Carry gate in [1]
+    qc_carry = QuantumCircuit(4, name="Carry")
+    qc_carry.ccx(1, 2, 3)
+    qc_carry.cx(1, 2)
+    qc_carry.ccx(0, 2, 3)
+    carry_gate = qc_carry.to_gate()
+    carry_gate_dg = carry_gate.inverse()
+
+    # corresponds to Sum gate in [1]
+    qc_sum = QuantumCircuit(3, name="Sum")
+    qc_sum.cx(1, 2)
+    qc_sum.cx(0, 2)
+    sum_gate = qc_sum.to_gate()
+
+    # handle all cases for the first qubits, depending on whether cin is available
+    i = 0
+    if kind == "half":
+        i += 1
+        circuit.ccx(qr_a[0], qr_b[0], carries[0])
+    elif kind == "fixed":
+        i += 1
+        if num_state_qubits == 1:
+            circuit.cx(qr_a[0], qr_b[0])
+        else:
+            circuit.ccx(qr_a[0], qr_b[0], carries[0])
+
+    for inp, out in zip(carries[:-1], carries[1:]):
+        circuit.append(carry_gate, [inp, qr_a[i], qr_b[i], out])
+        i += 1
+
+    if kind in ["full", "half"]:  # final CX (cancels for the 'fixed' case)
+        circuit.cx(qr_a[-1], qr_b[-1])
+
+    if len(carries) > 1:
+        circuit.append(sum_gate, [carries[-2], qr_a[-1], qr_b[-1]])
+
+    i -= 2
+    for j, (inp, out) in enumerate(zip(reversed(carries[:-1]), reversed(carries[1:]))):
+        if j == 0:
+            if kind == "fixed":
+                i += 1
+            else:
+                continue
+        circuit.append(carry_gate_dg, [inp, qr_a[i], qr_b[i], out])
+        circuit.append(sum_gate, [inp, qr_a[i], qr_b[i]])
+        i -= 1
+
+    if kind in ["half", "fixed"] and num_state_qubits > 1:
+        circuit.ccx(qr_a[0], qr_b[0], carries[0])
+        circuit.cx(qr_a[0], qr_b[0])
+
+    return circuit

qiskit/synthesis/arithmetic/comparators/__init__.py

@@ -0,0 +1,16 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2024.
+#
+# 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.
+
+"""Comparator synthesis algorithms."""
+
+from .compare_2s import synth_integer_comparator_2s
+from .compare_greedy import synth_integer_comparator_greedy