qiskit 1.3.0b1__cp39-abi3-macosx_10_9_x86_64.whl

qiskit/circuit/library/generalized_gates/__init__.py

@@ -0,0 +1,30 @@
+# 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 circuit library module on generalized gates."""
+
+from .diagonal import Diagonal, DiagonalGate
+from .permutation import Permutation, PermutationGate
+from .mcmt import MCMT, MCMTVChain
+from .gms import GMS, MSGate
+from .gr import GR, GRX, GRY, GRZ
+from .pauli import PauliGate
+from .rv import RVGate
+from .linear_function import LinearFunction
+from .isometry import Isometry
+from .uc import UCGate
+from .uc_pauli_rot import UCPauliRotGate
+from .ucrx import UCRXGate
+from .ucry import UCRYGate
+from .ucrz import UCRZGate
+from .unitary import UnitaryGate
+from .mcg_up_to_diagonal import MCGupDiag

qiskit/circuit/library/generalized_gates/diagonal.py

@@ -0,0 +1,165 @@
+# 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.
+
+
+"""Diagonal matrix circuit."""
+
+from __future__ import annotations
+from collections.abc import Sequence
+
+import cmath
+import math
+import numpy as np
+
+from qiskit.circuit.gate import Gate
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.exceptions import CircuitError
+
+from .ucrz import UCRZGate
+
+_EPS = 1e-10
+
+
+class Diagonal(QuantumCircuit):
+    r"""Diagonal circuit.
+
+    Circuit symbol:
+
+    .. parsed-literal::
+
+             ┌───────────┐
+        q_0: ┤0          ├
+             │           │
+        q_1: ┤1 Diagonal ├
+             │           │
+        q_2: ┤2          ├
+             └───────────┘
+
+    Matrix form:
+
+    .. math::
+        \text{DiagonalGate}\ q_0, q_1, .., q_{n-1} =
+            \begin{pmatrix}
+                D[0]    & 0         & \dots     & 0 \\
+                0       & D[1]      & \dots     & 0 \\
+                \vdots  & \vdots    & \ddots    & 0 \\
+                0       & 0         & \dots     & D[n-1]
+            \end{pmatrix}
+
+    Diagonal gates are useful as representations of Boolean functions,
+    as they can map from :math:`\{0,1\}^{2^n}` to :math:`\{0,1\}^{2^n}` space. For example a phase
+    oracle can be seen as a diagonal gate with :math:`\{1, -1\}` on the diagonals. Such
+    an oracle will induce a :math:`+1` or :math`-1` phase on the amplitude of any corresponding
+    basis state.
+
+    Diagonal gates appear in many classically hard oracular problems such as
+    Forrelation or Hidden Shift circuits.
+
+    Diagonal gates are represented and simulated more efficiently than a dense
+    :math:`2^n \times 2^n` unitary matrix.
+
+    The reference implementation is via the method described in
+    Theorem 7 of [1]. The code is based on Emanuel Malvetti's semester thesis
+    at ETH in 2018, supervised by Raban Iten and Prof. Renato Renner.
+
+    **Reference:**
+
+    [1] Shende et al., Synthesis of Quantum Logic Circuits, 2009
+    `arXiv:0406176 <https://arxiv.org/pdf/quant-ph/0406176.pdf>`_
+    """
+
+    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.
+        """
+        self._check_input(diag)
+        num_qubits = int(math.log2(len(diag)))
+
+        circuit = QuantumCircuit(num_qubits, name="Diagonal")
+
+        # 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)
+        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
+
+            ucrz = UCRZGate(angles_rz)
+            circuit.append(ucrz, [target_qubit] + ctrl_qubits)
+
+            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()
+
+    def validate_parameter(self, parameter):
+        """Diagonal Gate parameter should accept complex
+        (in addition to the Gate parameter types) and always return build-in complex."""
+        if isinstance(parameter, complex):
+            return complex(parameter)
+        else:
+            return complex(super().validate_parameter(parameter))
+
+    def inverse(self, annotated: bool = False):
+        """Return the inverse of the diagonal gate."""
+        return DiagonalGate([np.conj(entry) for entry in self.params])
+
+
+def _extract_rz(phi1, phi2):
+    """
+    Extract a Rz rotation (angle given by first output) such that exp(j*phase)*Rz(z_angle)
+    is equal to the diagonal matrix with entires exp(1j*ph1) and exp(1j*ph2).
+    """
+    phase = (phi1 + phi2) / 2.0
+    z_angle = phi2 - phi1
+    return phase, z_angle

qiskit/circuit/library/generalized_gates/gms.py

@@ -0,0 +1,121 @@
+# 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 typing import Union, List
+
+import numpy as np
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit.library.standard_gates import RXXGate
+from qiskit.circuit.gate import Gate
+
+
+class GMS(QuantumCircuit):
+    r"""Global Mølmer–Sørensen gate.
+
+    **Circuit symbol:**
+
+    .. parsed-literal::
+
+             ┌───────────┐
+        q_0: ┤0          ├
+             │           │
+        q_1: ┤1   GMS    ├
+             │           │
+        q_2: ┤2          ├
+             └───────────┘
+
+    **Expanded Circuit:**
+
+    .. plot::
+
+       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>`_
+    """
+
+    def __init__(self, num_qubits: int, theta: Union[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):
+    """MSGate has been deprecated.
+    Please use ``GMS`` in ``qiskit.circuit.generalized_gates`` instead.
+
+    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.
+
+    In the two-qubit case, this is equivalent to an XX(theta) interaction,
+    and is thus reduced to the RXXGate.
+    """
+
+    def __init__(self, num_qubits, theta, label=None):
+        """Create new MS gate."""
+        super().__init__("ms", num_qubits, [theta], label=label)
+
+    def _define(self):
+        theta = self.params[0]
+        q = QuantumRegister(self.num_qubits, "q")
+        qc = QuantumCircuit(q, name=self.name)
+        for i in range(self.num_qubits):
+            for j in range(i + 1, self.num_qubits):
+                qc._append(RXXGate(theta), [q[i], q[j]], [])
+
+        self.definition = qc

qiskit/circuit/library/generalized_gates/gr.py

@@ -0,0 +1,215 @@
+# 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:**
+
+    .. parsed-literal::
+
+             ┌──────────┐
+        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::
+
+       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:**
+
+    .. parsed-literal::
+
+             ┌──────────┐
+        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::
+
+        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:**
+
+    .. parsed-literal::
+
+             ┌──────────┐
+        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::
+
+       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:**
+
+    .. parsed-literal::
+
+             ┌──────────┐
+        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::
+
+       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)