qiskit 1.3.0b1__cp39-abi3-win32.whl → 1.3.0rc2__cp39-abi3-win32.whl

qiskit/circuit/library/arithmetic/adders/vbe_ripple_carry_adder.py

@@ -11,11 +11,9 @@
 # that they have been altered from the originals.
 
 """Compute the sum of two qubit registers using Classical Addition."""
-from __future__ import annotations
-from qiskit.circuit.bit import Bit
-
-from qiskit.circuit import QuantumCircuit, QuantumRegister, AncillaRegister
 
+from __future__ import annotations
+from qiskit.synthesis.arithmetic import adder_ripple_v95
 from .adder import Adder
 
 
@@ -26,7 +24,7 @@ class VBERippleCarryAdder(Adder):
     As an example, a classical adder circuit that performs full addition (i.e. including
     a carry-in bit) on two 2-qubit sized registers is as follows:
 
-    .. parsed-literal::
+    .. code-block:: text
 
                   ┌────────┐                       ┌───────────┐┌──────┐
            cin_0: ┤0       ├───────────────────────┤0          ├┤0     ├
@@ -52,6 +50,22 @@ class VBERippleCarryAdder(Adder):
     This is different ordering as compared to Figure 2 in [1], which leads to a different
     drawing of the circuit.
 
+    .. seealso::
+
+        The following generic gate objects perform additions, like this circuit class,
+        but allow the compiler to select the optimal decomposition based on the context.
+        Specific implementations can be set via the :class:`.HLSConfig`, e.g. this circuit
+        can be chosen via ``Adder=["ripple_v95"]``.
+
+        :class:`.ModularAdderGate`: A generic inplace adder, modulo :math:`2^n`. This
+            is functionally equivalent to ``kind="fixed"``.
+
+        :class:`.AdderGate`: A generic inplace adder. This
+            is functionally equivalent to ``kind="half"``.
+
+        :class:`.FullAdderGate`: A generic inplace adder, with a carry-in bit. This
+            is functionally equivalent to ``kind="full"``.
+
     **References:**
 
     [1] Vedral et al., Quantum Networks for Elementary Arithmetic Operations, 1995.
@@ -74,92 +88,8 @@ class VBERippleCarryAdder(Adder):
         Raises:
             ValueError: If ``num_state_qubits`` is lower than 1.
         """
-        if num_state_qubits < 1:
-            raise ValueError("The number of qubits must be at least 1.")
-
         super().__init__(num_state_qubits, name=name)
+        circuit = adder_ripple_v95(num_state_qubits, kind)
 
-        # define the input registers
-        registers: list[QuantumRegister | list[Bit]] = []
-        if kind == "full":
-            qr_cin = QuantumRegister(1, name="cin")
-            registers.append(qr_cin)
-        else:
-            qr_cin = QuantumRegister(0)
-
-        qr_a = QuantumRegister(num_state_qubits, name="a")
-        qr_b = QuantumRegister(num_state_qubits, name="b")
-
-        registers += [qr_a, qr_b]
-
-        if kind in ["half", "full"]:
-            qr_cout = QuantumRegister(1, name="cout")
-            registers.append(qr_cout)
-        else:
-            qr_cout = QuantumRegister(0)
-
-        self.add_register(*registers)
-
-        if num_state_qubits > 1:
-            qr_help = AncillaRegister(num_state_qubits - 1, name="helper")
-            self.add_register(qr_help)
-        else:
-            qr_help = AncillaRegister(0)
-
-        # the code is simplified a lot if we create a list of all carries and helpers
-        carries = qr_cin[:] + qr_help[:] + qr_cout[:]
-
-        # corresponds to Carry gate in [1]
-        qc_carry = QuantumCircuit(4, name="Carry")
-        qc_carry.ccx(1, 2, 3)
-        qc_carry.cx(1, 2)
-        qc_carry.ccx(0, 2, 3)
-        carry_gate = qc_carry.to_gate()
-        carry_gate_dg = carry_gate.inverse()
-
-        # corresponds to Sum gate in [1]
-        qc_sum = QuantumCircuit(3, name="Sum")
-        qc_sum.cx(1, 2)
-        qc_sum.cx(0, 2)
-        sum_gate = qc_sum.to_gate()
-
-        circuit = QuantumCircuit(*self.qregs, name=name)
-
-        # handle all cases for the first qubits, depending on whether cin is available
-        i = 0
-        if kind == "half":
-            i += 1
-            circuit.ccx(qr_a[0], qr_b[0], carries[0])
-        elif kind == "fixed":
-            i += 1
-            if num_state_qubits == 1:
-                circuit.cx(qr_a[0], qr_b[0])
-            else:
-                circuit.ccx(qr_a[0], qr_b[0], carries[0])
-
-        for inp, out in zip(carries[:-1], carries[1:]):
-            circuit.append(carry_gate, [inp, qr_a[i], qr_b[i], out])
-            i += 1
-
-        if kind in ["full", "half"]:  # final CX (cancels for the 'fixed' case)
-            circuit.cx(qr_a[-1], qr_b[-1])
-
-        if len(carries) > 1:
-            circuit.append(sum_gate, [carries[-2], qr_a[-1], qr_b[-1]])
-
-        i -= 2
-        for j, (inp, out) in enumerate(zip(reversed(carries[:-1]), reversed(carries[1:]))):
-            if j == 0:
-                if kind == "fixed":
-                    i += 1
-                else:
-                    continue
-            circuit.append(carry_gate_dg, [inp, qr_a[i], qr_b[i], out])
-            circuit.append(sum_gate, [inp, qr_a[i], qr_b[i]])
-            i -= 1
-
-        if kind in ["half", "fixed"] and num_state_qubits > 1:
-            circuit.ccx(qr_a[0], qr_b[0], carries[0])
-            circuit.cx(qr_a[0], qr_b[0])
-
+        self.add_register(*circuit.qregs)
         self.append(circuit.to_gate(), self.qubits)

qiskit/circuit/library/arithmetic/linear_pauli_rotations.py

@@ -27,7 +27,7 @@ class LinearPauliRotations(FunctionalPauliRotations):
     For a register of state qubits :math:`|x\rangle`, a target qubit :math:`|0\rangle` and the
     basis ``'Y'`` this circuit acts as:
 
-    .. parsed-literal::
+    .. code-block:: text
 
             q_0: ─────────────────────────■───────── ... ──────────────────────
                                           │

qiskit/circuit/library/arithmetic/multipliers/__init__.py

@@ -14,3 +14,4 @@
 
 from .hrs_cumulative_multiplier import HRSCumulativeMultiplier
 from .rg_qft_multiplier import RGQFTMultiplier
+from .multiplier import MultiplierGate

qiskit/circuit/library/arithmetic/multipliers/hrs_cumulative_multiplier.py

@@ -26,7 +26,7 @@ class HRSCumulativeMultiplier(Multiplier):
     the default adder is as follows (where ``Adder`` denotes the
     ``CDKMRippleCarryAdder``):
 
-    .. parsed-literal::
+    .. code-block:: text
 
           a_0: ────■─────────────────────────
                    │
@@ -59,6 +59,13 @@ class HRSCumulativeMultiplier(Multiplier):
     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.
 
+    .. seealso::
+
+        The :class:`.MultiplierGate` objects represents a multiplication, like this circuit class,
+        but allows the compiler to select the optimal decomposition based on the context.
+        Specific implementations can be set via the :class:`.HLSConfig`, e.g. this circuit
+        can be chosen via ``Multiplier=["cumulative_h18"]``.
+
     **References:**
 
     [1] Häner et al., Optimizing Quantum Circuits for Arithmetic, 2018.

qiskit/circuit/library/arithmetic/multipliers/multiplier.py

@@ -12,9 +12,10 @@
 
 """Compute the product of two equally sized qubit registers."""
 
-from typing import Optional
+from __future__ import annotations
 
-from qiskit.circuit import QuantumCircuit
+from qiskit.circuit import QuantumCircuit, Gate
+from qiskit.utils.deprecation import deprecate_func
 
 
 class Multiplier(QuantumCircuit):
@@ -45,10 +46,19 @@ class Multiplier(QuantumCircuit):
 
     """
 
+    @deprecate_func(
+        since="1.3",
+        additional_msg=(
+            "Use the MultiplierGate provided in qiskit.circuit.library.arithmetic instead. "
+            "For different multiplier implementations, see "
+            "https://docs.quantum.ibm.com/api/qiskit/synthesis.",
+        ),
+        pending=True,
+    )
     def __init__(
         self,
         num_state_qubits: int,
-        num_result_qubits: Optional[int] = None,
+        num_result_qubits: int | None = None,
         name: str = "Multiplier",
     ) -> None:
         """
@@ -99,3 +109,84 @@ class Multiplier(QuantumCircuit):
             The number of result qubits.
         """
         return self._num_result_qubits
+
+
+class MultiplierGate(Gate):
+    r"""Compute the product of two equally sized qubit registers into a new register.
+
+    For two input registers :math:`|a\rangle_n`, :math:`|b\rangle_n` with :math:`n` qubits each
+    and an output register with :math:`2n` qubits, a multiplier performs the following operation
+
+    .. math::
+
+        |a\rangle_n |b\rangle_n |0\rangle_{t} \mapsto |a\rangle_n |b\rangle_n |a \cdot b\rangle_t
+
+    where :math:`t` is the number of bits used to represent the result. To completely store the result
+    of the multiplication without overflow we need :math:`t = 2n` bits.
+
+    The quantum register :math:`|a\rangle_n` (analogously :math:`|b\rangle_n` and
+    output register)
+
+    .. math::
+
+        |a\rangle_n = |a_0\rangle \otimes \cdots \otimes |a_{n - 1}\rangle,
+
+    for :math:`a_i \in \{0, 1\}`, is associated with the integer value
+
+    .. math::
+
+        a = 2^{0}a_{0} + 2^{1}a_{1} + \cdots + 2^{n - 1}a_{n - 1}.
+
+    """
+
+    def __init__(
+        self,
+        num_state_qubits: int,
+        num_result_qubits: int | None = None,
+        label: str | None = None,
+    ) -> None:
+        """
+        Args:
+            num_state_qubits: The number of qubits in each of the input registers.
+            num_result_qubits: The number of result qubits to limit the output to.
+                Default value is ``2 * num_state_qubits`` to represent any possible
+                result from the multiplication of the two inputs.
+            name: The name of the circuit.
+        Raises:
+            ValueError: If ``num_state_qubits`` is smaller than 1.
+            ValueError: If ``num_result_qubits`` is smaller than ``num_state_qubits``.
+            ValueError: If ``num_result_qubits`` is larger than ``2 * num_state_qubits``.
+        """
+        if num_state_qubits < 1:
+            raise ValueError("The number of state qubits must be at least 1.")
+
+        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})"
+            )
+
+        super().__init__("Multiplier", 2 * num_state_qubits + num_result_qubits, [], label=label)
+
+        self._num_state_qubits = num_state_qubits
+        self._num_result_qubits = num_result_qubits
+
+    @property
+    def num_state_qubits(self) -> int:
+        """The number of state qubits, i.e. the number of bits in each input register.
+
+        Returns:
+            The number of state qubits.
+        """
+        return self._num_state_qubits
+
+    @property
+    def num_result_qubits(self) -> int:
+        """The number of result qubits to limit the output to.
+
+        Returns:
+            The number of result qubits.
+        """
+        return self._num_result_qubits

qiskit/circuit/library/arithmetic/multipliers/rg_qft_multiplier.py

@@ -33,7 +33,7 @@ class RGQFTMultiplier(Multiplier):
     As an example, a circuit that performs a modular QFT multiplication on two 2-qubit
     sized input registers with an output register of 2 qubits, is as follows:
 
-    .. parsed-literal::
+    .. code-block:: text
 
           a_0: ────────────────────────────────────────■───────■──────■──────■────────────────
                                                        │       │      │      │
@@ -48,6 +48,13 @@ class RGQFTMultiplier(Multiplier):
         out_1: ┤1     ├─────────■───────────────■──────────────■─────────────■───────┤1      ├
                └──────┘                                                              └───────┘
 
+    .. seealso::
+
+        The :class:`.MultiplierGate` objects represents a multiplication, like this circuit class,
+        but allows the compiler to select the optimal decomposition based on the context.
+        Specific implementations can be set via the :class:`.HLSConfig`, e.g. this circuit
+        can be chosen via ``Multiplier=["qft_r17"]``.
+
     **References:**
 
     [1] Ruiz-Perez et al., Quantum arithmetic with the Quantum Fourier Transform, 2017.

qiskit/circuit/library/arithmetic/weighted_adder.py

@@ -45,7 +45,7 @@ class WeightedAdder(BlueprintCircuit):
     For an example where the state of 4 qubits is added into a sum register, the circuit can
     be schematically drawn as
 
-    .. parsed-literal::
+    .. code-block:: text
 
                    ┌────────┐
           state_0: ┤0       ├ | state_0 * weights[0]

qiskit/circuit/library/basis_change/qft.py

@@ -13,10 +13,10 @@
 """Define a Quantum Fourier Transform circuit (QFT) and a native gate (QFTGate)."""
 
 from __future__ import annotations
-import warnings
 import numpy as np
 
-from qiskit.circuit.quantumcircuit import QuantumCircuit, QuantumRegister, CircuitInstruction, Gate
+from qiskit.circuit.quantumcircuit import QuantumRegister, CircuitInstruction, Gate
+from qiskit.utils.deprecation import deprecate_func
 from ..blueprintcircuit import BlueprintCircuit
 
 
@@ -72,6 +72,14 @@ class QFT(BlueprintCircuit):
 
     """
 
+    @deprecate_func(
+        since="1.3",
+        additional_msg=(
+            "Use qiskit.circuit.library.QFTGate or qiskit.synthesis.qft.synth_qft_full instead, "
+            "for access to all previous arguments.",
+        ),
+        pending=True,
+    )
     def __init__(
         self,
         num_qubits: int | None = None,
@@ -232,22 +240,6 @@ class QFT(BlueprintCircuit):
         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
@@ -255,7 +247,6 @@ class QFT(BlueprintCircuit):
             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:
@@ -270,25 +261,16 @@ class QFT(BlueprintCircuit):
         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()
+        from qiskit.synthesis.qft import synth_qft_full
+
+        circuit = synth_qft_full(
+            num_qubits,
+            do_swaps=self._do_swaps,
+            insert_barriers=self._insert_barriers,
+            approximation_degree=self._approximation_degree,
+            inverse=self._inverse,
+            name=self.name,
+        )
 
         wrapped = circuit.to_instruction() if self.insert_barriers else circuit.to_gate()
         self.compose(wrapped, qubits=self.qubits, inplace=True)

qiskit/circuit/library/blueprintcircuit.py

@@ -94,6 +94,12 @@ class BlueprintCircuit(QuantumCircuit, ABC):
 
     @property
     def data(self):
+        """The circuit data (instructions and context).
+
+        Returns:
+            QuantumCircuitData: a list-like object containing the :class:`.CircuitInstruction`\\ s
+            for each instruction.
+        """
         if not self._is_built:
             self._build()
         return super().data
@@ -110,12 +116,70 @@ class BlueprintCircuit(QuantumCircuit, ABC):
 
     @property
     def num_parameters(self) -> int:
+        """The number of parameter objects in the circuit."""
         if not self._is_built:
             self._build()
         return super().num_parameters
 
     @property
     def parameters(self) -> ParameterView:
+        """The parameters defined in the circuit.
+
+        This attribute returns the :class:`.Parameter` objects in the circuit sorted
+        alphabetically. Note that parameters instantiated with a :class:`.ParameterVector`
+        are still sorted numerically.
+
+        Examples:
+
+            The snippet below shows that insertion order of parameters does not matter.
+
+            .. code-block:: python
+
+                >>> from qiskit.circuit import QuantumCircuit, Parameter
+                >>> a, b, elephant = Parameter("a"), Parameter("b"), Parameter("elephant")
+                >>> circuit = QuantumCircuit(1)
+                >>> circuit.rx(b, 0)
+                >>> circuit.rz(elephant, 0)
+                >>> circuit.ry(a, 0)
+                >>> circuit.parameters  # sorted alphabetically!
+                ParameterView([Parameter(a), Parameter(b), Parameter(elephant)])
+
+            Bear in mind that alphabetical sorting might be unintuitive when it comes to numbers.
+            The literal "10" comes before "2" in strict alphabetical sorting.
+
+            .. code-block:: python
+
+                >>> from qiskit.circuit import QuantumCircuit, Parameter
+                >>> angles = [Parameter("angle_1"), Parameter("angle_2"), Parameter("angle_10")]
+                >>> circuit = QuantumCircuit(1)
+                >>> circuit.u(*angles, 0)
+                >>> circuit.draw()
+                   ┌─────────────────────────────┐
+                q: ┤ U(angle_1,angle_2,angle_10) ├
+                   └─────────────────────────────┘
+                >>> circuit.parameters
+                ParameterView([Parameter(angle_1), Parameter(angle_10), Parameter(angle_2)])
+
+            To respect numerical sorting, a :class:`.ParameterVector` can be used.
+
+            .. code-block:: python
+
+                >>> from qiskit.circuit import QuantumCircuit, Parameter, ParameterVector
+                >>> x = ParameterVector("x", 12)
+                >>> circuit = QuantumCircuit(1)
+                >>> for x_i in x:
+                ...     circuit.rx(x_i, 0)
+                >>> circuit.parameters
+                ParameterView([
+                    ParameterVectorElement(x[0]), ParameterVectorElement(x[1]),
+                    ParameterVectorElement(x[2]), ParameterVectorElement(x[3]),
+                    ..., ParameterVectorElement(x[11])
+                ])
+
+
+        Returns:
+            The sorted :class:`.Parameter` objects in the circuit.
+        """
         if not self._is_built:
             self._build()
         return super().parameters

qiskit/circuit/library/boolean_logic/__init__.py

@@ -12,7 +12,7 @@
 
 """The Boolean logic circuit library."""
 
-from .quantum_and import AND
-from .quantum_or import OR
-from .quantum_xor import XOR
-from .inner_product import InnerProduct
+from .quantum_and import AND, AndGate
+from .quantum_or import OR, OrGate
+from .quantum_xor import XOR, BitwiseXorGate, random_bitwise_xor
+from .inner_product import InnerProduct, InnerProductGate

qiskit/circuit/library/boolean_logic/inner_product.py

@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2020.
+# (C) Copyright IBM 2020, 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
@@ -11,10 +11,11 @@
 # that they have been altered from the originals.
 
 
-"""InnerProduct circuit."""
+"""InnerProduct circuit and gate."""
 
 
-from qiskit.circuit import QuantumRegister, QuantumCircuit
+from qiskit.circuit import QuantumRegister, QuantumCircuit, Gate
+from qiskit.utils.deprecation import deprecate_func
 
 
 class InnerProduct(QuantumCircuit):
@@ -32,7 +33,7 @@ class InnerProduct(QuantumCircuit):
     where the inner product of the top and bottom registers is 1. Otherwise it keeps
     the input intact.
 
-    .. parsed-literal::
+    .. code-block:: text
 
 
         q0_0: ─■──────────
@@ -61,6 +62,11 @@ class InnerProduct(QuantumCircuit):
            _generate_circuit_library_visualization(circuit)
     """
 
+    @deprecate_func(
+        since="1.3",
+        additional_msg="Use qiskit.circuit.library.InnerProductGate instead.",
+        pending=True,
+    )
     def __init__(self, num_qubits: int) -> None:
         """Return a circuit to compute the inner product of 2 n-qubit registers.
 
@@ -76,3 +82,74 @@ class InnerProduct(QuantumCircuit):
 
         super().__init__(*inner.qregs, name="inner_product")
         self.compose(inner.to_gate(), qubits=self.qubits, inplace=True)
+
+
+class InnerProductGate(Gate):
+    r"""A 2n-qubit Boolean function that computes the inner product of
+    two n-qubit vectors over :math:`F_2`.
+
+    This implementation is a phase oracle which computes the following transform.
+
+    .. math::
+
+        \mathcal{IP}_{2n} : F_2^{2n} \rightarrow {-1, 1}
+        \mathcal{IP}_{2n}(x_1, \cdots, x_n, y_1, \cdots, y_n) = (-1)^{x.y}
+
+    The corresponding unitary is a diagonal, which induces a -1 phase on any inputs
+    where the inner product of the top and bottom registers is 1. Otherwise, it keeps
+    the input intact.
+
+    .. parsed-literal::
+
+
+        q0_0: ─■──────────
+               │
+        q0_1: ─┼──■───────
+               │  │
+        q0_2: ─┼──┼──■────
+               │  │  │
+        q0_3: ─┼──┼──┼──■─
+               │  │  │  │
+        q1_0: ─■──┼──┼──┼─
+                  │  │  │
+        q1_1: ────■──┼──┼─
+                     │  │
+        q1_2: ───────■──┼─
+                        │
+        q1_3: ──────────■─
+
+
+    Reference Circuit:
+        .. plot::
+
+           from qiskit.circuit import QuantumCircuit
+           from qiskit.circuit.library import InnerProductGate
+           from qiskit.visualization.library import _generate_circuit_library_visualization
+           circuit = QuantumCircuit(8)
+           circuit.append(InnerProductGate(4), [0, 1, 2, 3, 4, 5, 6, 7])
+           _generate_circuit_library_visualization(circuit)
+    """
+
+    def __init__(
+        self,
+        num_qubits: int,
+    ) -> None:
+        """
+        Args:
+            num_qubits: width of top and bottom registers (half total number of qubits).
+        """
+        super().__init__("inner_product", 2 * num_qubits, [])
+
+    def _define(self):
+        num_qubits = self.num_qubits // 2
+        qr_a = QuantumRegister(num_qubits, name="x")
+        qr_b = QuantumRegister(num_qubits, name="y")
+
+        circuit = QuantumCircuit(qr_a, qr_b, name="inner_product")
+        for i in range(num_qubits):
+            circuit.cz(qr_a[i], qr_b[i])
+
+        self.definition = circuit
+
+    def __eq__(self, other):
+        return isinstance(other, InnerProductGate) and self.num_qubits == other.num_qubits