qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

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

qiskit/synthesis/arithmetic/multipliers/hrs_cumulative_multiplier.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 product of two qubit registers using classical multiplication approach."""
+
+from __future__ import annotations
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit import QuantumRegister
+
+
+def multiplier_cumulative_h18(
+    num_state_qubits: int, num_result_qubits: int | None = None
+) -> QuantumCircuit:
+    r"""A multiplication circuit to store product of two input registers out-of-place.
+
+    The circuit uses the approach from Ref. [1]. As an example, a multiplier circuit that
+    performs a non-modular multiplication on two 3-qubit sized registers is:
+
+    .. plot::
+        :alt: Circuit diagram output by the previous code.
+        :include-source:
+
+        from qiskit.synthesis.arithmetic import multiplier_cumulative_h18
+
+        num_state_qubits = 3
+        circuit = multiplier_cumulative_h18(num_state_qubits)
+        circuit.draw("mpl")
+
+    Multiplication in this circuit is implemented in a classical approach by performing
+    a series of shifted additions using one of the input registers while the qubits
+    from the other input register act as control qubits for the adders.
+
+    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.
+        num_result_qubits: The number of result qubits to limit the output to.
+            If number of result qubits is :math:`n`, multiplication modulo :math:`2^n` is performed
+            to limit the output to the specified number of qubits. Default
+            value is ``2 * num_state_qubits`` to represent any possible
+            result from the multiplication of the two inputs.
+
+    Raises:
+        ValueError: If ``num_result_qubits`` is given and not valid, meaning not
+            in ``[num_state_qubits, 2 * num_state_qubits]``.
+
+    **References:**
+
+    [1] Häner et al., Optimizing Quantum Circuits for Arithmetic, 2018.
+    `arXiv:1805.12445 <https://arxiv.org/pdf/1805.12445.pdf>`_
+
+    """
+    if num_result_qubits is None:
+        num_result_qubits = 2 * num_state_qubits
+    elif num_result_qubits < num_state_qubits or num_result_qubits > 2 * num_state_qubits:
+        raise ValueError(
+            f"num_result_qubits ({num_result_qubits}) must be in between num_state_qubits "
+            f"({num_state_qubits}) and 2 * num_state_qubits ({2 * num_state_qubits})"
+        )
+
+    # define the registers
+    qr_a = QuantumRegister(num_state_qubits, name="a")
+    qr_b = QuantumRegister(num_state_qubits, name="b")
+    qr_out = QuantumRegister(num_result_qubits, name="out")
+
+    circuit = QuantumCircuit(qr_a, qr_b, qr_out)
+
+    # prepare adder as controlled gate
+    # pylint: disable=cyclic-import
+    from qiskit.circuit.library.arithmetic import HalfAdderGate, ModularAdderGate
+
+    adder = HalfAdderGate(num_state_qubits)
+    controlled_adder = adder.control(annotated=True)
+
+    # build multiplication circuit
+    for i in range(num_state_qubits):
+        excess_qubits = max(0, num_state_qubits + i + 1 - num_result_qubits)
+        if excess_qubits == 0:
+            num_adder_qubits = num_state_qubits
+            this_controlled = controlled_adder
+        else:
+            num_adder_qubits = num_state_qubits - excess_qubits + 1
+            modular = ModularAdderGate(num_adder_qubits)
+            this_controlled = modular.control(annotated=True)
+
+        qr_list = (
+            [qr_a[i]]
+            + qr_b[:num_adder_qubits]
+            + qr_out[i : num_state_qubits + i + 1 - excess_qubits]
+        )
+        circuit.append(this_controlled, qr_list)
+
+    return circuit

qiskit/synthesis/arithmetic/multipliers/rg_qft_multiplier.py

@@ -0,0 +1,100 @@
+# 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 product of two qubit registers using QFT."""
+
+from __future__ import annotations
+
+import numpy as np
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit import QuantumRegister
+from qiskit.circuit.library.standard_gates import PhaseGate
+from qiskit.circuit.library.basis_change import QFTGate
+
+
+def multiplier_qft_r17(
+    num_state_qubits: int, num_result_qubits: int | None = None
+) -> QuantumCircuit:
+    r"""A QFT multiplication circuit to store product of two input registers out-of-place.
+
+    Multiplication in this circuit is implemented using the procedure of Fig. 3 in [1], where
+    weighted sum rotations are implemented as given in Fig. 5 in [1]. QFT is used on the output
+    register and is followed by rotations controlled by input registers. The rotations
+    transform the state into the product of two input registers in QFT base, which is
+    reverted from QFT base using inverse QFT.
+    For example, on 3 state qubits, a full multiplier is given by:
+
+    .. plot::
+        :alt: Circuit diagram output by the previous code.
+        :include-source:
+
+        from qiskit.synthesis.arithmetic import multiplier_qft_r17
+
+        num_state_qubits = 3
+        circuit = multiplier_qft_r17(num_state_qubits)
+        circuit.draw("mpl")
+
+    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.
+        num_result_qubits: The number of result qubits to limit the output to.
+            If number of result qubits is :math:`n`, multiplication modulo :math:`2^n` is performed
+            to limit the output to the specified number of qubits. Default
+            value is ``2 * num_state_qubits`` to represent any possible
+            result from the multiplication of the two inputs.
+
+    Raises:
+        ValueError: If ``num_result_qubits`` is given and not valid, meaning not
+            in ``[num_state_qubits, 2 * num_state_qubits]``.
+
+    **References:**
+
+    [1] Ruiz-Perez et al., Quantum arithmetic with the Quantum Fourier Transform, 2017.
+    `arXiv:1411.5949 <https://arxiv.org/pdf/1411.5949.pdf>`_
+
+    """
+    # define the registers
+    if num_result_qubits is None:
+        num_result_qubits = 2 * num_state_qubits
+    elif num_result_qubits < num_state_qubits or num_result_qubits > 2 * num_state_qubits:
+        raise ValueError(
+            f"num_result_qubits ({num_result_qubits}) must be in between num_state_qubits "
+            f"({num_state_qubits}) and 2 * num_state_qubits ({2 * num_state_qubits})"
+        )
+
+    qr_a = QuantumRegister(num_state_qubits, name="a")
+    qr_b = QuantumRegister(num_state_qubits, name="b")
+    qr_out = QuantumRegister(num_result_qubits, name="out")
+
+    # build multiplication circuit
+    circuit = QuantumCircuit(qr_a, qr_b, qr_out)
+    qft = QFTGate(num_result_qubits)
+
+    circuit.append(qft, qr_out[:])
+
+    for j in range(1, num_state_qubits + 1):
+        for i in range(1, num_state_qubits + 1):
+            for k in range(1, num_result_qubits + 1):
+                lam = (2 * np.pi) / (2 ** (i + j + k - 2 * num_state_qubits))
+
+                # note: if we can synthesize the QFT without swaps, we can implement this circuit
+                # more efficiently and just apply phase gate on qr_out[(k - 1)] instead
+                circuit.append(
+                    PhaseGate(lam).control(2),
+                    [qr_a[num_state_qubits - j], qr_b[num_state_qubits - i], qr_out[~(k - 1)]],
+                )
+
+    circuit.append(qft.inverse(), qr_out[:])
+
+    return circuit

qiskit/synthesis/arithmetic/weighted_sum.py

@@ -0,0 +1,155 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+"""Implement a integer-weighted sum over a set of qubits."""
+
+from __future__ import annotations
+
+import typing
+import numpy as np
+from qiskit.circuit.quantumcircuit import QuantumCircuit, QuantumRegister, AncillaRegister
+from qiskit.synthesis.multi_controlled import synth_mcx_n_clean_m15
+
+if typing.TYPE_CHECKING:
+    from qiskit.circuit.library import WeightedSumGate
+
+
+def synth_weighted_sum_carry(weighted_sum: WeightedSumGate) -> QuantumCircuit:
+    """Synthesize a weighted sum gate, by the number of state qubits and the qubit weights.
+
+    This method is described in Appendix A of [1].
+
+    Reference:
+
+        [1] Stamatopoulos et al. Option Pricing using Quantum Computers (2020)
+            `Quantum 4, 291 <https://doi.org/10.22331/q-2020-07-06-291>`__
+    """
+
+    num_sum_qubits = weighted_sum.num_sum_qubits
+    num_state_qubits = weighted_sum.num_qubits - num_sum_qubits
+
+    num_carry_qubits = num_sum_qubits - 1
+    num_control_qubits = int(num_sum_qubits > 2)
+
+    qr_state = QuantumRegister(num_state_qubits, "state")
+    qr_sum = QuantumRegister(num_sum_qubits, "sum")
+    qr_carry = AncillaRegister(num_carry_qubits, "carry")
+    qr_control = AncillaRegister(num_control_qubits, "control")
+    circuit = QuantumCircuit(qr_state, qr_sum, qr_carry, qr_control)
+
+    # we use a MCX v-chain decomposition of C3X here, synthesize it once and re-use
+    c3x = synth_mcx_n_clean_m15(3)
+
+    # loop over state qubits and corresponding weights
+    weights = weighted_sum.params
+    for i, weight in enumerate(weights):
+        # only act if non-trivial weight
+        if np.isclose(weight, 0):
+            continue
+
+        # get state control qubit
+        q_state = qr_state[i]
+
+        # get bit representation of current weight
+        weight_binary = f"{int(weight):b}".rjust(num_sum_qubits, "0")[::-1]
+
+        # loop over bits of current weight and add them to sum and carry registers
+        for j, bit in enumerate(weight_binary):
+            if bit == "1":
+                if num_sum_qubits == 1:
+                    circuit.cx(q_state, qr_sum[j])
+                elif j == 0:
+                    # compute (q_sum[0] + 1) into (q_sum[0], q_carry[0])
+                    # - controlled by q_state[i]
+                    circuit.ccx(q_state, qr_sum[j], qr_carry[j])
+                    circuit.cx(q_state, qr_sum[j])
+                elif j == num_sum_qubits - 1:
+                    # compute (q_sum[j] + q_carry[j-1] + 1) into (q_sum[j])
+                    # - controlled by q_state[i] / last qubit,
+                    # no carry needed by construction
+                    circuit.cx(q_state, qr_sum[j])
+                    circuit.ccx(q_state, qr_carry[j - 1], qr_sum[j])
+                else:
+                    # compute (q_sum[j] + q_carry[j-1] + 1) into (q_sum[j], q_carry[j])
+                    # - controlled by q_state[i]
+                    circuit.x(qr_sum[j])
+                    circuit.x(qr_carry[j - 1])
+                    circuit.compose(
+                        c3x,
+                        [q_state, qr_sum[j], qr_carry[j - 1], qr_carry[j]] + qr_control[:],
+                        inplace=True,
+                    )
+                    circuit.cx(q_state, qr_carry[j])
+                    circuit.x(qr_sum[j])
+                    circuit.x(qr_carry[j - 1])
+                    circuit.cx(q_state, qr_sum[j])
+                    circuit.ccx(q_state, qr_carry[j - 1], qr_sum[j])
+            else:
+                if num_sum_qubits == 1:
+                    pass  # nothing to do, since nothing to add
+                elif j == 0:
+                    pass  # nothing to do, since nothing to add
+                elif j == num_sum_qubits - 1:
+                    # compute (q_sum[j] + q_carry[j-1]) into (q_sum[j])
+                    # - controlled by q_state[i] / last qubit,
+                    # no carry needed by construction
+                    circuit.ccx(q_state, qr_carry[j - 1], qr_sum[j])
+                else:
+                    # compute (q_sum[j] + q_carry[j-1]) into (q_sum[j], q_carry[j])
+                    # - controlled by q_state[i]
+                    circuit.compose(
+                        c3x,
+                        [q_state, qr_sum[j], qr_carry[j - 1], qr_carry[j]] + qr_control[:],
+                        inplace=True,
+                    )
+                    circuit.ccx(q_state, qr_carry[j - 1], qr_sum[j])
+
+        # uncompute carry qubits
+        for j in reversed(range(len(weight_binary))):
+            bit = weight_binary[j]
+            if bit == "1":
+                if num_sum_qubits == 1:
+                    pass
+                elif j == 0:
+                    circuit.x(qr_sum[j])
+                    circuit.ccx(q_state, qr_sum[j], qr_carry[j])
+                    circuit.x(qr_sum[j])
+                elif j == num_sum_qubits - 1:
+                    pass
+                else:
+                    circuit.x(qr_carry[j - 1])
+                    circuit.compose(
+                        c3x,
+                        [q_state, qr_sum[j], qr_carry[j - 1], qr_carry[j]] + qr_control[:],
+                        inplace=True,
+                    )
+                    circuit.cx(q_state, qr_carry[j])
+                    circuit.x(qr_carry[j - 1])
+            else:
+                if num_sum_qubits == 1:
+                    pass
+                elif j == 0:
+                    pass
+                elif j == num_sum_qubits - 1:
+                    pass
+                else:
+                    # compute (q_sum[j] + q_carry[j-1]) into (q_sum[j], q_carry[j])
+                    # - controlled by q_state[i]
+                    circuit.x(qr_sum[j])
+                    circuit.compose(
+                        c3x,
+                        [q_state, qr_sum[j], qr_carry[j - 1], qr_carry[j]] + qr_control[:],
+                        inplace=True,
+                    )
+                    circuit.x(qr_sum[j])
+
+    return circuit

qiskit/synthesis/boolean/__init__.py

@@ -0,0 +1,13 @@
+# 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.
+
+"""Module containing boolean expression synthesis."""