qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

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
+
+    .. parsed-literal::
+
+                   ┌────────┐
+          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

qiskit/circuit/library/basis_change/qft.py

@@ -0,0 +1,289 @@
+# 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.
+
+"""Quantum Fourier Transform Circuit."""
+
+from typing import Optional
+import warnings
+import numpy as np
+
+from qiskit.circuit import QuantumCircuit, QuantumRegister, CircuitInstruction
+
+from ..blueprintcircuit import BlueprintCircuit
+
+
+class QFT(BlueprintCircuit):
+    r"""Quantum Fourier Transform Circuit.
+
+    The Quantum Fourier Transform (QFT) on :math:`n` qubits is the operation
+
+    .. math::
+
+        |j\rangle \mapsto \frac{1}{2^{n/2}} \sum_{k=0}^{2^n - 1} e^{2\pi ijk / 2^n} |k\rangle
+
+    The circuit that implements this transformation can be implemented using Hadamard gates
+    on each qubit, a series of controlled-U1 (or Z, depending on the phase) gates and a
+    layer of Swap gates. The layer of Swap gates can in principle be dropped if the QFT appears
+    at the end of the circuit, since then the re-ordering can be done classically. They
+    can be turned off using the ``do_swaps`` attribute.
+
+    For 4 qubits, the circuit that implements this transformation is:
+
+    .. plot::
+
+       from qiskit.circuit.library import QFT
+       from qiskit.tools.jupyter.library import _generate_circuit_library_visualization
+       circuit = QFT(4)
+       _generate_circuit_library_visualization(circuit)
+
+    The inverse QFT can be obtained by calling the ``inverse`` method on this class.
+    The respective circuit diagram is:
+
+    .. plot::
+
+       from qiskit.circuit.library import QFT
+       from qiskit.tools.jupyter.library import _generate_circuit_library_visualization
+       circuit = QFT(4).inverse()
+       _generate_circuit_library_visualization(circuit)
+
+    One method to reduce circuit depth is to implement the QFT approximately by ignoring
+    controlled-phase rotations where the angle is beneath a threshold. This is discussed
+    in more detail in https://arxiv.org/abs/quant-ph/9601018 or
+    https://arxiv.org/abs/quant-ph/0403071.
+
+    Here, this can be adjusted using the ``approximation_degree`` attribute: the smallest
+    ``approximation_degree`` rotation angles are dropped from the QFT. For instance, a QFT
+    on 5 qubits with approximation degree 2 yields (the barriers are dropped in this example):
+
+    .. plot::
+
+       from qiskit.circuit.library import QFT
+       from qiskit.tools.jupyter.library import _generate_circuit_library_visualization
+       circuit = QFT(5, approximation_degree=2)
+       _generate_circuit_library_visualization(circuit)
+
+    """
+
+    def __init__(
+        self,
+        num_qubits: Optional[int] = None,
+        approximation_degree: int = 0,
+        do_swaps: bool = True,
+        inverse: bool = False,
+        insert_barriers: bool = False,
+        name: Optional[str] = None,
+    ) -> None:
+        """Construct a new QFT circuit.
+
+        Args:
+            num_qubits: The number of qubits on which the QFT acts.
+            approximation_degree: The degree of approximation (0 for no approximation).
+            do_swaps: Whether to include the final swaps in the QFT.
+            inverse: If True, the inverse Fourier transform is constructed.
+            insert_barriers: If True, barriers are inserted as visualization improvement.
+            name: The name of the circuit.
+        """
+        if name is None:
+            name = "IQFT" if inverse else "QFT"
+
+        super().__init__(name=name)
+        self._approximation_degree = approximation_degree
+        self._do_swaps = do_swaps
+        self._insert_barriers = insert_barriers
+        self._inverse = inverse
+        self.num_qubits = num_qubits
+
+    @property
+    def num_qubits(self) -> int:
+        """The number of qubits in the QFT circuit.
+
+        Returns:
+            The number of qubits in the circuit.
+        """
+        # This method needs to be overwritten to allow adding the setter for num_qubits while still
+        # complying to pylint.
+        return super().num_qubits
+
+    @num_qubits.setter
+    def num_qubits(self, num_qubits: int) -> None:
+        """Set the number of qubits.
+
+        Note that this changes the registers of the circuit.
+
+        Args:
+            num_qubits: The new number of qubits.
+        """
+        if num_qubits != self.num_qubits:
+            self._invalidate()
+
+            self.qregs = []
+            if num_qubits is not None and num_qubits > 0:
+                self.qregs = [QuantumRegister(num_qubits, name="q")]
+
+    @property
+    def approximation_degree(self) -> int:
+        """The approximation degree of the QFT.
+
+        Returns:
+            The currently set approximation degree.
+        """
+        return self._approximation_degree
+
+    @approximation_degree.setter
+    def approximation_degree(self, approximation_degree: int) -> None:
+        """Set the approximation degree of the QFT.
+
+        Args:
+            approximation_degree: The new approximation degree.
+
+        Raises:
+            ValueError: If the approximation degree is smaller than 0.
+        """
+        if approximation_degree < 0:
+            raise ValueError("Approximation degree cannot be smaller than 0.")
+
+        if approximation_degree != self._approximation_degree:
+            self._invalidate()
+            self._approximation_degree = approximation_degree
+
+    @property
+    def insert_barriers(self) -> bool:
+        """Whether barriers are inserted for better visualization or not.
+
+        Returns:
+            True, if barriers are inserted, False if not.
+        """
+        return self._insert_barriers
+
+    @insert_barriers.setter
+    def insert_barriers(self, insert_barriers: bool) -> None:
+        """Specify whether barriers are inserted for better visualization or not.
+
+        Args:
+            insert_barriers: If True, barriers are inserted, if False not.
+        """
+        if insert_barriers != self._insert_barriers:
+            self._invalidate()
+            self._insert_barriers = insert_barriers
+
+    @property
+    def do_swaps(self) -> bool:
+        """Whether the final swaps of the QFT are applied or not.
+
+        Returns:
+            True, if the final swaps are applied, False if not.
+        """
+        return self._do_swaps
+
+    @do_swaps.setter
+    def do_swaps(self, do_swaps: bool) -> None:
+        """Specify whether to do the final swaps of the QFT circuit or not.
+
+        Args:
+            do_swaps: If True, the final swaps are applied, if False not.
+        """
+        if do_swaps != self._do_swaps:
+            self._invalidate()
+            self._do_swaps = do_swaps
+
+    def is_inverse(self) -> bool:
+        """Whether the inverse Fourier transform is implemented.
+
+        Returns:
+            True, if the inverse Fourier transform is implemented, False otherwise.
+        """
+        return self._inverse
+
+    def inverse(self) -> "QFT":
+        """Invert this circuit.
+
+        Returns:
+            The inverted circuit.
+        """
+
+        if self.name in ("QFT", "IQFT"):
+            name = "QFT" if self._inverse else "IQFT"
+        else:
+            name = self.name + "_dg"
+
+        inverted = self.copy(name=name)
+
+        # data consists of the QFT gate only
+        iqft = self.data[0].operation.inverse()
+        iqft.name = name
+
+        inverted.data.clear()
+        inverted._append(CircuitInstruction(iqft, inverted.qubits, []))
+
+        inverted._inverse = not self._inverse
+        return inverted
+
+    def _warn_if_precision_loss(self):
+        """Issue a warning if constructing the circuit will lose precision.
+
+        If we need an angle smaller than ``pi * 2**-1022``, we start to lose precision by going into
+        the subnormal numbers.  We won't lose _all_ precision until an exponent of about 1075, but
+        beyond 1022 we're using fractional bits to represent leading zeros."""
+        max_num_entanglements = self.num_qubits - self.approximation_degree - 1
+        if max_num_entanglements > -np.finfo(float).minexp:  # > 1022 for doubles.
+            warnings.warn(
+                "precision loss in QFT."
+                f" The rotation needed to represent {max_num_entanglements} entanglements"
+                " is smaller than the smallest normal floating-point number.",
+                category=RuntimeWarning,
+                stacklevel=3,
+            )
+
+    def _check_configuration(self, raise_on_failure: bool = True) -> bool:
+        """Check if the current configuration is valid."""
+        valid = True
+        if self.num_qubits is None:
+            valid = False
+            if raise_on_failure:
+                raise AttributeError("The number of qubits has not been set.")
+        self._warn_if_precision_loss()
+        return valid
+
+    def _build(self) -> None:
+        """If not already built, build the circuit."""
+        if self._is_built:
+            return
+
+        super()._build()
+
+        num_qubits = self.num_qubits
+
+        if num_qubits == 0:
+            return
+
+        circuit = QuantumCircuit(*self.qregs, name=self.name)
+        for j in reversed(range(num_qubits)):
+            circuit.h(j)
+            num_entanglements = max(0, j - max(0, self.approximation_degree - (num_qubits - j - 1)))
+            for k in reversed(range(j - num_entanglements, j)):
+                # Use negative exponents so that the angle safely underflows to zero, rather than
+                # using a temporary variable that overflows to infinity in the worst case.
+                lam = np.pi * (2.0 ** (k - j))
+                circuit.cp(lam, j, k)
+
+            if self.insert_barriers:
+                circuit.barrier()
+
+        if self._do_swaps:
+            for i in range(num_qubits // 2):
+                circuit.swap(i, num_qubits - i - 1)
+
+        if self._inverse:
+            circuit = circuit.inverse()
+
+        wrapped = circuit.to_instruction() if self.insert_barriers else circuit.to_gate()
+        self.compose(wrapped, qubits=self.qubits, inplace=True)