qiskit 1.4.2__cp39-abi3-win_amd64.whl → 2.0.0rc2__cp39-abi3-win_amd64.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/hrs_cumulative_multiplier.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 
 
 def multiplier_cumulative_h18(

qiskit/synthesis/arithmetic/multipliers/rg_qft_multiplier.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 import numpy as np
 
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.circuit.library.standard_gates import PhaseGate
 from qiskit.circuit.library.basis_change import QFTGate
 

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/{result/mitigation → synthesis/boolean}/__init__.py

@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2017, 2021.
+# (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
@@ -10,4 +10,4 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""Readout error mitigation."""
+"""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)