qiskit 2.0.3__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/quantum_info/operators/measures.py

@@ -0,0 +1,418 @@
+# 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 collection of useful quantum information functions for operators.
+"""
+
+from __future__ import annotations
+import logging
+import numpy as np
+
+from qiskit.exceptions import QiskitError, MissingOptionalLibraryError
+from qiskit.circuit.gate import Gate
+from qiskit.quantum_info.operators.base_operator import BaseOperator
+from qiskit.quantum_info.operators.operator import Operator
+from qiskit.quantum_info.operators.channel.quantum_channel import QuantumChannel
+from qiskit.quantum_info.operators.channel import Choi, SuperOp
+from qiskit.quantum_info.states.densitymatrix import DensityMatrix
+from qiskit.quantum_info.states.measures import state_fidelity
+from qiskit.utils import optionals as _optionals
+
+logger = logging.getLogger(__name__)
+
+
+def process_fidelity(
+    channel: Operator | QuantumChannel,
+    target: Operator | QuantumChannel | None = None,
+    require_cp: bool = True,
+    require_tp: bool = True,
+) -> float:
+    r"""Return the process fidelity of a noisy quantum channel.
+
+
+    The process fidelity :math:`F_{\text{pro}}(\mathcal{E}, \mathcal{F})`
+    between two quantum channels :math:`\mathcal{E}, \mathcal{F}` is given by
+
+    .. math::
+        F_{\text{pro}}(\mathcal{E}, \mathcal{F})
+            = F(\rho_{\mathcal{E}}, \rho_{\mathcal{F}})
+
+    where :math:`F` is the :func:`~qiskit.quantum_info.state_fidelity`,
+    :math:`\rho_{\mathcal{E}} = \Lambda_{\mathcal{E}} / d` is the
+    normalized :class:`~qiskit.quantum_info.Choi` matrix for the channel
+    :math:`\mathcal{E}`, and :math:`d` is the input dimension of
+    :math:`\mathcal{E}`.
+
+    When the target channel is unitary this is equivalent to
+
+    .. math::
+        F_{\text{pro}}(\mathcal{E}, U)
+            = \frac{Tr[S_U^\dagger S_{\mathcal{E}}]}{d^2}
+
+    where :math:`S_{\mathcal{E}}, S_{U}` are the
+    :class:`~qiskit.quantum_info.SuperOp` matrices for the *input* quantum
+    channel :math:`\mathcal{E}` and *target* unitary :math:`U` respectively,
+    and :math:`d` is the input dimension of the channel.
+
+    Args:
+        channel (Operator or QuantumChannel): input quantum channel.
+        target (Operator or QuantumChannel or None): target quantum channel.
+            If `None` target is the identity operator [Default: None].
+        require_cp (bool): check if input and target channels are
+                           completely-positive and if non-CP log warning
+                           containing negative eigenvalues of Choi-matrix
+                           [Default: True].
+        require_tp (bool): check if input and target channels are
+                           trace-preserving and if non-TP log warning
+                           containing negative eigenvalues of partial
+                           Choi-matrix :math:`Tr_{\text{out}}[\mathcal{E}] - I`
+                           [Default: True].
+
+    Returns:
+        float: The process fidelity :math:`F_{\text{pro}}`.
+
+    Raises:
+        QiskitError: if the channel and target do not have the same dimensions.
+    """
+    # Format inputs
+    channel = _input_formatter(channel, SuperOp, "process_fidelity", "channel")
+    target = _input_formatter(target, Operator, "process_fidelity", "target")
+
+    if target:
+        # Validate dimensions
+        if channel.dim != target.dim:
+            raise QiskitError(
+                "Input quantum channel and target unitary must have the same "
+                f"dimensions ({channel.dim} != {target.dim})."
+            )
+
+    # Validate complete-positivity and trace-preserving
+    for label, chan in [("Input", channel), ("Target", target)]:
+        if chan is not None and require_cp:
+            cp_cond = _cp_condition(chan)
+            neg = cp_cond < -1 * chan.atol
+            if np.any(neg):
+                logger.warning(
+                    "%s channel is not CP. Choi-matrix has negative eigenvalues: %s",
+                    label,
+                    cp_cond[neg],
+                )
+        if chan is not None and require_tp:
+            tp_cond = _tp_condition(chan)
+            non_zero = np.logical_not(np.isclose(tp_cond, 0, atol=chan.atol, rtol=chan.rtol))
+            if np.any(non_zero):
+                logger.warning(
+                    "%s channel is not TP. Tr_2[Choi] - I has non-zero eigenvalues: %s",
+                    label,
+                    tp_cond[non_zero],
+                )
+
+    if isinstance(target, Operator):
+        # Compute fidelity with unitary target by applying the inverse
+        # to channel and computing fidelity with the identity
+        channel = channel.compose(target.adjoint())
+        target = None
+
+    input_dim, _ = channel.dim
+    if target is None:
+        # Compute process fidelity with identity channel
+        if isinstance(channel, Operator):
+            # |Tr[U]/dim| ** 2
+            fid = np.abs(np.trace(channel.data) / input_dim) ** 2
+        else:
+            # Tr[S] / (dim ** 2)
+            fid = np.trace(SuperOp(channel).data) / (input_dim**2)
+        return float(np.real(fid))
+
+    # For comparing two non-unitary channels we compute the state fidelity of
+    # the normalized Choi-matrices. This is equivalent to the previous definition
+    # when the target is a unitary channel.
+    state1 = DensityMatrix(Choi(channel).data / input_dim)
+    state2 = DensityMatrix(Choi(target).data / input_dim)
+    return state_fidelity(state1, state2, validate=False)
+
+
+def average_gate_fidelity(
+    channel: QuantumChannel | Operator,
+    target: Operator | None = None,
+    require_cp: bool = True,
+    require_tp: bool = False,
+) -> float:
+    r"""Return the average gate fidelity of a noisy quantum channel.
+
+    The average gate fidelity :math:`F_{\text{ave}}` is given by
+
+    .. math::
+        \begin{aligned}
+        F_{\text{ave}}(\mathcal{E}, U)
+            &= \int d\psi \langle\psi|U^\dagger
+                \mathcal{E}(|\psi\rangle\!\langle\psi|)U|\psi\rangle \\
+            &= \frac{d F_{\text{pro}}(\mathcal{E}, U) + 1}{d + 1}
+        \end{aligned}
+
+    where :math:`F_{\text{pro}}(\mathcal{E}, U)` is the
+    :meth:`~qiskit.quantum_info.process_fidelity` of the input quantum
+    *channel* :math:`\mathcal{E}` with a *target* unitary :math:`U`, and
+    :math:`d` is the dimension of the *channel*.
+
+    Args:
+        channel (QuantumChannel or Operator): noisy quantum channel.
+        target (Operator or None): target unitary operator.
+            If `None` target is the identity operator [Default: None].
+        require_cp (bool): check if input and target channels are
+                           completely-positive and if non-CP log warning
+                           containing negative eigenvalues of Choi-matrix
+                           [Default: True].
+        require_tp (bool): check if input and target channels are
+                           trace-preserving and if non-TP log warning
+                           containing negative eigenvalues of partial
+                           Choi-matrix :math:`Tr_{\text{out}}[\mathcal{E}] - I`
+                           [Default: True].
+
+    Returns:
+        float: The average gate fidelity :math:`F_{\text{ave}}`.
+
+    Raises:
+        QiskitError: if the channel and target do not have the same dimensions,
+                     or have different input and output dimensions.
+    """
+    # Format inputs
+    channel = _input_formatter(channel, SuperOp, "average_gate_fidelity", "channel")
+    target = _input_formatter(target, Operator, "average_gate_fidelity", "target")
+
+    if target is not None:
+        try:
+            target = Operator(target)
+        except QiskitError as ex:
+            raise QiskitError(
+                "Target channel is not a unitary channel. To compare "
+                "two non-unitary channels use the "
+                "`qiskit.quantum_info.process_fidelity` function instead."
+            ) from ex
+    dim, _ = channel.dim
+    f_pro = process_fidelity(channel, target=target, require_cp=require_cp, require_tp=require_tp)
+    return (dim * f_pro + 1) / (dim + 1)
+
+
+def gate_error(
+    channel: QuantumChannel,
+    target: Operator | None = None,
+    require_cp: bool = True,
+    require_tp: bool = False,
+) -> float:
+    r"""Return the gate error of a noisy quantum channel.
+
+    The gate error :math:`E` is given by the average gate infidelity
+
+    .. math::
+        E(\mathcal{E}, U) = 1 - F_{\text{ave}}(\mathcal{E}, U)
+
+    where :math:`F_{\text{ave}}(\mathcal{E}, U)` is the
+    :meth:`~qiskit.quantum_info.average_gate_fidelity` of the input
+    quantum *channel* :math:`\mathcal{E}` with a *target* unitary
+    :math:`U`.
+
+    Args:
+        channel (QuantumChannel): noisy quantum channel.
+        target (Operator or None): target unitary operator.
+            If `None` target is the identity operator [Default: None].
+        require_cp (bool): check if input and target channels are
+                           completely-positive and if non-CP log warning
+                           containing negative eigenvalues of Choi-matrix
+                           [Default: True].
+        require_tp (bool): check if input and target channels are
+                           trace-preserving and if non-TP log warning
+                           containing negative eigenvalues of partial
+                           Choi-matrix :math:`Tr_{\text{out}}[\mathcal{E}] - I`
+                           [Default: True].
+
+    Returns:
+        float: The average gate error :math:`E`.
+
+    Raises:
+        QiskitError: if the channel and target do not have the same dimensions,
+                     or have different input and output dimensions.
+    """
+    # Format inputs
+    channel = _input_formatter(channel, SuperOp, "gate_error", "channel")
+    target = _input_formatter(target, Operator, "gate_error", "target")
+    return 1 - average_gate_fidelity(
+        channel, target=target, require_cp=require_cp, require_tp=require_tp
+    )
+
+
+def diamond_norm(choi: Choi | QuantumChannel, solver: str = "SCS", **kwargs) -> float:
+    r"""Return the diamond norm of the input quantum channel object.
+
+    This function computes the completely-bounded trace-norm (often
+    referred to as the diamond-norm) of the input quantum channel object
+    using the semidefinite-program from reference [1].
+
+    Args:
+        choi(Choi or QuantumChannel): a quantum channel object or
+                                      Choi-matrix array.
+        solver (str): The solver to use.
+        kwargs: optional arguments to pass to CVXPY solver.
+
+    Returns:
+        float: The completely-bounded trace norm :math:`\|\mathcal{E}\|_{\diamond}`.
+
+    Raises:
+        QiskitError: if CVXPY package cannot be found.
+
+    Additional Information:
+        The input to this function is typically *not* a CPTP quantum
+        channel, but rather the *difference* between two quantum channels
+        :math:`\|\Delta\mathcal{E}\|_\diamond` where
+        :math:`\Delta\mathcal{E} = \mathcal{E}_1 - \mathcal{E}_2`.
+
+    Reference:
+        J. Watrous. "Simpler semidefinite programs for completely bounded
+        norms", arXiv:1207.5726 [quant-ph] (2012).
+
+    .. note::
+
+        This function requires the optional CVXPY package to be installed.
+        Any additional kwargs will be passed to the ``cvxpy.solve``
+        function. See the CVXPY documentation for information on available
+        SDP solvers.
+    """
+    from scipy import sparse
+
+    cvxpy = _cvxpy_check("`diamond_norm`")  # Check CVXPY is installed
+
+    choi = Choi(_input_formatter(choi, Choi, "diamond_norm", "choi"))
+
+    def cvx_bmat(mat_r, mat_i):
+        """Block matrix for embedding complex matrix in reals"""
+        return cvxpy.bmat([[mat_r, -mat_i], [mat_i, mat_r]])
+
+    # Dimension of input and output spaces
+    dim_in = choi._input_dim
+    dim_out = choi._output_dim
+    size = dim_in * dim_out
+
+    # SDP Variables to convert to real valued problem
+    r0_r = cvxpy.Variable((dim_in, dim_in))
+    r0_i = cvxpy.Variable((dim_in, dim_in))
+    r0 = cvx_bmat(r0_r, r0_i)
+
+    r1_r = cvxpy.Variable((dim_in, dim_in))
+    r1_i = cvxpy.Variable((dim_in, dim_in))
+    r1 = cvx_bmat(r1_r, r1_i)
+
+    x_r = cvxpy.Variable((size, size))
+    x_i = cvxpy.Variable((size, size))
+    iden = sparse.eye(dim_out)
+
+    # Watrous uses row-vec convention for his Choi matrix while we use
+    # col-vec. It turns out row-vec convention is required for CVXPY too
+    # since the cvxpy.kron function must have a constant as its first argument.
+    c_r = cvxpy.bmat([[cvxpy.kron(iden, r0_r), x_r], [x_r.T, cvxpy.kron(iden, r1_r)]])
+    c_i = cvxpy.bmat([[cvxpy.kron(iden, r0_i), x_i], [-x_i.T, cvxpy.kron(iden, r1_i)]])
+    c = cvx_bmat(c_r, c_i)
+
+    # Convert col-vec convention Choi-matrix to row-vec convention and
+    # then take Transpose: Choi_C -> Choi_R.T
+    choi_rt = np.transpose(
+        np.reshape(choi.data, (dim_in, dim_out, dim_in, dim_out)), (3, 2, 1, 0)
+    ).reshape(choi.data.shape)
+    choi_rt_r = choi_rt.real
+    choi_rt_i = choi_rt.imag
+
+    # Constraints
+    cons = [
+        r0 >> 0,
+        r0_r == r0_r.T,
+        r0_i == -r0_i.T,
+        cvxpy.trace(r0_r) == 1,
+        r1 >> 0,
+        r1_r == r1_r.T,
+        r1_i == -r1_i.T,
+        cvxpy.trace(r1_r) == 1,
+        c >> 0,
+    ]
+
+    # Objective function
+    obj = cvxpy.Maximize(cvxpy.trace(choi_rt_r @ x_r) + cvxpy.trace(choi_rt_i @ x_i))
+    prob = cvxpy.Problem(obj, cons)
+    sol = prob.solve(solver=solver, **kwargs)
+    return sol
+
+
+def _cvxpy_check(name):
+    """Check that a supported CVXPY version is installed"""
+    # Check if CVXPY package is installed
+    _optionals.HAS_CVXPY.require_now(name)
+    import cvxpy
+
+    # Check CVXPY version
+    version = cvxpy.__version__
+    if version[0] != "1":
+        raise MissingOptionalLibraryError(
+            "CVXPY >= 1.0",
+            "diamond_norm",
+            msg=f"Incompatible CVXPY version {version} found.",
+        )
+    return cvxpy
+
+
+# pylint: disable=too-many-return-statements
+def _input_formatter(obj, fallback_class, func_name, arg_name):
+    """Formatting function for input conversion"""
+    # Empty input
+    if obj is None:
+        return obj
+
+    # Channel-like input
+    if isinstance(obj, QuantumChannel):
+        return obj
+    if hasattr(obj, "to_quantumchannel"):
+        return obj.to_quantumchannel()
+    if hasattr(obj, "to_channel"):
+        return obj.to_channel()
+
+    # Unitary-like input
+    if isinstance(obj, (Gate, BaseOperator)):
+        return Operator(obj)
+    if hasattr(obj, "to_operator"):
+        return obj.to_operator()
+    raise TypeError(
+        f"invalid type supplied to {arg_name} of {func_name}."
+        f" A {fallback_class.__name__} is best."
+    )
+
+
+def _cp_condition(channel):
+    """Return Choi-matrix eigenvalues for checking if channel is CP"""
+    if isinstance(channel, QuantumChannel):
+        if not isinstance(channel, Choi):
+            channel = Choi(channel)
+        return np.linalg.eigvalsh(channel.data)
+    unitary = Operator(channel).data
+    return np.tensordot(unitary, unitary.conj(), axes=([0, 1], [0, 1])).real
+
+
+def _tp_condition(channel):
+    """Return partial tr Choi-matrix eigenvalues for checking if channel is TP"""
+    if isinstance(channel, QuantumChannel):
+        if not isinstance(channel, Choi):
+            channel = Choi(channel)
+        choi = channel.data
+        dims = tuple(np.sqrt(choi.shape).astype(int))
+        shape = dims + dims
+        tr_choi = np.trace(np.reshape(choi, shape), axis1=1, axis2=3)
+    else:
+        unitary = Operator(channel).data
+        tr_choi = np.tensordot(unitary, unitary.conj(), axes=(0, 0))
+    return np.linalg.eigvalsh(tr_choi - np.eye(len(tr_choi)))

qiskit/quantum_info/operators/mixins/__init__.py

@@ -0,0 +1,52 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2021.
+#
+# 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.
+
+"""
+Operator Mixins
+"""
+
+from inspect import getdoc
+
+from .group import GroupMixin
+from .adjoint import AdjointMixin
+from .linear import LinearMixin
+from .multiply import MultiplyMixin
+from .tolerances import TolerancesMixin
+
+
+def generate_apidocs(cls):
+    """Decorator to format API docstrings for classes using Mixins.
+
+    This runs string replacement on the docstrings of the mixin
+    methods to replace the placeholder CLASS with the class
+    name `cls.__name__`.
+
+    Args:
+        cls (type): The class to format docstrings.
+
+    Returns:
+        cls: the original class with updated docstrings.
+    """
+
+    def _replace_name(mixin, methods):
+        if issubclass(cls, mixin):
+            for i in methods:
+                meth = getattr(cls, i)
+                doc = getdoc(meth)
+                if doc is not None:
+                    meth.__doc__ = doc.replace("CLASS", cls.__name__)
+
+    _replace_name(GroupMixin, ("tensor", "expand", "compose", "dot", "power"))
+    _replace_name(AdjointMixin, ("transpose", "conjugate", "adjoint"))
+    _replace_name(MultiplyMixin, ("_multiply",))
+    _replace_name(LinearMixin, ("_add",))
+    return cls

qiskit/quantum_info/operators/mixins/adjoint.py

@@ -0,0 +1,52 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2021.
+#
+# 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.
+
+"""
+Mixin for gate operator interface.
+"""
+
+import sys
+from abc import ABC, abstractmethod
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+
+class AdjointMixin(ABC):
+    """Abstract Mixin for operator adjoint and transpose operations.
+
+    This class defines the following methods
+
+        - :meth:`transpose`
+        - :meth:`conjugate`
+        - :meth:`adjoint`
+
+    The following abstract methods must be implemented by subclasses
+    using this mixin
+
+        - ``conjugate(self)``
+        - ``transpose(self)``
+    """
+
+    def adjoint(self) -> Self:
+        """Return the adjoint of the CLASS."""
+        return self.conjugate().transpose()
+
+    @abstractmethod
+    def conjugate(self) -> Self:
+        """Return the conjugate of the CLASS."""
+
+    @abstractmethod
+    def transpose(self) -> Self:
+        """Return the transpose of the CLASS."""

qiskit/quantum_info/operators/mixins/group.py

@@ -0,0 +1,171 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2021.
+#
+# 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.
+
+"""
+Mixin for gate operator interface.
+"""
+
+import sys
+from abc import ABC, abstractmethod
+from numbers import Integral
+
+from qiskit.exceptions import QiskitError
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+
+class GroupMixin(ABC):
+    """Abstract Mixin for operator group operations.
+
+    This class defines the following methods
+
+        - :meth:`compose`
+        - :meth:`dot`
+        - :meth:`tensor`
+        - :meth:`expand`
+        - :meth:`power`
+
+    And the following operator overloads:
+
+        - ``&``, ``__and__`` -> :meth:`compose`
+        - ``@``, ``__matmul__`` -> :meth:`dot`
+        - ``^``, ``__xor__`` -> `:meth:`tensor`
+        - ``**``, ``__pow__`` -> :meth:`power`
+
+    The following abstract methods must be implemented by subclasses
+    using this mixin
+
+        - ``compose(self, other, qargs=None, inplace=False)``
+        - ``tensor(self, other)``
+        - ``expand(self, other)``
+    """
+
+    def __and__(self, other) -> Self:
+        return self.compose(other)
+
+    def __pow__(self, n) -> Self:
+        return self.power(n)
+
+    def __xor__(self, other) -> Self:
+        return self.tensor(other)
+
+    def __matmul__(self, other) -> Self:
+        return self.dot(other)
+
+    @abstractmethod
+    def tensor(self, other) -> Self:
+        r"""Return the tensor product with another CLASS.
+
+        Args:
+            other (CLASS): a CLASS object.
+
+        Returns:
+            CLASS: the tensor product :math:`a \otimes b`, where :math:`a`
+                is the current CLASS, and :math:`b` is the other CLASS.
+
+        .. note::
+            The tensor product can be obtained using the ``^`` binary operator.
+            Hence ``a.tensor(b)`` is equivalent to ``a ^ b``.
+
+        .. note:
+            Tensor uses reversed operator ordering to :meth:`expand`.
+            For two operators of the same type ``a.tensor(b) = b.expand(a)``.
+        """
+
+    @abstractmethod
+    def expand(self, other) -> Self:
+        r"""Return the reverse-order tensor product with another CLASS.
+
+        Args:
+            other (CLASS): a CLASS object.
+
+        Returns:
+            CLASS: the tensor product :math:`b \otimes a`, where :math:`a`
+                is the current CLASS, and :math:`b` is the other CLASS.
+
+        .. note:
+            Expand is the opposite operator ordering to :meth:`tensor`.
+            For two operators of the same type ``a.expand(b) = b.tensor(a)``.
+        """
+
+    @abstractmethod
+    def compose(self, other, qargs=None, front=False) -> Self:
+        """Return the operator composition with another CLASS.
+
+        Args:
+            other (CLASS): a CLASS object.
+            qargs (list or None): Optional, a list of subsystem positions to
+                                  apply other on. If None apply on all
+                                  subsystems (default: None).
+            front (bool): If True compose using right operator multiplication,
+                          instead of left multiplication [default: False].
+
+        Returns:
+            CLASS: The composed CLASS.
+
+        Raises:
+            QiskitError: if other cannot be converted to an operator, or has
+                         incompatible dimensions for specified subsystems.
+
+        .. note::
+            Composition (``&``) by default is defined as `left` matrix multiplication for
+            matrix operators, while ``@`` (equivalent to :meth:`dot`) is defined as `right` matrix
+            multiplication. That is that ``A & B == A.compose(B)`` is equivalent to
+            ``B @ A == B.dot(A)`` when ``A`` and ``B`` are of the same type.
+
+            Setting the ``front=True`` kwarg changes this to `right` matrix
+            multiplication and is equivalent to the :meth:`dot` method
+            ``A.dot(B) == A.compose(B, front=True)``.
+        """
+
+    def dot(self, other, qargs=None) -> Self:
+        """Return the right multiplied operator self * other.
+
+        Args:
+            other (CLASS): an operator object.
+            qargs (list or None): Optional, a list of subsystem positions to
+                                  apply other on. If None apply on all
+                                  subsystems (default: None).
+
+        Returns:
+            CLASS: The right matrix multiplied CLASS.
+
+        .. note::
+            The dot product can be obtained using the ``@`` binary operator.
+            Hence ``a.dot(b)`` is equivalent to ``a @ b``.
+        """
+        return self.compose(other, qargs=qargs, front=True)
+
+    def power(self, n) -> Self:
+        """Return the compose of a operator with itself n times.
+
+        Args:
+            n (int): the number of times to compose with self (n>0).
+
+        Returns:
+            CLASS: the n-times composed operator.
+
+        Raises:
+            QiskitError: if the input and output dimensions of the operator
+                         are not equal, or the power is not a positive integer.
+        """
+        # NOTE: if a subclass can have negative or non-integer powers
+        # this method should be overridden in that class.
+        if not isinstance(n, Integral) or n < 1:
+            raise QiskitError("Can only power with positive integer powers.")
+        ret = self
+        for _ in range(1, n):
+            ret = ret.dot(self)
+        return ret