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

qiskit/circuit/library/fourier_checking.py

@@ -12,13 +12,14 @@
 
 """Fourier checking circuit."""
 
-from typing import List
-
+from collections.abc import Sequence
 import math
+
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit.exceptions import CircuitError
+from qiskit.utils.deprecation import deprecate_func
 
-from .generalized_gates.diagonal import Diagonal
+from .generalized_gates.diagonal import Diagonal, DiagonalGate
 
 
 class FourierChecking(QuantumCircuit):
@@ -52,7 +53,12 @@ class FourierChecking(QuantumCircuit):
     `arXiv:1411.5729 <https://arxiv.org/abs/1411.5729>`_
     """
 
-    def __init__(self, f: List[int], g: List[int]) -> None:
+    @deprecate_func(
+        since="1.3",
+        additional_msg="Use qiskit.circuit.library.fourier_checking instead.",
+        pending=True,
+    )
+    def __init__(self, f: Sequence[int], g: Sequence[int]) -> None:
         """Create Fourier checking circuit.
 
         Args:
@@ -81,17 +87,72 @@ class FourierChecking(QuantumCircuit):
                 "{1, -1}."
             )
 
-        circuit = QuantumCircuit(num_qubits, name=f"fc: {f}, {g}")
-
+        # This definition circuit is not replaced by the circuit produced by fourier_checking,
+        # as the latter produces a slightly different circuit, with DiagonalGates instead
+        # of Diagonal circuits.
+        circuit = QuantumCircuit(int(num_qubits), name=f"fc: {f}, {g}")
         circuit.h(circuit.qubits)
-
         circuit.compose(Diagonal(f), inplace=True)
-
         circuit.h(circuit.qubits)
-
         circuit.compose(Diagonal(g), inplace=True)
-
         circuit.h(circuit.qubits)
-
         super().__init__(*circuit.qregs, name=circuit.name)
         self.compose(circuit.to_gate(), qubits=self.qubits, inplace=True)
+
+
+def fourier_checking(f: Sequence[int], g: Sequence[int]) -> QuantumCircuit:
+    """Fourier checking circuit.
+
+    The circuit for the Fourier checking algorithm, introduced in [1],
+    involves a layer of Hadamards, the function :math:`f`, another layer of
+    Hadamards, the function :math:`g`, followed by a final layer of Hadamards.
+    The functions :math:`f` and :math:`g` are classical functions realized
+    as phase oracles (diagonal operators with {-1, 1} on the diagonal).
+
+    The probability of observing the all-zeros string is :math:`p(f,g)`.
+    The algorithm solves the promise Fourier checking problem,
+    which decides if f is correlated with the Fourier transform
+    of g, by testing if :math:`p(f,g) <= 0.01` or :math:`p(f,g) >= 0.05`,
+    promised that one or the other of these is true.
+
+    The functions :math:`f` and :math:`g` are currently implemented
+    from their truth tables but could be represented concisely and
+    implemented efficiently for special classes of functions.
+
+    Fourier checking is a special case of :math:`k`-fold forrelation [2].
+
+    **Reference Circuit:**
+
+    .. plot::
+       :include-source:
+
+       from qiskit.circuit.library import fourier_checking
+       circuit = fourier_checking([1, -1, -1, -1], [1, 1, -1, -1])
+       circuit.draw('mpl')
+
+    **Reference:**
+
+    [1] S. Aaronson, BQP and the Polynomial Hierarchy, 2009 (Section 3.2).
+    `arXiv:0910.4698 <https://arxiv.org/abs/0910.4698>`_
+
+    [2] S. Aaronson, A. Ambainis, Forrelation: a problem that
+    optimally separates quantum from classical computing, 2014.
+    `arXiv:1411.5729 <https://arxiv.org/abs/1411.5729>`_
+    """
+    num_qubits = math.log2(len(f))
+
+    if len(f) != len(g) or num_qubits == 0 or not num_qubits.is_integer():
+        raise CircuitError(
+            "The functions f and g must be given as truth "
+            "tables, each as a list of 2**n entries of "
+            "{1, -1}."
+        )
+    num_qubits = int(num_qubits)
+
+    circuit = QuantumCircuit(num_qubits, name=f"fc: {f}, {g}")
+    circuit.h(circuit.qubits)
+    circuit.append(DiagonalGate(f), range(num_qubits))
+    circuit.h(circuit.qubits)
+    circuit.append(DiagonalGate(g), range(num_qubits))
+    circuit.h(circuit.qubits)
+    return circuit

qiskit/circuit/library/generalized_gates/__init__.py

@@ -14,7 +14,7 @@
 
 from .diagonal import Diagonal, DiagonalGate
 from .permutation import Permutation, PermutationGate
-from .mcmt import MCMT, MCMTVChain
+from .mcmt import MCMT, MCMTVChain, MCMTGate
 from .gms import GMS, MSGate
 from .gr import GR, GRX, GRY, GRZ
 from .pauli import PauliGate

qiskit/circuit/library/generalized_gates/diagonal.py

@@ -23,6 +23,8 @@ import numpy as np
 from qiskit.circuit.gate import Gate
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.exceptions import CircuitError
+from qiskit.circuit.annotated_operation import AnnotatedOperation, InverseModifier
+from qiskit.utils.deprecation import deprecate_func
 
 from .ucrz import UCRZGate
 
@@ -30,19 +32,28 @@ _EPS = 1e-10
 
 
 class Diagonal(QuantumCircuit):
-    r"""Diagonal circuit.
+    """Circuit implementing a diagonal transformation."""
 
-    Circuit symbol:
+    @deprecate_func(since="1.3", additional_msg="Use DiagonalGate instead.", pending=True)
+    def __init__(self, diag: Sequence[complex]) -> None:
+        r"""
+        Args:
+            diag: List of the :math:`2^k` diagonal entries (for a diagonal gate on :math:`k` qubits).
+
+        Raises:
+            CircuitError: if the list of the diagonal entries or the qubit list is in bad format;
+                if the number of diagonal entries is not :math:`2^k`, where :math:`k` denotes the
+                number of qubits.
+        """
+        DiagonalGate._check_input(diag)
+        num_qubits = int(math.log2(len(diag)))
+
+        super().__init__(num_qubits, name="Diagonal")
+        self.append(DiagonalGate(diag), self.qubits)
 
-    .. parsed-literal::
 
-             ┌───────────┐
-        q_0: ┤0          ├
-             │           │
-        q_1: ┤1 Diagonal ├
-             │           │
-        q_2: ┤2          ├
-             └───────────┘
+class DiagonalGate(Gate):
+    r"""A generic diagonal quantum gate.
 
     Matrix form:
 
@@ -80,30 +91,28 @@ class Diagonal(QuantumCircuit):
     def __init__(self, diag: Sequence[complex]) -> None:
         r"""
         Args:
-            diag: List of the :math:`2^k` diagonal entries (for a diagonal gate on :math:`k` qubits).
-
-        Raises:
-            CircuitError: if the list of the diagonal entries or the qubit list is in bad format;
-                if the number of diagonal entries is not :math:`2^k`, where :math:`k` denotes the
-                number of qubits.
+            diag: list of the :math:`2^k` diagonal entries (for a diagonal gate on :math:`k` qubits).
         """
         self._check_input(diag)
         num_qubits = int(math.log2(len(diag)))
 
-        circuit = QuantumCircuit(num_qubits, name="Diagonal")
+        super().__init__("diagonal", num_qubits, diag)
 
+    def _define(self):
         # Since the diagonal is a unitary, all its entries have absolute value
         # one and the diagonal is fully specified by the phases of its entries.
-        diag_phases = [cmath.phase(z) for z in diag]
-        n = len(diag)
+        diag_phases = [cmath.phase(z) for z in self.params]
+        n = len(diag_phases)
+        circuit = QuantumCircuit(self.num_qubits)
+
         while n >= 2:
             angles_rz = []
             for i in range(0, n, 2):
                 diag_phases[i // 2], rz_angle = _extract_rz(diag_phases[i], diag_phases[i + 1])
                 angles_rz.append(rz_angle)
             num_act_qubits = int(math.log2(n))
-            ctrl_qubits = list(range(num_qubits - num_act_qubits + 1, num_qubits))
-            target_qubit = num_qubits - num_act_qubits
+            ctrl_qubits = list(range(self.num_qubits - num_act_qubits + 1, self.num_qubits))
+            target_qubit = self.num_qubits - num_act_qubits
 
             ucrz = UCRZGate(angles_rz)
             circuit.append(ucrz, [target_qubit] + ctrl_qubits)
@@ -111,36 +120,7 @@ class Diagonal(QuantumCircuit):
             n //= 2
         circuit.global_phase += diag_phases[0]
 
-        super().__init__(num_qubits, name="Diagonal")
-        self.append(circuit.to_gate(), self.qubits)
-
-    @staticmethod
-    def _check_input(diag):
-        """Check if ``diag`` is in valid format."""
-        if not isinstance(diag, (list, np.ndarray)):
-            raise CircuitError("Diagonal entries must be in a list or numpy array.")
-        num_qubits = math.log2(len(diag))
-        if num_qubits < 1 or not num_qubits.is_integer():
-            raise CircuitError("The number of diagonal entries is not a positive power of 2.")
-        if not np.allclose(np.abs(diag), 1, atol=_EPS):
-            raise CircuitError("A diagonal element does not have absolute value one.")
-
-
-class DiagonalGate(Gate):
-    """Gate implementing a diagonal transformation."""
-
-    def __init__(self, diag: Sequence[complex]) -> None:
-        r"""
-        Args:
-            diag: list of the :math:`2^k` diagonal entries (for a diagonal gate on :math:`k` qubits).
-        """
-        Diagonal._check_input(diag)
-        num_qubits = int(math.log2(len(diag)))
-
-        super().__init__("diagonal", num_qubits, diag)
-
-    def _define(self):
-        self.definition = Diagonal(self.params).decompose()
+        self.definition = circuit
 
     def validate_parameter(self, parameter):
         """Diagonal Gate parameter should accept complex
@@ -152,8 +132,22 @@ class DiagonalGate(Gate):
 
     def inverse(self, annotated: bool = False):
         """Return the inverse of the diagonal gate."""
+        if annotated:
+            return AnnotatedOperation(self.copy(), InverseModifier)
+
         return DiagonalGate([np.conj(entry) for entry in self.params])
 
+    @staticmethod
+    def _check_input(diag):
+        """Check if ``diag`` is in valid format."""
+        if not isinstance(diag, (list, np.ndarray)):
+            raise CircuitError("Diagonal entries must be in a list or numpy array.")
+        num_qubits = math.log2(len(diag))
+        if num_qubits < 1 or not num_qubits.is_integer():
+            raise CircuitError("The number of diagonal entries is not a positive power of 2.")
+        if not np.allclose(np.abs(diag), 1, atol=_EPS):
+            raise CircuitError("A diagonal element does not have absolute value one.")
+
 
 def _extract_rz(phi1, phi2):
     """

qiskit/circuit/library/generalized_gates/gms.py

@@ -15,13 +15,16 @@
 Global Mølmer–Sørensen gate.
 """
 
-from typing import Union, List
+from __future__ import annotations
+from collections.abc import Sequence
 
 import numpy as np
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit.parameterexpression import ParameterValueType
 from qiskit.circuit.library.standard_gates import RXXGate
 from qiskit.circuit.gate import Gate
+from qiskit.utils.deprecation import deprecate_func
 
 
 class GMS(QuantumCircuit):
@@ -29,7 +32,7 @@ class GMS(QuantumCircuit):
 
     **Circuit symbol:**
 
-    .. parsed-literal::
+    .. code-block:: text
 
              ┌───────────┐
         q_0: ┤0          ├
@@ -74,7 +77,8 @@ class GMS(QuantumCircuit):
     `arXiv:1707.06356 <https://arxiv.org/abs/1707.06356>`_
     """
 
-    def __init__(self, num_qubits: int, theta: Union[List[List[float]], np.ndarray]) -> None:
+    @deprecate_func(since="1.3", additional_msg="Use the MSGate instead.", pending=True)
+    def __init__(self, num_qubits: int, theta: list[list[float]] | np.ndarray) -> None:
         """Create a new Global Mølmer–Sørensen (GMS) gate.
 
         Args:
@@ -94,28 +98,77 @@ class GMS(QuantumCircuit):
 
 
 class MSGate(Gate):
-    """MSGate has been deprecated.
-    Please use ``GMS`` in ``qiskit.circuit.generalized_gates`` instead.
+    r"""The Mølmer–Sørensen gate.
 
-    Global Mølmer–Sørensen gate.
+    The Mølmer–Sørensen gate is native to ion-trap systems. The global MS
+    can be applied to multiple ions to entangle multiple qubits simultaneously [1].
 
-    The Mølmer–Sørensen gate is native to ion-trap systems. The global MS can be
-    applied to multiple ions to entangle multiple qubits simultaneously.
+    In the two-qubit case, this is equivalent to an XX interaction,
+    and is thus reduced to the :class:`.RXXGate`. The global MS gate is a sum of XX
+    interactions on all pairs [2].
 
-    In the two-qubit case, this is equivalent to an XX(theta) interaction,
-    and is thus reduced to the RXXGate.
+    .. math::
+
+        MS(\chi_{12}, \chi_{13}, ..., \chi_{n-1 n}) =
+        exp(-i \sum_{i=1}^{n} \sum_{j=i+1}^{n} X{\otimes}X \frac{\chi_{ij}}{2})
+
+    Example::
+
+        import numpy as np
+        from qiskit.circuit.library import MSGate
+        from qiskit.quantum_info import Operator
+
+        gate = MSGate(num_qubits=3, theta=[[0, np.pi/4, np.pi/8],
+                                           [0, 0, np.pi/2],
+                                           [0, 0, 0]])
+        print(Operator(gate))
+
+
+    **References:**
+
+    [1] Sørensen, A. and Mølmer, K., Multi-particle entanglement of hot trapped ions.
+    Physical Review Letters. 82 (9): 1835–1838.
+    `arXiv:9810040 <https://arxiv.org/abs/quant-ph/9810040>`_
+
+    [2] Maslov, D. and Nam, Y., Use of global interactions in efficient quantum circuit
+    constructions. New Journal of Physics, 20(3), p.033018.
+    `arXiv:1707.06356 <https://arxiv.org/abs/1707.06356>`_
     """
 
-    def __init__(self, num_qubits, theta, label=None):
-        """Create new MS gate."""
+    def __init__(
+        self,
+        num_qubits: int,
+        theta: ParameterValueType | Sequence[Sequence[ParameterValueType]],
+        label: str | None = None,
+    ):
+        """
+        Args:
+            num_qubits: The number of qubits the MS gate acts on.
+            theta: The XX rotation angles. If a single value, the same angle is used on all
+                interactions. Alternatively an upper-triangular, square matrix with width
+                ``num_qubits`` can be provided with interaction angles for each qubit pair.
+            label: A gate label.
+        """
         super().__init__("ms", num_qubits, [theta], label=label)
 
     def _define(self):
-        theta = self.params[0]
-        q = QuantumRegister(self.num_qubits, "q")
+        thetas = self.params[0]
+        q = QuantumRegister(self.num_qubits, name="q")
         qc = QuantumCircuit(q, name=self.name)
         for i in range(self.num_qubits):
             for j in range(i + 1, self.num_qubits):
+                # if theta is just a single angle, use that, otherwise use the correct index
+                theta = thetas if not isinstance(thetas, Sequence) else thetas[i][j]
                 qc._append(RXXGate(theta), [q[i], q[j]], [])
 
         self.definition = qc
+
+    def validate_parameter(self, parameter):
+        if isinstance(parameter, Sequence):
+            # pylint: disable=super-with-arguments
+            return [
+                [super(MSGate, self).validate_parameter(theta) for theta in row]
+                for row in parameter
+            ]
+
+        return super().validate_parameter(parameter)

qiskit/circuit/library/generalized_gates/gr.py

@@ -21,7 +21,7 @@ class GR(QuantumCircuit):
 
     **Circuit symbol:**
 
-    .. parsed-literal::
+    .. code-block:: text
 
              ┌──────────┐
         q_0: ┤0         ├
@@ -75,7 +75,7 @@ class GRX(GR):
 
     **Circuit symbol:**
 
-    .. parsed-literal::
+    .. code-block:: text
 
              ┌──────────┐
         q_0: ┤0         ├
@@ -123,7 +123,7 @@ class GRY(GR):
 
     **Circuit symbol:**
 
-    .. parsed-literal::
+    .. code-block:: text
 
              ┌──────────┐
         q_0: ┤0         ├
@@ -171,7 +171,7 @@ class GRZ(QuantumCircuit):
 
     **Circuit symbol:**
 
-    .. parsed-literal::
+    .. code-block:: text
 
              ┌──────────┐
         q_0: ┤0         ├

qiskit/circuit/library/generalized_gates/isometry.py

@@ -31,7 +31,7 @@ from qiskit.exceptions import QiskitError
 from qiskit.quantum_info.operators.predicates import is_isometry
 from qiskit._accelerate import isometry as isometry_rs
 
-from .diagonal import Diagonal
+from .diagonal import DiagonalGate
 from .uc import UCGate
 from .mcg_up_to_diagonal import MCGupDiag
 
@@ -167,7 +167,7 @@ class Isometry(Instruction):
         if len(diag) > 1 and not isometry_rs.diag_is_identity_up_to_global_phase(
             diag, self._epsilon
         ):
-            diagonal = Diagonal(np.conj(diag))
+            diagonal = DiagonalGate(np.conj(diag))
             circuit.append(diagonal, q_input)
         return circuit
 

qiskit/circuit/library/generalized_gates/linear_function.py

@@ -17,6 +17,7 @@ import numpy as np
 from qiskit.circuit.quantumcircuit import QuantumCircuit, Gate
 from qiskit.circuit.exceptions import CircuitError
 from qiskit.circuit.library.generalized_gates.permutation import PermutationGate
+from qiskit.utils.deprecation import deprecate_func
 
 # pylint: disable=cyclic-import
 from qiskit.quantum_info import Clifford
@@ -37,7 +38,7 @@ class LinearFunction(Gate):
 
     **Example:** the circuit
 
-    .. parsed-literal::
+    .. code-block:: text
 
         q_0: ──■──
              ┌─┴─┐
@@ -67,7 +68,7 @@ class LinearFunction(Gate):
     def __init__(
         self,
         linear: (
-            list[list]
+            list[list[bool]]
             | np.ndarray[bool]
             | QuantumCircuit
             | LinearFunction
@@ -221,17 +222,22 @@ class LinearFunction(Gate):
 
     def _define(self):
         """Populates self.definition with a decomposition of this gate."""
-        self.definition = self.synthesize()
+        from qiskit.synthesis.linear import synth_cnot_count_full_pmh
+
+        self.definition = synth_cnot_count_full_pmh(self.linear)
 
+    @deprecate_func(
+        since="1.3",
+        pending=True,
+        additional_msg="Call LinearFunction.definition instead, or compile the circuit.",
+    )
     def synthesize(self):
         """Synthesizes the linear function into a quantum circuit.
 
         Returns:
             QuantumCircuit: A circuit implementing the evolution.
         """
-        from qiskit.synthesis.linear import synth_cnot_count_full_pmh
-
-        return synth_cnot_count_full_pmh(self.linear)
+        return self.definition
 
     @property
     def linear(self):