qiskit 2.0.3__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/quantum_info/operators/utils/__init__.py

@@ -0,0 +1,20 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2023.
+#
+# 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 information utility functions for operators.
+"""
+
+from __future__ import annotations
+from .anti_commutator import anti_commutator
+from .commutator import commutator
+from .double_commutator import double_commutator

qiskit/quantum_info/operators/utils/anti_commutator.py

@@ -0,0 +1,36 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2023.
+#
+# 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.
+
+"""Anti commutator function."""
+
+from __future__ import annotations
+from typing import TypeVar
+
+from qiskit.quantum_info.operators.linear_op import LinearOp
+
+OperatorTypeT = TypeVar("OperatorTypeT", bound=LinearOp)
+
+
+def anti_commutator(a: OperatorTypeT, b: OperatorTypeT) -> OperatorTypeT:
+    r"""Compute anti-commutator of a and b.
+
+    .. math::
+
+        ab + ba.
+
+    Args:
+        a: Operator a.
+        b: Operator b.
+    Returns:
+        The anti-commutator
+    """
+    return a @ b + b @ a

qiskit/quantum_info/operators/utils/commutator.py

@@ -0,0 +1,36 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2023.
+#
+# 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.
+
+"""Commutator function."""
+
+from __future__ import annotations
+from typing import TypeVar
+
+from qiskit.quantum_info.operators.linear_op import LinearOp
+
+OperatorTypeT = TypeVar("OperatorTypeT", bound=LinearOp)
+
+
+def commutator(a: OperatorTypeT, b: OperatorTypeT) -> OperatorTypeT:
+    r"""Compute commutator of a and b.
+
+    .. math::
+
+        ab - ba.
+
+    Args:
+        a: Operator a.
+        b: Operator b.
+    Returns:
+        The commutator
+    """
+    return a @ b - b @ a

qiskit/quantum_info/operators/utils/double_commutator.py

@@ -0,0 +1,76 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2023.
+#
+# 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.
+
+"""Double commutator function."""
+
+from __future__ import annotations
+from typing import TypeVar
+
+from qiskit.quantum_info.operators.linear_op import LinearOp
+
+OperatorTypeT = TypeVar("OperatorTypeT", bound=LinearOp)
+
+
+def double_commutator(
+    a: OperatorTypeT, b: OperatorTypeT, c: OperatorTypeT, *, commutator: bool = True
+) -> OperatorTypeT:
+    r"""Compute symmetric double commutator of a, b and c.
+
+    See also Equation (13.6.18) in [1].
+
+    If `commutator` is `True`, it returns
+
+    .. math::
+
+         [[A, B], C]/2 + [A, [B, C]]/2
+         = (2ABC + 2CBA - BAC - CAB - ACB - BCA)/2.
+
+    If `commutator` is `False`, it returns
+
+    .. math::
+         \lbrace[A, B], C\rbrace/2 + \lbrace A, [B, C]\rbrace/2
+         = (2ABC - 2CBA - BAC + CAB - ACB + BCA)/2.
+
+    Args:
+        a: Operator a.
+        b: Operator b.
+        c: Operator c.
+        commutator: If ``True`` compute the double commutator,
+            if ``False`` the double anti-commutator.
+
+    Returns:
+        The double commutator
+
+    References:
+
+        [1]: R. McWeeny.
+            Methods of Molecular Quantum Mechanics.
+            2nd Edition, Academic Press, 1992.
+            ISBN 0-12-486552-6.
+    """
+    sign_num = -1 if commutator else 1
+
+    ab = a @ b
+    ba = b @ a
+    ac = a @ c
+    ca = c @ a
+
+    abc = ab @ c
+    cba = c @ ba
+    bac = ba @ c
+    cab = c @ ab
+    acb = ac @ b
+    bca = b @ ca
+
+    res = abc - sign_num * cba + 0.5 * (-bac + sign_num * cab - acb + sign_num * bca)
+
+    return res

qiskit/quantum_info/quaternion.py

@@ -0,0 +1,156 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017.
+#
+# 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.
+
+"""
+A module for using quaternions.
+"""
+from __future__ import annotations
+import math
+import numpy as np
+
+
+class Quaternion:
+    """A class representing a Quaternion."""
+
+    def __init__(self, data):
+        self.data = np.asarray(data, dtype=float)
+
+    def __call__(self, idx):
+        return self.data[idx]
+
+    def __repr__(self):
+        return np.array_str(self.data)
+
+    def __str__(self):
+        return np.array_str(self.data)
+
+    def __mul__(self, r):
+        if isinstance(r, Quaternion):
+            q = self
+            out_data = np.zeros(4, dtype=float)
+            out_data[0] = r(0) * q(0) - r(1) * q(1) - r(2) * q(2) - r(3) * q(3)
+            out_data[1] = r(0) * q(1) + r(1) * q(0) - r(2) * q(3) + r(3) * q(2)
+            out_data[2] = r(0) * q(2) + r(1) * q(3) + r(2) * q(0) - r(3) * q(1)
+            out_data[3] = r(0) * q(3) - r(1) * q(2) + r(2) * q(1) + r(3) * q(0)
+            return Quaternion(out_data)
+        else:
+            return NotImplemented
+
+    def norm(self):
+        """Norm of quaternion."""
+        import scipy.linalg as la
+
+        return la.norm(self.data)
+
+    def normalize(self, inplace: bool = False) -> Quaternion:
+        """Normalizes a Quaternion to unit length
+        so that it represents a valid rotation.
+
+        Args:
+            inplace (bool): Do an inplace normalization.
+
+        Returns:
+            Quaternion: Normalized quaternion.
+        """
+        if inplace:
+            nrm = self.norm()
+            self.data /= nrm
+            return None
+        nrm = self.norm()
+        data_copy = np.array(self.data, copy=True)
+        data_copy /= nrm
+        return Quaternion(data_copy)
+
+    def to_matrix(self) -> np.ndarray:
+        """Converts a unit-length quaternion to a rotation matrix.
+
+        Returns:
+            ndarray: Rotation matrix.
+        """
+        w, x, y, z = self.normalize().data
+        mat = np.array(
+            [
+                [1 - 2 * y**2 - 2 * z**2, 2 * x * y - 2 * z * w, 2 * x * z + 2 * y * w],
+                [2 * x * y + 2 * z * w, 1 - 2 * x**2 - 2 * z**2, 2 * y * z - 2 * x * w],
+                [2 * x * z - 2 * y * w, 2 * y * z + 2 * x * w, 1 - 2 * x**2 - 2 * y**2],
+            ],
+            dtype=float,
+        )
+        return mat
+
+    def to_zyz(self) -> np.ndarray:
+        """Converts a unit-length quaternion to a sequence
+        of ZYZ Euler angles.
+
+        Returns:
+            ndarray: Array of Euler angles.
+        """
+        mat = self.to_matrix()
+        euler = np.zeros(3, dtype=float)
+        if mat[2, 2] < 1:
+            if mat[2, 2] > -1:
+                euler[0] = math.atan2(mat[1, 2], mat[0, 2])
+                euler[1] = math.acos(mat[2, 2])
+                euler[2] = math.atan2(mat[2, 1], -mat[2, 0])
+            else:
+                euler[0] = -math.atan2(mat[1, 0], mat[1, 1])
+                euler[1] = np.pi
+        else:
+            euler[0] = math.atan2(mat[1, 0], mat[1, 1])
+        return euler
+
+    @classmethod
+    def from_axis_rotation(cls, angle: float, axis: str) -> Quaternion:
+        """Return quaternion for rotation about given axis.
+
+        Args:
+            angle (float): Angle in radians.
+            axis (str): Axis for rotation
+
+        Returns:
+            Quaternion: Quaternion for axis rotation.
+
+        Raises:
+            ValueError: Invalid input axis.
+        """
+        out = np.zeros(4, dtype=float)
+        if axis == "x":
+            out[1] = 1
+        elif axis == "y":
+            out[2] = 1
+        elif axis == "z":
+            out[3] = 1
+        else:
+            raise ValueError("Invalid axis input.")
+        out *= math.sin(angle / 2.0)
+        out[0] = math.cos(angle / 2.0)
+        return cls(out)
+
+    @classmethod
+    def from_euler(cls, angles: list | np.ndarray, order: str = "yzy") -> Quaternion:
+        """Generate a quaternion from a set of Euler angles.
+
+        Args:
+            angles (array_like): Array of Euler angles.
+            order (str): Order of Euler rotations.  'yzy' is default.
+
+        Returns:
+            Quaternion: Quaternion representation of Euler rotation.
+        """
+        angles = np.asarray(angles, dtype=float)
+        quat = (
+            cls.from_axis_rotation(angles[0], order[0])
+            * cls.from_axis_rotation(angles[1], order[1])
+            * cls.from_axis_rotation(angles[2], order[2])
+        )
+        quat.normalize(inplace=True)
+        return quat

qiskit/quantum_info/random.py

@@ -0,0 +1,26 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+"""Methods for generating random quantum information objects."""
+
+# pylint: disable=unused-import
+from __future__ import annotations
+from qiskit.quantum_info.operators.random import (
+    random_clifford,
+    random_cnotdihedral,
+    random_hermitian,
+    random_pauli,
+    random_pauli_list,
+    random_quantum_channel,
+    random_unitary,
+)
+from qiskit.quantum_info.states.random import random_density_matrix, random_statevector

qiskit/quantum_info/states/__init__.py

@@ -0,0 +1,28 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+"""Quantum States."""
+
+from __future__ import annotations
+from .statevector import Statevector
+from .stabilizerstate import StabilizerState
+from .densitymatrix import DensityMatrix
+from .utils import partial_trace, schmidt_decomposition, shannon_entropy
+from .measures import (
+    state_fidelity,
+    purity,
+    entropy,
+    concurrence,
+    mutual_information,
+    entanglement_of_formation,
+    negativity,
+)