qiskit 1.3.0__cp39-abi3-win32.whl

qiskit/circuit/library/arithmetic/quadratic_form.py

@@ -0,0 +1,198 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2020.
+#
+# 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 circuit implementing a quadratic form on binary variables."""
+
+from typing import Union, Optional, List
+import math
+
+import numpy as np
+
+from qiskit.circuit import QuantumCircuit, QuantumRegister, ParameterExpression
+from ..basis_change import QFT
+
+
+class QuadraticForm(QuantumCircuit):
+    r"""Implements a quadratic form on binary variables encoded in qubit registers.
+
+    A quadratic form on binary variables is a quadratic function :math:`Q` acting on a binary
+    variable of :math:`n` bits, :math:`x = x_0 ... x_{n-1}`. For an integer matrix :math:`A`,
+    an integer vector :math:`b` and an integer :math:`c` the function can be written as
+
+    .. math::
+
+        Q(x) = x^T A x + x^T b + c
+
+    If :math:`A`, :math:`b` or :math:`c` contain scalar values, this circuit computes only
+    an approximation of the quadratic form.
+
+    Provided with :math:`m` qubits to encode the value, this circuit computes :math:`Q(x) \mod 2^m`
+    in [two's complement](https://stackoverflow.com/questions/1049722/what-is-2s-complement)
+    representation.
+
+    .. math::
+
+        |x\rangle_n |0\rangle_m \mapsto |x\rangle_n |(Q(x) + 2^m) \mod 2^m \rangle_m
+
+    Since we use two's complement e.g. the value of :math:`Q(x) = 3` requires 2 bits to represent
+    the value and 1 bit for the sign: `3 = '011'` where the first `0` indicates a positive value.
+    On the other hand, :math:`Q(x) = -3` would be `-3 = '101'`, where the first `1` indicates
+    a negative value and `01` is the two's complement of `3`.
+
+    If the value of :math:`Q(x)` is too large to be represented with `m` qubits, the resulting
+    bitstring is :math:`(Q(x) + 2^m) \mod 2^m)`.
+
+    The implementation of this circuit is discussed in [1], Fig. 6.
+
+    References:
+        [1]: Gilliam et al., Grover Adaptive Search for Constrained Polynomial Binary Optimization.
+             `arXiv:1912.04088 <https://arxiv.org/pdf/1912.04088.pdf>`_
+
+    """
+
+    def __init__(
+        self,
+        num_result_qubits: Optional[int] = None,
+        quadratic: Optional[
+            Union[np.ndarray, List[List[Union[float, ParameterExpression]]]]
+        ] = None,
+        linear: Optional[Union[np.ndarray, List[Union[float, ParameterExpression]]]] = None,
+        offset: Optional[Union[float, ParameterExpression]] = None,
+        little_endian: bool = True,
+    ) -> None:
+        r"""
+        Args:
+            num_result_qubits: The number of qubits to encode the result. Called :math:`m` in
+                the class documentation.
+            quadratic: A matrix containing the quadratic coefficients, :math:`A`.
+            linear: An array containing the linear coefficients, :math:`b`.
+            offset: A constant offset, :math:`c`.
+            little_endian: Encode the result in little endianness.
+
+        Raises:
+            ValueError: If ``linear`` and ``quadratic`` have mismatching sizes.
+            ValueError: If ``num_result_qubits`` is unspecified but cannot be determined because
+                some values of the quadratic form are parameterized.
+        """
+        # check inputs match
+        if quadratic is not None and linear is not None:
+            if len(quadratic) != len(linear):
+                raise ValueError("Mismatching sizes of quadratic and linear.")
+
+        # temporarily set quadratic and linear to [] instead of None so we can iterate over them
+        if quadratic is None:
+            quadratic = []
+
+        if linear is None:
+            linear = []
+
+        if offset is None:
+            offset = 0
+
+        num_input_qubits = np.max([1, len(linear), len(quadratic)])
+
+        # deduce number of result bits if not added
+        if num_result_qubits is None:
+            # check no value is parameterized
+            if (
+                any(any(isinstance(q_ij, ParameterExpression) for q_ij in q_i) for q_i in quadratic)
+                or any(isinstance(l_i, ParameterExpression) for l_i in linear)
+                or isinstance(offset, ParameterExpression)
+            ):
+                raise ValueError(
+                    "If the number of result qubits is not specified, the quadratic "
+                    "form matrices/vectors/offset may not be parameterized."
+                )
+            num_result_qubits = self.required_result_qubits(quadratic, linear, offset)
+
+        qr_input = QuantumRegister(num_input_qubits)
+        qr_result = QuantumRegister(num_result_qubits)
+        circuit = QuantumCircuit(qr_input, qr_result, name="Q(x)")
+
+        # set quadratic and linear again to None if they were None
+        if len(quadratic) == 0:
+            quadratic = None
+
+        if len(linear) == 0:
+            linear = None
+
+        scaling = np.pi * 2 ** (1 - num_result_qubits)
+
+        # initial QFT (just hadamards)
+        circuit.h(qr_result)
+
+        if little_endian:
+            qr_result = qr_result[::-1]
+
+        # constant coefficient
+        if offset != 0:
+            for i, q_i in enumerate(qr_result):
+                circuit.p(scaling * 2**i * offset, q_i)
+
+        # the linear part consists of the vector and the diagonal of the
+        # matrix, since x_i * x_i = x_i, as x_i is a binary variable
+        for j in range(num_input_qubits):
+            value = linear[j] if linear is not None else 0
+            value += quadratic[j][j] if quadratic is not None else 0
+            if value != 0:
+                for i, q_i in enumerate(qr_result):
+                    circuit.cp(scaling * 2**i * value, qr_input[j], q_i)
+
+        # the quadratic part adds A_ij and A_ji as x_i x_j == x_j x_i
+        if quadratic is not None:
+            for j in range(num_input_qubits):
+                for k in range(j + 1, num_input_qubits):
+                    value = quadratic[j][k] + quadratic[k][j]
+                    if value != 0:
+                        for i, q_i in enumerate(qr_result):
+                            circuit.mcp(scaling * 2**i * value, [qr_input[j], qr_input[k]], q_i)
+
+        # add the inverse QFT
+        iqft = QFT(num_result_qubits, do_swaps=False).inverse().reverse_bits()
+        circuit.compose(iqft, qubits=qr_result[:], inplace=True)
+
+        super().__init__(*circuit.qregs, name="Q(x)")
+        self.compose(circuit.to_gate(), qubits=self.qubits, inplace=True)
+
+    @staticmethod
+    def required_result_qubits(
+        quadratic: Union[np.ndarray, List[List[float]]],
+        linear: Union[np.ndarray, List[float]],
+        offset: float,
+    ) -> int:
+        """Get the number of required result qubits.
+
+        Args:
+            quadratic: A matrix containing the quadratic coefficients.
+            linear: An array containing the linear coefficients.
+            offset: A constant offset.
+
+        Returns:
+            The number of qubits needed to represent the value of the quadratic form
+            in twos complement.
+        """
+
+        bounds = []  # bounds = [minimum value, maximum value]
+        for condition in [lambda x: x < 0, lambda x: x > 0]:
+            bound = 0.0
+            bound += sum(sum(q_ij for q_ij in q_i if condition(q_ij)) for q_i in quadratic)
+            bound += sum(l_i for l_i in linear if condition(l_i))
+            bound += offset if condition(offset) else 0
+            bounds.append(bound)
+
+        # the minimum number of qubits is the number of qubits needed to represent
+        # the minimum/maximum value plus one sign qubit
+        num_qubits_for_min = math.ceil(math.log2(max(-bounds[0], 1)))
+        num_qubits_for_max = math.ceil(math.log2(bounds[1] + 1))
+        num_result_qubits = 1 + max(num_qubits_for_min, num_qubits_for_max)
+
+        return num_result_qubits

qiskit/circuit/library/arithmetic/weighted_adder.py

@@ -0,0 +1,337 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2020.
+#
+# 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 weighted sum of qubit states."""
+
+from typing import List, Optional
+import numpy as np
+
+from qiskit.circuit import QuantumRegister, AncillaRegister, QuantumCircuit
+
+from ..blueprintcircuit import BlueprintCircuit
+
+
+class WeightedAdder(BlueprintCircuit):
+    r"""A circuit to compute the weighted sum of qubit registers.
+
+    Given :math:`n` qubit basis states :math:`q_0, \ldots, q_{n-1} \in \{0, 1\}` and non-negative
+    integer weights :math:`\lambda_0, \ldots, \lambda_{n-1}`, this circuit performs the operation
+
+    .. math::
+
+        |q_0 \ldots q_{n-1}\rangle |0\rangle_s
+        \mapsto |q_0 \ldots q_{n-1}\rangle |\sum_{j=0}^{n-1} \lambda_j q_j\rangle_s
+
+    where :math:`s` is the number of sum qubits required.
+    This can be computed as
+
+    .. math::
+
+        s = 1 + \left\lfloor \log_2\left( \sum_{j=0}^{n-1} \lambda_j \right) \right\rfloor
+
+    or :math:`s = 1` if the sum of the weights is 0 (then the expression in the logarithm is
+    invalid).
+
+    For qubits in a circuit diagram, the first weight applies to the upper-most qubit.
+    For an example where the state of 4 qubits is added into a sum register, the circuit can
+    be schematically drawn as
+
+    .. code-block:: text
+
+                   ┌────────┐
+          state_0: ┤0       ├ | state_0 * weights[0]
+                   │        │ |
+          state_1: ┤1       ├ | + state_1 * weights[1]
+                   │        │ |
+          state_2: ┤2       ├ | + state_2 * weights[2]
+                   │        │ |
+          state_3: ┤3       ├ | + state_3 * weights[3]
+                   │        │
+            sum_0: ┤4       ├ |
+                   │  Adder │ |
+            sum_1: ┤5       ├ | = sum_0 * 2^0 + sum_1 * 2^1 + sum_2 * 2^2
+                   │        │ |
+            sum_2: ┤6       ├ |
+                   │        │
+          carry_0: ┤7       ├
+                   │        │
+          carry_1: ┤8       ├
+                   │        │
+        control_0: ┤9       ├
+                   └────────┘
+    """
+
+    def __init__(
+        self,
+        num_state_qubits: Optional[int] = None,
+        weights: Optional[List[int]] = None,
+        name: str = "adder",
+    ) -> None:
+        """Computes the weighted sum controlled by state qubits.
+
+        Args:
+            num_state_qubits: The number of state qubits.
+            weights: List of weights, one for each state qubit. If none are provided they
+                default to 1 for every qubit.
+            name: The name of the circuit.
+        """
+        super().__init__(name=name)
+
+        self._weights = None
+        self._num_state_qubits = None
+
+        self.weights = weights
+        self.num_state_qubits = num_state_qubits
+
+    @property
+    def num_sum_qubits(self) -> int:
+        """The number of sum qubits in the circuit.
+
+        Returns:
+            The number of qubits needed to represent the weighted sum of the qubits.
+        """
+        if sum(self.weights) > 0:
+            return int(np.floor(np.log2(sum(self.weights))) + 1)
+        return 1
+
+    @property
+    def weights(self) -> List[int]:
+        """The weights for the qubit states.
+
+        Returns:
+            The weight for the qubit states.
+        """
+        if self._weights:
+            return self._weights
+        if self.num_state_qubits:
+            return [1] * self.num_state_qubits
+        return None
+
+    @weights.setter
+    def weights(self, weights: List[int]) -> None:
+        """Set the weights for summing the qubit states.
+
+        Args:
+            weights: The new weights.
+
+        Raises:
+            ValueError: If not all weights are close to an integer.
+        """
+        if weights:
+            for i, weight in enumerate(weights):
+                if not np.isclose(weight, np.round(weight)):
+                    raise ValueError("Non-integer weights are not supported!")
+                weights[i] = np.round(weight)
+
+        self._invalidate()
+        self._weights = weights
+        self._reset_registers()
+
+    @property
+    def num_state_qubits(self) -> int:
+        """The number of qubits to be summed.
+
+        Returns:
+            The number of state qubits.
+        """
+        return self._num_state_qubits
+
+    @num_state_qubits.setter
+    def num_state_qubits(self, num_state_qubits: int) -> None:
+        """Set the number of state qubits.
+
+        Args:
+            num_state_qubits: The new number of state qubits.
+        """
+        if self._num_state_qubits is None or num_state_qubits != self._num_state_qubits:
+            self._invalidate()
+            self._num_state_qubits = num_state_qubits
+            self._reset_registers()
+
+    def _reset_registers(self):
+        """Reset the registers."""
+        self.qregs = []
+
+        if self.num_state_qubits:
+            qr_state = QuantumRegister(self.num_state_qubits, name="state")
+            qr_sum = QuantumRegister(self.num_sum_qubits, name="sum")
+            self.qregs = [qr_state, qr_sum]
+
+            if self.num_carry_qubits > 0:
+                qr_carry = AncillaRegister(self.num_carry_qubits, name="carry")
+                self.add_register(qr_carry)
+
+            if self.num_control_qubits > 0:
+                qr_control = AncillaRegister(self.num_control_qubits, name="control")
+                self.add_register(qr_control)
+
+    @property
+    def num_carry_qubits(self) -> int:
+        """The number of carry qubits required to compute the sum.
+
+        Note that this is not necessarily equal to the number of ancilla qubits, these can
+        be queried using ``num_ancilla_qubits``.
+
+        Returns:
+            The number of carry qubits required to compute the sum.
+        """
+        return self.num_sum_qubits - 1
+
+    @property
+    def num_control_qubits(self) -> int:
+        """The number of additional control qubits required.
+
+        Note that the total number of ancilla qubits can be obtained by calling the
+        method ``num_ancilla_qubits``.
+
+        Returns:
+            The number of additional control qubits required (0 or 1).
+        """
+        return int(self.num_sum_qubits > 2)
+
+    def _check_configuration(self, raise_on_failure=True):
+        """Check if the current configuration is valid."""
+        valid = True
+        if self._num_state_qubits is None:
+            valid = False
+            if raise_on_failure:
+                raise AttributeError("The number of state qubits has not been set.")
+
+        if self._num_state_qubits != len(self.weights):
+            valid = False
+            if raise_on_failure:
+                raise ValueError("Mismatching number of state qubits and weights.")
+
+        return valid
+
+    def _build(self):
+        """If not already built, build the circuit."""
+        if self._is_built:
+            return
+
+        super()._build()
+
+        num_result_qubits = self.num_state_qubits + self.num_sum_qubits
+
+        circuit = QuantumCircuit(*self.qregs)
+        qr_state = circuit.qubits[: self.num_state_qubits]
+        qr_sum = circuit.qubits[self.num_state_qubits : num_result_qubits]
+        qr_carry = circuit.qubits[num_result_qubits : num_result_qubits + self.num_carry_qubits]
+        qr_control = circuit.qubits[num_result_qubits + self.num_carry_qubits :]
+
+        # loop over state qubits and corresponding weights
+        for i, weight in enumerate(self.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(self.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 self.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 == self.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.mcx(
+                            [q_state, qr_sum[j], qr_carry[j - 1]],
+                            qr_carry[j],
+                            qr_control,
+                            mode="v-chain",
+                        )
+                        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 self.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 == self.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.mcx(
+                            [q_state, qr_sum[j], qr_carry[j - 1]],
+                            qr_carry[j],
+                            qr_control,
+                            mode="v-chain",
+                        )
+                        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 self.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 == self.num_sum_qubits - 1:
+                        pass
+                    else:
+                        circuit.x(qr_carry[j - 1])
+                        circuit.mcx(
+                            [q_state, qr_sum[j], qr_carry[j - 1]],
+                            qr_carry[j],
+                            qr_control,
+                            mode="v-chain",
+                        )
+                        circuit.cx(q_state, qr_carry[j])
+                        circuit.x(qr_carry[j - 1])
+                else:
+                    if self.num_sum_qubits == 1:
+                        pass
+                    elif j == 0:
+                        pass
+                    elif j == self.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.mcx(
+                            [q_state, qr_sum[j], qr_carry[j - 1]],
+                            qr_carry[j],
+                            qr_control,
+                            mode="v-chain",
+                        )
+                        circuit.x(qr_sum[j])
+
+        self.append(circuit.to_gate(), self.qubits)

qiskit/circuit/library/basis_change/__init__.py

@@ -0,0 +1,15 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2020.
+#
+# 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 basis change circuits."""
+
+from .qft import QFT, QFTGate