qiskit 2.0.3__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

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."""

qiskit/synthesis/boolean/boolean_expression.py

@@ -0,0 +1,231 @@
+# 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.
+
+"""A class for parsing and synthesizing boolean expressions"""
+
+import ast
+import itertools
+import re
+from os.path import isfile
+from typing import Union, Callable
+import numpy as np
+
+from .boolean_expression_visitor import (
+    BooleanExpressionEvalVisitor,
+    BooleanExpressionArgsCollectorVisitor,
+)
+
+
+class TruthTable:
+    """A simple implementation of a truth table for a boolean function
+
+    The truth table is built from a callable which takes an assignment, which
+    is a tuple of boolean values of a fixed given length (the number of bits
+    of the truth table) and returns a boolean value.
+
+    For a number of bits at most `EXPLICIT_REP_THRESHOLD` the values of the table
+    are explicitly computed and stored. Otherwise, the values are computed on the fly
+    and stored in a dictionary."""
+
+    EXPLICIT_REP_THRESHOLD = (
+        12  # above this number of bits, do not explicitly save the values in a list
+    )
+
+    def __init__(self, func: Callable, num_bits: int):
+        self.func = func
+        self.num_bits = num_bits
+        self.explicit_storage = self.num_bits <= self.EXPLICIT_REP_THRESHOLD
+        if self.explicit_storage:
+            self.values = np.array(
+                [self.func(assignment) for assignment in self.all_assignments()],
+                dtype=bool,
+            )
+        else:
+            self.implicit_values = {}
+
+    def all_assignments(self) -> list[tuple[bool]]:
+        """Return an ordered list of all assignments, ordered from right to left
+        i.e. 000, 100, 010, 110, 001, 101, 011, 111"""
+        return [
+            tuple(reversed(assignment))
+            for assignment in itertools.product([False, True], repeat=self.num_bits)
+        ]
+
+    def __getitem__(self, key: Union[str, tuple[bool]]) -> bool:
+        if isinstance(key, str):
+            key = (bit != "0" for bit in key)
+        if self.explicit_storage:
+            key = sum(2**n for n, bit in enumerate(key) if bit)
+            return self.values[key]
+        else:
+            return self.implicit_values.setdefault(key, self.func(key))
+
+    def __str__(self) -> str:
+        if self.explicit_storage:
+            return "".join(
+                "1" if self[assignemnt] else "0" for assignemnt in self.all_assignments()
+            )
+        else:
+            return f"Truth table on {self.num_bits} bits (implicit representation)"
+
+
+class BooleanExpression:
+    """A Boolean Expression"""
+
+    def __init__(self, expression: str, var_order: list = None) -> None:
+        """
+        Args:
+            expression (str): The logical expression string.
+            name (str): Optional. Instruction gate name. Otherwise part of the expression is
+               going to be used.
+            var_order(list): A list with the order in which variables will be created.
+               (default: by appearance)
+        """
+        self.expression = expression
+        self.expression_ast = ast.parse(expression)
+        args_collector = BooleanExpressionArgsCollectorVisitor()
+        args_collector.visit(self.expression_ast)
+        self.args = args_collector.get_sorted_args()
+        self.num_bits = len(self.args)
+        if var_order is not None:
+            missing_args = set(self.args) - set(var_order)
+            if len(missing_args) > 0:
+                raise ValueError(f"var_order missing the variable(s) {', '.join(missing_args)}")
+            self.args.sort(key=var_order.index)
+        self.truth_table_ = None
+
+    def simulate(self, bitstring: Union[str, tuple]) -> bool:
+        """Evaluate the expression on a bitstring.
+
+        This evaluation is done classically.
+
+        Args:
+            bitstring: The bitstring for which to evaluate,
+            either as a string of 0 and 1 or a tuple of booleans.
+
+        Returns:
+            bool: result of the evaluation.
+        """
+        if self.num_bits != len(bitstring):
+            raise ValueError(
+                f"bitstring length differs from the number of variables "
+                f"({len(bitstring)} != {self.num_bits}"
+            )
+        if isinstance(bitstring, str):
+            bitstring = (bit != "0" for bit in bitstring)
+        eval_visitor = BooleanExpressionEvalVisitor()
+        eval_visitor.arg_values = dict(zip(self.args, bitstring))
+        return eval_visitor.visit(self.expression_ast)
+
+    @property
+    def truth_table(self) -> dict:
+        """Generates the full truth table for the expression
+        Returns:
+            dict: A dictionary mapping boolean assignments to the boolean result
+        """
+        if self.truth_table_ is None:
+            self.truth_table_ = TruthTable(self.simulate, self.num_bits)
+        return self.truth_table_
+
+    def synth(self, circuit_type: str = "bit"):
+        r"""Synthesize the logic network into a :class:`~qiskit.circuit.QuantumCircuit`.
+        There are two common types of circuits for a boolean function :math:`f(x)`:
+
+        1. **Bit-flip oracles** which compute:
+
+         .. math::
+
+            |x\rangle|y\rangle |-> |x\rangle|f(x)\oplusy\rangle
+
+        2. **Phase-flip** oracles which compute:
+
+         .. math::
+
+            |x\rangle |-> (-1)^{f(x)}|x\rangle
+
+        By default the bit-flip oracle is generated.
+
+        Args:
+            circuit_type: which type of oracle to create, 'bit' or 'phase' flip oracle.
+        Returns:
+            QuantumCircuit: A circuit implementing the logic network.
+        Raises:
+            ValueError: If ``circuit_type`` is not either 'bit' or 'phase'.
+        """
+        # pylint: disable=cyclic-import
+        from .boolean_expression_synth import (
+            synth_bit_oracle_from_esop,
+            synth_phase_oracle_from_esop,
+            EsopGenerator,
+        )  # import here to avoid cyclic import
+
+        # generating the esop currntly requires generating the full truth table
+        # there are many optimizations that can be done to improve this step
+        esop = EsopGenerator(self.truth_table).esop
+        if circuit_type == "bit":
+            return synth_bit_oracle_from_esop(esop, self.num_bits + 1)
+        if circuit_type == "phase":
+            return synth_phase_oracle_from_esop(esop, self.num_bits)
+        raise ValueError("'circuit_type' must be either 'bit' or 'phase'")
+
+    @staticmethod
+    def from_dimacs(dimacs: str):
+        """Create a BooleanExpression from a string in the DIMACS format.
+        Args:
+            dimacs : A string in DIMACS format.
+
+        Returns:
+            BooleanExpression: A gate for the input string
+
+        Raises:
+            ValueError: If the string is not formatted according to DIMACS rules
+        """
+        header_regex = re.compile(r"p\s+cnf\s+(\d+)\s+(\d+)")
+        clause_regex = re.compile(r"(-?\d+)")
+        lines = [
+            line for line in dimacs.split("\n") if not line.startswith("c") and line != ""
+        ]  # DIMACS comment line start with c
+        header_match = header_regex.match(lines[0])
+        if not header_match:
+            raise ValueError("First line must start with 'p cnf'")
+        num_vars, _ = map(int, header_match.groups())
+        variables = [f"x{i+1}" for i in range(num_vars)]
+        clauses = []
+        for line in lines[1:]:
+            literals = clause_regex.findall(line)
+            if len(literals) == 0 or literals[-1] != "0":
+                continue
+            clauses.append([int(c) for c in literals[:-1]])
+        clause_strings = [
+            " | ".join([f'{"~" if lit < 0 else ""}{variables[abs(lit)-1]}' for lit in clause])
+            for clause in clauses
+        ]
+        expr = " & ".join([f"({c})" for c in clause_strings])
+        return BooleanExpression(expr, var_order=variables)
+
+    @staticmethod
+    def from_dimacs_file(filename: str):
+        """Create a BooleanExpression from a file in the DIMACS format.
+        Args:
+            filename: A file in DIMACS format.
+
+        Returns:
+            BooleanExpression: A gate for the input string
+
+        Raises:
+            FileNotFoundError: If filename is not found.
+        """
+        if not isfile(filename):
+            raise FileNotFoundError(f"The file {filename} does not exists.")
+        with open(filename, "r") as dimacs_file:
+            dimacs = dimacs_file.read()
+        return BooleanExpression.from_dimacs(dimacs)