qiskit 2.0.3__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/circuit/library/generalized_gates/gms.py

@@ -0,0 +1,175 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2019.
+#
+# 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.
+
+
+"""
+Global Mølmer–Sørensen gate.
+"""
+
+from __future__ import annotations
+from collections.abc import Sequence
+
+import numpy as np
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit 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):
+    r"""Global Mølmer–Sørensen gate.
+
+    **Circuit symbol:**
+
+    .. code-block:: text
+
+             ┌───────────┐
+        q_0: ┤0          ├
+             │           │
+        q_1: ┤1   GMS    ├
+             │           │
+        q_2: ┤2          ├
+             └───────────┘
+
+    **Expanded Circuit:**
+
+    .. plot::
+       :alt: Diagram illustrating the previously described circuit.
+
+       from qiskit.circuit.library import GMS
+       from qiskit.visualization.library import _generate_circuit_library_visualization
+       import numpy as np
+       circuit = GMS(num_qubits=3, theta=[[0, np.pi/4, np.pi/8],
+                                          [0, 0, np.pi/2],
+                                          [0, 0, 0]])
+       _generate_circuit_library_visualization(circuit.decompose())
+
+    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].
+
+    In the two-qubit case, this is equivalent to an XX(theta) interaction,
+    and is thus reduced to the RXXGate. The global MS gate is a sum of XX
+    interactions on all pairs [2].
+
+    .. math::
+
+        GMS(\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})
+
+    **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>`_
+    """
+
+    @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:
+            num_qubits: width of gate.
+            theta: a num_qubits x num_qubits symmetric matrix of
+                interaction angles for each qubit pair. The upper
+                triangle is considered.
+        """
+        super().__init__(num_qubits, name="gms")
+        if not isinstance(theta, list):
+            theta = [theta] * int((num_qubits**2 - 1) / 2)
+        gms = QuantumCircuit(num_qubits, name="gms")
+        for i in range(self.num_qubits):
+            for j in range(i + 1, self.num_qubits):
+                gms.append(RXXGate(theta[i][j]), [i, j])
+        self.append(gms.to_gate(), self.qubits)
+
+
+class MSGate(Gate):
+    r"""The 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].
+
+    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].
+
+    .. 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: 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):
+        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

@@ -0,0 +1,219 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+
+"""Global R gates."""
+
+import numpy as np
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+
+
+class GR(QuantumCircuit):
+    r"""Global R gate.
+
+    **Circuit symbol:**
+
+    .. code-block:: text
+
+             ┌──────────┐
+        q_0: ┤0         ├
+             │          │
+        q_1: ┤1 GR(ϴ,φ) ├
+             │          │
+        q_2: ┤2         ├
+             └──────────┘
+
+    The global R gate is native to atomic systems (ion traps, cold neutrals). The global R
+    can be applied to multiple qubits simultaneously.
+
+    In the one-qubit case, this is equivalent to an R(theta, phi) operation,
+    and is thus reduced to the RGate. The global R gate is a direct sum of R
+    operations on all individual qubits.
+
+    .. math::
+
+        GR(\theta, \phi) = \exp(-i \sum_{i=1}^{n} (\cos(\phi)X_i + \sin(\phi)Y_i) \theta/2)
+
+    **Expanded Circuit:**
+
+    .. plot::
+       :alt: Diagram illustrating the previously described circuit.
+
+       from qiskit.circuit.library import GR
+       from qiskit.visualization.library import _generate_circuit_library_visualization
+       import numpy as np
+       circuit = GR(num_qubits=3, theta=np.pi/4, phi=np.pi/2)
+       _generate_circuit_library_visualization(circuit)
+
+    """
+
+    def __init__(self, num_qubits: int, theta: float, phi: float) -> None:
+        """Create a new Global R (GR) gate.
+
+        Args:
+            num_qubits: number of qubits.
+            theta: rotation angle about axis determined by phi
+            phi: angle of rotation axis in xy-plane
+        """
+        name = f"GR({theta:.2f}, {phi:.2f})"
+        circuit = QuantumCircuit(num_qubits, name=name)
+        circuit.r(theta, phi, circuit.qubits)
+
+        super().__init__(num_qubits, name=name)
+        self.append(circuit.to_gate(), self.qubits)
+
+
+class GRX(GR):
+    r"""Global RX gate.
+
+    **Circuit symbol:**
+
+    .. code-block:: text
+
+             ┌──────────┐
+        q_0: ┤0         ├
+             │          │
+        q_1: ┤1  GRX(ϴ) ├
+             │          │
+        q_2: ┤2         ├
+             └──────────┘
+
+    The global RX gate is native to atomic systems (ion traps, cold neutrals). The global RX
+    can be applied to multiple qubits simultaneously.
+
+    In the one-qubit case, this is equivalent to an RX(theta) operations,
+    and is thus reduced to the RXGate. The global RX gate is a direct sum of RX
+    operations on all individual qubits.
+
+    .. math::
+
+        GRX(\theta) = \exp(-i \sum_{i=1}^{n} X_i \theta/2)
+
+    **Expanded Circuit:**
+
+    .. plot::
+       :alt: Diagram illustrating the previously described circuit.
+
+        from qiskit.circuit.library import GRX
+        from qiskit.visualization.library import _generate_circuit_library_visualization
+        import numpy as np
+        circuit = GRX(num_qubits=3, theta=np.pi/4)
+        _generate_circuit_library_visualization(circuit)
+
+    """
+
+    def __init__(self, num_qubits: int, theta: float) -> None:
+        """Create a new Global RX (GRX) gate.
+
+        Args:
+            num_qubits: number of qubits.
+            theta: rotation angle about x-axis
+        """
+        super().__init__(num_qubits, theta, phi=0)
+
+
+class GRY(GR):
+    r"""Global RY gate.
+
+    **Circuit symbol:**
+
+    .. code-block:: text
+
+             ┌──────────┐
+        q_0: ┤0         ├
+             │          │
+        q_1: ┤1  GRY(ϴ) ├
+             │          │
+        q_2: ┤2         ├
+             └──────────┘
+
+    The global RY gate is native to atomic systems (ion traps, cold neutrals). The global RY
+    can be applied to multiple qubits simultaneously.
+
+    In the one-qubit case, this is equivalent to an RY(theta) operation,
+    and is thus reduced to the RYGate. The global RY gate is a direct sum of RY
+    operations on all individual qubits.
+
+    .. math::
+
+        GRY(\theta) = \exp(-i \sum_{i=1}^{n} Y_i \theta/2)
+
+    **Expanded Circuit:**
+
+    .. plot::
+       :alt: Diagram illustrating the previously described circuit.
+
+       from qiskit.circuit.library import GRY
+       from qiskit.visualization.library import _generate_circuit_library_visualization
+       import numpy as np
+       circuit = GRY(num_qubits=3, theta=np.pi/4)
+       _generate_circuit_library_visualization(circuit)
+
+    """
+
+    def __init__(self, num_qubits: int, theta: float) -> None:
+        """Create a new Global RY (GRY) gate.
+
+        Args:
+            num_qubits: number of qubits.
+            theta: rotation angle about y-axis
+        """
+        super().__init__(num_qubits, theta, phi=np.pi / 2)
+
+
+class GRZ(QuantumCircuit):
+    r"""Global RZ gate.
+
+    **Circuit symbol:**
+
+    .. code-block:: text
+
+             ┌──────────┐
+        q_0: ┤0         ├
+             │          │
+        q_1: ┤1  GRZ(φ) ├
+             │          │
+        q_2: ┤2         ├
+             └──────────┘
+
+    The global RZ gate is native to atomic systems (ion traps, cold neutrals). The global RZ
+    can be applied to multiple qubits simultaneously.
+
+    In the one-qubit case, this is equivalent to an RZ(phi) operation,
+    and is thus reduced to the RZGate. The global RZ gate is a direct sum of RZ
+    operations on all individual qubits.
+
+    .. math::
+
+        GRZ(\phi) = \exp(-i \sum_{i=1}^{n} Z_i \phi)
+
+    **Expanded Circuit:**
+
+    .. plot::
+       :alt: Diagram illustrating the previously described circuit.
+
+       from qiskit.circuit.library import GRZ
+       from qiskit.visualization.library import _generate_circuit_library_visualization
+       import numpy as np
+       circuit = GRZ(num_qubits=3, phi=np.pi/2)
+       _generate_circuit_library_visualization(circuit)
+
+    """
+
+    def __init__(self, num_qubits: int, phi: float) -> None:
+        """Create a new Global RZ (GRZ) gate.
+
+        Args:
+            num_qubits: number of qubits.
+            phi: rotation angle about z-axis
+        """
+        super().__init__(num_qubits, name="grz")
+        self.rz(phi, self.qubits)