qiskit 2.0.3__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,103 @@
+# 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") -> 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``.
+
+    **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(), qr_sum[:])
+
+    return circuit

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

qiskit/synthesis/arithmetic/comparators/compare_2s.py

@@ -0,0 +1,112 @@
+# 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.
+
+"""Integer comparator based on 2s complement."""
+
+import math
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.library.boolean_logic.quantum_or import OrGate
+
+
+def synth_integer_comparator_2s(
+    num_state_qubits: int, value: int, geq: bool = True
+) -> QuantumCircuit:
+    r"""Implement an integer comparison based on 2s complement.
+
+    This is based on Appendix B of [1].
+
+    Args:
+        num_state_qubits: The number of qubits encoding the value to compare to.
+        value: The value to compare to.
+        geq: If ``True`` flip the target bit if the qubit state is :math:`\geq` than the value,
+            otherwise implement :math:`<`.
+
+    Returns:
+        A circuit implementing the integer comparator.
+
+    References:
+
+        [1] J. Gacon et al. "Quantum-enhanced simulation-based optimization"
+            `arXiv:2005.10780 <https://arxiv.org/abs/2005.10780>`__.
+    """
+    circuit = QuantumCircuit(2 * num_state_qubits)
+    qr_state = circuit.qubits[:num_state_qubits]
+    q_compare = circuit.qubits[num_state_qubits]
+    qr_ancilla = circuit.qubits[num_state_qubits + 1 :]
+
+    if value <= 0:  # condition always satisfied for non-positive values
+        if geq:  # otherwise the condition is never satisfied
+            circuit.x(q_compare)
+    # condition never satisfied for values larger than or equal to 2^n
+    elif value < pow(2, num_state_qubits):
+
+        if num_state_qubits > 1:
+            twos = _get_twos_complement(num_state_qubits, value)
+            for i in range(num_state_qubits):
+                if i == 0:
+                    if twos[i] == 1:
+                        circuit.cx(qr_state[i], qr_ancilla[i])
+                elif i < num_state_qubits - 1:
+                    if twos[i] == 1:
+                        circuit.append(OrGate(2), [qr_state[i], qr_ancilla[i - 1], qr_ancilla[i]])
+                    else:
+                        circuit.ccx(qr_state[i], qr_ancilla[i - 1], qr_ancilla[i])
+                else:
+                    if twos[i] == 1:
+                        # OR needs the result argument as qubit not register, thus
+                        # access the index [0]
+                        circuit.append(OrGate(2), [qr_state[i], qr_ancilla[i - 1], q_compare])
+                    else:
+                        circuit.ccx(qr_state[i], qr_ancilla[i - 1], q_compare)
+
+            # flip result bit if geq flag is false
+            if not geq:
+                circuit.x(q_compare)
+
+            # uncompute ancillas state
+            for i in reversed(range(num_state_qubits - 1)):
+                if i == 0:
+                    if twos[i] == 1:
+                        circuit.cx(qr_state[i], qr_ancilla[i])
+                else:
+                    if twos[i] == 1:
+                        circuit.append(OrGate(2), [qr_state[i], qr_ancilla[i - 1], qr_ancilla[i]])
+                    else:
+                        circuit.ccx(qr_state[i], qr_ancilla[i - 1], qr_ancilla[i])
+        else:
+
+            # num_state_qubits == 1 and value == 1:
+            circuit.cx(qr_state[0], q_compare)
+
+            # flip result bit if geq flag is false
+            if not geq:
+                circuit.x(q_compare)
+
+    else:
+        if not geq:  # otherwise the condition is never satisfied
+            circuit.x(q_compare)
+
+    return circuit
+
+
+def _get_twos_complement(num_bits: int, value: int) -> list[int]:
+    """Returns the 2's complement of ``self.value`` as array.
+
+    Returns:
+            The 2's complement of ``self.value``.
+    """
+    twos_complement = pow(2, num_bits) - math.ceil(value)
+    twos_complement = f"{twos_complement:b}".rjust(num_bits, "0")
+    twos_complement = [
+        1 if twos_complement[i] == "1" else 0 for i in reversed(range(len(twos_complement)))
+    ]
+    return twos_complement

qiskit/synthesis/arithmetic/comparators/compare_greedy.py

@@ -0,0 +1,66 @@
+# 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.
+
+"""Integer comparator based on an exponential number of multi-controlled gates."""
+
+import numpy as np
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+
+
+def synth_integer_comparator_greedy(
+    num_state_qubits: int, value: int, geq: bool = True
+) -> QuantumCircuit:
+    r"""Implement an integer comparison based on value-by-value comparison.
+
+    For ``value`` smaller than ``2 ** (num_state_qubits - 1)`` this circuit implements
+    ``value`` multi-controlled gates with control states 0, 1, ..., ``value - 1``, such that
+    the target qubit is flipped if the qubit state represents any of the allowed values.
+    For ``value`` larger than that, ``geq`` is flipped. This implementation can
+    require an exponential number of gates. If auxiliary qubits are available, the implementation
+    provided by :func:`.synth_integer_comparator_2s` is more efficient.
+
+    Args:
+        num_state_qubits: The number of qubits encoding the value to compare to.
+        value: The value to compare to.
+        geq: If ``True`` flip the target bit if the qubit state is :math:`\geq` than the value,
+            otherwise implement :math:`<`.
+
+    Returns:
+        A circuit implementing the integer comparator.
+
+    """
+    circuit = QuantumCircuit(num_state_qubits + 1)
+
+    if value <= 0:  # condition always satisfied for non-positive values
+        if geq:  # otherwise the condition is never satisfied
+            circuit.x(num_state_qubits)
+
+        return circuit
+
+    # make sure to always choose the comparison where we have to place less than
+    # (2 ** n)/2 MCX gates
+    value = int(np.ceil(value))
+    if (value < 2 ** (num_state_qubits - 1) and geq) or (
+        value > 2 ** (num_state_qubits - 1) and not geq
+    ):
+        geq = not geq
+        circuit.x(num_state_qubits)
+
+    if geq:
+        accepted_values = range(value, 2**num_state_qubits)
+    else:
+        accepted_values = range(0, value)
+
+    for accepted_value in accepted_values:
+        circuit.mcx(list(range(num_state_qubits)), num_state_qubits, ctrl_state=accepted_value)
+
+    return circuit

qiskit/synthesis/arithmetic/multipliers/__init__.py

@@ -0,0 +1,16 @@
+# 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 multiplier circuit library."""
+
+from .hrs_cumulative_multiplier import multiplier_cumulative_h18
+from .rg_qft_multiplier import multiplier_qft_r17