qiskit 2.0.3__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/quantum_info/operators/operator_utils.py

@@ -0,0 +1,76 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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
+# 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.
+
+"""
+Additional utilities for Operators.
+"""
+
+from __future__ import annotations
+
+from qiskit.quantum_info import Operator
+from qiskit.quantum_info.operators.predicates import matrix_equal
+
+
+def _equal_with_ancillas(
+    op1: Operator,
+    op2: Operator,
+    ancilla_qubits: list[int],
+    ignore_phase: bool = False,
+    rtol: float | None = None,
+    atol: float | None = None,
+) -> bool:
+    r"""Test if two Operators are equal on the subspace where ancilla qubits
+    are :math:`|0\rangle`.
+
+    Args:
+        op1 (Operator): an operator object.
+        op2 (Operator): an operator object.
+        ancilla_qubits (list[int]): a list of clean ancilla qubits.
+        ignore_phase (bool): ignore complex-phase difference between matrices.
+        rtol (float): relative tolerance value for comparison.
+        atol (float): absolute tolerance value for comparison.
+
+    Returns:
+        bool: True iff operators are equal up to clean ancilla qubits.
+    """
+    if op1.dim != op2.dim:
+        return False
+
+    if atol is None:
+        atol = op1.atol
+    if rtol is None:
+        rtol = op1.rtol
+
+    num_qubits = op1._op_shape._num_qargs_l
+    num_non_ancillas = num_qubits - len(ancilla_qubits)
+
+    # Find a permutation that moves all ancilla qubits to the back
+    pattern = []
+    ancillas = []
+    for q in range(num_qubits):
+        if q not in ancilla_qubits:
+            pattern.append(q)
+        else:
+            ancillas.append(q)
+    pattern = pattern + ancillas
+
+    # Apply this permutation to both operators
+    permuted1 = op1.apply_permutation(pattern)
+    permuted2 = op2.apply_permutation(pattern)
+
+    # Restrict to the subspace where ancillas are 0
+    restricted1 = permuted1.data[: 2**num_non_ancillas, : 2**num_qubits]
+    restricted2 = permuted2.data[: 2**num_non_ancillas, : 2**num_qubits]
+
+    return matrix_equal(
+        restricted1, restricted2.data, ignore_phase=ignore_phase, rtol=rtol, atol=atol
+    )

qiskit/quantum_info/operators/predicates.py

@@ -0,0 +1,183 @@
+# 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.
+
+"""
+Predicates for operators.
+"""
+
+from __future__ import annotations
+import numpy as np
+
+ATOL_DEFAULT = 1e-8
+RTOL_DEFAULT = 1e-5
+
+
+def matrix_equal(mat1, mat2, ignore_phase=False, rtol=RTOL_DEFAULT, atol=ATOL_DEFAULT, props=None):
+    # pylint: disable-next=consider-using-f-string
+    """Test if two arrays are equal.
+
+    The final comparison is implemented using Numpy.allclose. See its
+    documentation for additional information on tolerance parameters.
+
+    If ignore_phase is True both matrices will be multiplied by
+    exp(-1j * theta) where `theta` is the first nphase for a
+    first non-zero matrix element `|a| * exp(1j * theta)`.
+
+    Args:
+        mat1 (matrix_like): a matrix
+        mat2 (matrix_like): a matrix
+        ignore_phase (bool): ignore complex-phase differences between
+            matrices [Default: False]
+        rtol (double): the relative tolerance parameter [Default {}].
+        atol (double): the absolute tolerance parameter [Default {}].
+        props (dict | None): if not ``None`` and ``ignore_phase`` is ``True``
+            returns the phase difference between the two matrices under
+            ``props['phase_difference']``
+
+    Returns:
+        bool: True if the matrices are equal or False otherwise.
+    """.format(
+        RTOL_DEFAULT, ATOL_DEFAULT
+    )
+
+    if atol is None:
+        atol = ATOL_DEFAULT
+    if rtol is None:
+        rtol = RTOL_DEFAULT
+
+    if not isinstance(mat1, np.ndarray):
+        mat1 = np.array(mat1)
+    if not isinstance(mat2, np.ndarray):
+        mat2 = np.array(mat2)
+
+    if mat1.shape != mat2.shape:
+        return False
+
+    if ignore_phase:
+        phase_difference = 0
+
+        # Get phase of first non-zero entry of mat1 and mat2
+        # and multiply all entries by the conjugate
+        for elt in mat1.flat:
+            if abs(elt) > atol:
+                angle = np.angle(elt)
+                phase_difference -= angle
+                mat1 = np.exp(-1j * angle) * mat1
+                break
+        for elt in mat2.flat:
+            if abs(elt) > atol:
+                angle = np.angle(elt)
+                phase_difference += angle
+                mat2 = np.exp(-1j * np.angle(elt)) * mat2
+                break
+        if props is not None:
+            props["phase_difference"] = phase_difference
+
+    return np.allclose(mat1, mat2, rtol=rtol, atol=atol)
+
+
+def is_square_matrix(mat):
+    """Test if an array is a square matrix."""
+    mat = np.array(mat)
+    if mat.ndim != 2:
+        return False
+    shape = mat.shape
+    return shape[0] == shape[1]
+
+
+def is_diagonal_matrix(mat, rtol=RTOL_DEFAULT, atol=ATOL_DEFAULT):
+    """Test if an array is a diagonal matrix"""
+    if atol is None:
+        atol = ATOL_DEFAULT
+    if rtol is None:
+        rtol = RTOL_DEFAULT
+    mat = np.array(mat)
+    if mat.ndim != 2:
+        return False
+    return np.allclose(mat, np.diag(np.diagonal(mat)), rtol=rtol, atol=atol)
+
+
+def is_symmetric_matrix(op, rtol=RTOL_DEFAULT, atol=ATOL_DEFAULT):
+    """Test if an array is a symmetric matrix"""
+    if atol is None:
+        atol = ATOL_DEFAULT
+    if rtol is None:
+        rtol = RTOL_DEFAULT
+    mat = np.array(op)
+    if mat.ndim != 2:
+        return False
+    return np.allclose(mat, mat.T, rtol=rtol, atol=atol)
+
+
+def is_hermitian_matrix(mat, rtol=RTOL_DEFAULT, atol=ATOL_DEFAULT):
+    """Test if an array is a Hermitian matrix"""
+    if atol is None:
+        atol = ATOL_DEFAULT
+    if rtol is None:
+        rtol = RTOL_DEFAULT
+    mat = np.array(mat)
+    if mat.ndim != 2:
+        return False
+    return np.allclose(mat, np.conj(mat.T), rtol=rtol, atol=atol)
+
+
+def is_positive_semidefinite_matrix(mat, rtol=RTOL_DEFAULT, atol=ATOL_DEFAULT):
+    """Test if a matrix is positive semidefinite"""
+    if atol is None:
+        atol = ATOL_DEFAULT
+    if rtol is None:
+        rtol = RTOL_DEFAULT
+    if not is_hermitian_matrix(mat, rtol=rtol, atol=atol):
+        return False
+    # Check eigenvalues are all positive
+    vals = np.linalg.eigvalsh(mat)
+    for v in vals:
+        if v < -atol:
+            return False
+    return True
+
+
+def is_identity_matrix(mat, ignore_phase=False, rtol=RTOL_DEFAULT, atol=ATOL_DEFAULT):
+    """Test if an array is an identity matrix."""
+    if atol is None:
+        atol = ATOL_DEFAULT
+    if rtol is None:
+        rtol = RTOL_DEFAULT
+    mat = np.array(mat)
+    if mat.ndim != 2:
+        return False
+    if ignore_phase:
+        # If the matrix is equal to an identity up to a phase, we can
+        # remove the phase by multiplying each entry by the complex
+        # conjugate of the phase of the [0, 0] entry.
+        theta = np.angle(mat[0, 0])
+        mat = np.exp(-1j * theta) * mat
+    # Check if square identity
+    iden = np.eye(len(mat))
+    return np.allclose(mat, iden, rtol=rtol, atol=atol)
+
+
+def is_unitary_matrix(mat, rtol=RTOL_DEFAULT, atol=ATOL_DEFAULT):
+    """Test if an array is a unitary matrix."""
+    mat = np.array(mat)
+    # Compute A^dagger.A and see if it is identity matrix
+    mat = np.conj(mat.T).dot(mat)
+    return is_identity_matrix(mat, ignore_phase=False, rtol=rtol, atol=atol)
+
+
+def is_isometry(mat, rtol=RTOL_DEFAULT, atol=ATOL_DEFAULT):
+    """Test if an array is an isometry."""
+    mat = np.array(mat)
+    # Compute A^dagger.A and see if it is identity matrix
+    iden = np.eye(mat.shape[1])
+    mat = np.conj(mat.T).dot(mat)
+    return np.allclose(mat, iden, rtol=rtol, atol=atol)

qiskit/quantum_info/operators/random.py

@@ -0,0 +1,154 @@
+# 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.
+
+"""
+Methods to create random operators.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from numpy.random import default_rng
+
+from qiskit.exceptions import QiskitError
+from qiskit.quantum_info.operators import Operator, Stinespring
+
+# pylint: disable=unused-import
+from .dihedral.random import random_cnotdihedral
+from .symplectic.random import random_clifford, random_pauli, random_pauli_list
+
+DEFAULT_RNG = default_rng()
+
+
+def random_unitary(dims: int | tuple, seed: int | np.random.Generator | None = None):
+    """Return a random unitary Operator.
+
+    The operator is sampled from the unitary Haar measure.
+
+    Args:
+        dims (int or tuple): the input dimensions of the Operator.
+        seed (int or np.random.Generator): Optional. Set a fixed seed or
+                                           generator for RNG.
+
+    Returns:
+        Operator: a unitary operator.
+    """
+    if seed is None:
+        random_state = DEFAULT_RNG
+    elif isinstance(seed, np.random.Generator):
+        random_state = seed
+    else:
+        random_state = default_rng(seed)
+
+    dim = np.prod(dims)
+    from scipy import stats
+
+    mat = stats.unitary_group.rvs(dim, random_state=random_state)
+    return Operator(mat, input_dims=dims, output_dims=dims)
+
+
+def random_hermitian(
+    dims: int | tuple, traceless: bool = False, seed: int | np.random.Generator | None = None
+):
+    """Return a random hermitian Operator.
+
+    The operator is sampled from Gaussian Unitary Ensemble.
+
+    Args:
+        dims (int or tuple): the input dimension of the Operator.
+        traceless (bool): Optional. If True subtract diagonal entries to
+                          return a traceless hermitian operator
+                          (Default: False).
+        seed (int or np.random.Generator): Optional. Set a fixed seed or
+                                           generator for RNG.
+
+    Returns:
+        Operator: a Hermitian operator.
+    """
+    if seed is None:
+        rng = DEFAULT_RNG
+    elif isinstance(seed, np.random.Generator):
+        rng = seed
+    else:
+        rng = default_rng(seed)
+
+    # Total dimension
+    dim = np.prod(dims)
+    from scipy import stats
+
+    if traceless:
+        mat = np.zeros((dim, dim), dtype=complex)
+    else:
+        # Generate diagonal part of matrix for Gaussian N(0, 1)
+        mat = np.diag(stats.norm.rvs(scale=1, size=dim, random_state=rng).astype(complex))
+
+    # Generate lower triangular values from Gaussian N(0, 0.5)
+    num_tril = (dim * (dim - 1)) // 2
+    real_tril = stats.norm.rvs(scale=0.5, size=num_tril, random_state=rng)
+    imag_tril = stats.norm.rvs(scale=0.5, size=num_tril, random_state=rng)
+    # Get lower triangular indices
+    rows, cols = np.tril_indices(dim, -1)
+    mat[(rows, cols)] = real_tril + 1j * imag_tril
+    mat[(cols, rows)] = real_tril - 1j * imag_tril
+    return Operator(mat, input_dims=dims, output_dims=dims)
+
+
+def random_quantum_channel(
+    input_dims: int | tuple | None = None,
+    output_dims: int | tuple | None = None,
+    rank: int | None = None,
+    seed: int | np.random.Generator | None = None,
+):
+    """Return a random CPTP quantum channel.
+
+    This constructs the Stinespring operator for the quantum channel by
+    sampling a random isometry from the unitary Haar measure.
+
+    Args:
+        input_dims (int or tuple): the input dimension of the channel.
+        output_dims (int or tuple): the input dimension of the channel.
+        rank (int): Optional. The rank of the quantum channel Choi-matrix.
+        seed (int or np.random.Generator): Optional. Set a fixed seed or
+                                           generator for RNG.
+
+    Returns:
+        Stinespring: a quantum channel operator.
+
+    Raises:
+        QiskitError: if rank or dimensions are invalid.
+    """
+    # Determine total input and output dimensions
+    if input_dims is None and output_dims is None:
+        raise QiskitError(
+            "No dimensions specified: input_dims and output_dims cannot both be None."
+        )
+    if input_dims is None:
+        input_dims = output_dims
+    elif output_dims is None:
+        output_dims = input_dims
+
+    d_in = np.prod(input_dims)
+    d_out = np.prod(output_dims)
+
+    # If rank is not specified set to the maximum rank for the
+    # Choi matrix (input_dim * output_dim)
+    if rank is None or rank > d_in * d_out:
+        rank = d_in * d_out
+    if rank < 1:
+        raise QiskitError(f"Rank {rank} must be greater than 0.")
+    from scipy import stats
+
+    # Generate a random unitary matrix
+    unitary = stats.unitary_group.rvs(max(rank * d_out, d_in), random_state=seed)
+
+    # Truncate columns to produce an isometry
+    return Stinespring(unitary[:, :d_in], input_dims=input_dims, output_dims=output_dims)

qiskit/quantum_info/operators/scalar_op.py

@@ -0,0 +1,254 @@
+# 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.
+
+"""
+ScalarOp class
+"""
+
+from __future__ import annotations
+import copy as _copy
+from numbers import Number
+import numpy as np
+
+from qiskit.exceptions import QiskitError
+from qiskit.quantum_info.operators.base_operator import BaseOperator
+from qiskit.quantum_info.operators.linear_op import LinearOp
+from qiskit.quantum_info.operators.operator import Operator
+from qiskit.quantum_info.operators.mixins import generate_apidocs
+
+
+class ScalarOp(LinearOp):
+    """Scalar identity operator class.
+
+    This is a symbolic representation of an scalar identity operator on
+    multiple subsystems. It may be used to initialize a symbolic scalar
+    multiplication of an identity and then be implicitly converted to other
+    kinds of operator subclasses by using the :meth:`compose`, :meth:`dot`,
+    :meth:`tensor`, :meth:`expand` methods.
+    """
+
+    def __init__(self, dims: int | tuple | None = None, coeff: Number = 1):
+        """Initialize an operator object.
+
+        Args:
+            dims (int or tuple): subsystem dimensions.
+            coeff (Number): scalar coefficient for the identity
+                            operator (Default: 1).
+
+        Raises:
+            QiskitError: If the optional coefficient is invalid.
+        """
+        if not isinstance(coeff, Number):
+            raise QiskitError(f"coeff {coeff} must be a number.")
+        self._coeff = coeff
+        super().__init__(input_dims=dims, output_dims=dims)
+
+    def __array__(self, dtype=None, copy=None):
+        if copy is False:
+            raise ValueError("could not produce matrix without calculation")
+        arr = self.to_matrix()
+        return arr if dtype is None else arr.astype(dtype, copy=False)
+
+    def __repr__(self):
+        return f"ScalarOp({self.input_dims()}, coeff={self.coeff})"
+
+    @property
+    def coeff(self):
+        """Return the coefficient"""
+        return self._coeff
+
+    def conjugate(self):
+        ret = self.copy()
+        ret._coeff = np.conjugate(self.coeff)
+        return ret
+
+    def transpose(self):
+        return self.copy()
+
+    def is_unitary(self, atol=None, rtol=None):
+        """Return True if operator is a unitary matrix."""
+        if atol is None:
+            atol = self.atol
+        if rtol is None:
+            rtol = self.rtol
+        return np.isclose(np.abs(self.coeff), 1, atol=atol, rtol=rtol)
+
+    def to_matrix(self):
+        """Convert to a Numpy matrix."""
+        dim, _ = self.dim
+        iden = np.eye(dim, dtype=complex)
+        return self.coeff * iden
+
+    def to_operator(self) -> Operator:
+        """Convert to an Operator object."""
+        return Operator(
+            self.to_matrix(), input_dims=self.input_dims(), output_dims=self.output_dims()
+        )
+
+    def compose(self, other: ScalarOp, qargs: list | None = None, front: bool = False) -> ScalarOp:
+        if qargs is None:
+            qargs = getattr(other, "qargs", None)
+        if not isinstance(other, BaseOperator):
+            other = Operator(other)
+
+        new_shape = self._op_shape.compose(other._op_shape, qargs, front)
+
+        # If other is also an ScalarOp we only need to
+        # update the coefficient and dimensions
+        if isinstance(other, ScalarOp):
+            ret = _copy.copy(self)
+            ret._coeff = self.coeff * other.coeff
+            ret._op_shape = new_shape
+            return ret
+
+        # If we are composing on the full system we return the
+        # other operator with reshaped dimensions
+        if qargs is None:
+            ret = _copy.copy(other)
+            ret._op_shape = new_shape
+            # Other operator might not support scalar multiplication
+            # so we treat the identity as a special case to avoid a
+            # possible error
+            if self.coeff == 1:
+                return ret
+            return self.coeff * ret
+
+        # For qargs composition we initialize the scalar operator
+        # as an instance of the other BaseOperators subclass. We then
+        # perform subsystem qargs composition using the BaseOperator
+        # subclasses compose method.
+        # Note that this will raise an error if the other operator does
+        # not support initialization from a ScalarOp or the ScalarOps
+        # `to_operator` method).
+        return other.__class__(self).compose(other, qargs=qargs, front=front)
+
+    def power(self, n: float) -> ScalarOp:
+        """Return the power of the ScalarOp.
+
+        Args:
+            n (float): the exponent for the scalar op.
+
+        Returns:
+            ScalarOp: the ``coeff ** n`` ScalarOp.
+        """
+        ret = self.copy()
+        ret._coeff = self.coeff**n
+        return ret
+
+    def tensor(self, other: ScalarOp) -> ScalarOp:
+        if not isinstance(other, BaseOperator):
+            other = Operator(other)
+
+        if isinstance(other, ScalarOp):
+            ret = _copy.copy(self)
+            ret._coeff = self.coeff * other.coeff
+            ret._op_shape = self._op_shape.tensor(other._op_shape)
+            return ret
+
+        return other.expand(self)
+
+    def expand(self, other: ScalarOp) -> ScalarOp:
+        if not isinstance(other, BaseOperator):
+            other = Operator(other)
+
+        if isinstance(other, ScalarOp):
+            ret = _copy.copy(self)
+            ret._coeff = self.coeff * other.coeff
+            ret._op_shape = self._op_shape.expand(other._op_shape)
+            return ret
+
+        return other.tensor(self)
+
+    def _add(self, other, qargs=None):
+        """Return the operator self + other.
+
+        If ``qargs`` are specified the other operator will be added
+        assuming it is identity on all other subsystems.
+
+        Args:
+            other (BaseOperator): an operator object.
+            qargs (None or list): optional subsystems to subtract on
+                                  (Default: None)
+
+        Returns:
+            ScalarOp: if other is an ScalarOp.
+            BaseOperator: if other is not an ScalarOp.
+
+        Raises:
+            QiskitError: if other has incompatible dimensions.
+        """
+        if qargs is None:
+            qargs = getattr(other, "qargs", None)
+
+        if not isinstance(other, BaseOperator):
+            other = Operator(other)
+
+        self._op_shape._validate_add(other._op_shape, qargs)
+
+        # Next if we are adding two ScalarOps we return a ScalarOp
+        if isinstance(other, ScalarOp):
+            return ScalarOp(self.input_dims(), coeff=self.coeff + other.coeff)
+
+        # If qargs are specified we have to pad the other BaseOperator
+        # with identities on remaining subsystems. We do this by
+        # composing it with an identity ScalarOp.
+        other = ScalarOp._pad_with_identity(self, other, qargs)
+
+        # First we check the special case where coeff=0. In this case
+        # we simply return the other operator reshaped so that its
+        # subsystem dimensions are equal to the current operator for the
+        # case where total dimensions agree but subsystem dimensions differ.
+        if self.coeff == 0:
+            return other.reshape(self.input_dims(), self.output_dims())
+
+        # Finally if we are adding another BaseOperator subclass
+        # we use that subclasses `_add` method and reshape the
+        # final dimensions.
+        return other.reshape(self.input_dims(), self.output_dims())._add(self)
+
+    def _multiply(self, other):
+        """Return the ScalarOp other * self.
+
+        Args:
+            other (Number): a complex number.
+
+        Returns:
+            ScalarOp: the scaled identity operator other * self.
+
+        Raises:
+            QiskitError: if other is not a valid complex number.
+        """
+        if not isinstance(other, Number):
+            raise QiskitError(f"other ({other}) is not a number")
+        ret = self.copy()
+        ret._coeff = other * self.coeff
+        return ret
+
+    @staticmethod
+    def _pad_with_identity(current, other, qargs=None):
+        """Pad another operator with identities.
+
+        Args:
+            current (BaseOperator): current operator.
+            other (BaseOperator): other operator.
+            qargs (None or list): qargs
+
+        Returns:
+            BaseOperator: the padded operator.
+        """
+        if qargs is None:
+            return other
+        return ScalarOp(current.input_dims()).compose(other, qargs=qargs)
+
+
+# Update docstrings for API docs
+generate_apidocs(ScalarOp)

qiskit/quantum_info/operators/symplectic/__init__.py

@@ -0,0 +1,23 @@
+# 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.
+
+"""
+Symplectic Operators
+"""
+
+from __future__ import annotations
+
+from .clifford import Clifford
+from .pauli import Pauli
+from .pauli_list import PauliList
+from .pauli_utils import pauli_basis
+from .sparse_pauli_op import SparsePauliOp