qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/quantum_info/operators/__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 Operators."""
+
+from __future__ import annotations
+from .channel import PTM, Chi, Choi, Kraus, Stinespring, SuperOp
+from .dihedral import CNOTDihedral
+from .measures import average_gate_fidelity, diamond_norm, gate_error, process_fidelity
+from .operator import Operator
+from .scalar_op import ScalarOp
+from .symplectic import (
+    Clifford,
+    Pauli,
+    PauliList,
+    SparsePauliOp,
+    pauli_basis,
+)
+from .utils import anti_commutator, commutator, double_commutator

qiskit/quantum_info/operators/base_operator.py

@@ -0,0 +1,145 @@
+# 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.
+
+"""
+Abstract BaseOperator class.
+"""
+
+from __future__ import annotations
+import copy
+from abc import ABC
+
+from qiskit.exceptions import QiskitError
+from qiskit.quantum_info.operators.op_shape import OpShape
+
+from .mixins import GroupMixin
+
+
+class BaseOperator(GroupMixin, ABC):
+    """Abstract operator base class."""
+
+    def __init__(
+        self,
+        input_dims: tuple | int | None = None,
+        output_dims: tuple | int | None = None,
+        num_qubits: int | None = None,
+        shape: tuple | None = None,
+        op_shape: OpShape | None = None,
+    ):
+        """Initialize a BaseOperator shape
+
+        Args:
+            input_dims (tuple or int or None): Optional, input dimensions.
+            output_dims (tuple or int or None): Optional, output dimensions.
+            num_qubits (int): Optional, the number of qubits of the operator.
+            shape (tuple): Optional, matrix shape for automatically determining
+                           qubit dimensions.
+            op_shape (OpShape): Optional, an OpShape object for operator dimensions.
+
+        .. note::
+
+            If `op_shape`` is specified it will take precedence over other
+            kwargs.
+        """
+        self._qargs = None
+        if op_shape:
+            self._op_shape = op_shape
+        else:
+            self._op_shape = OpShape.auto(
+                shape=shape, dims_l=output_dims, dims_r=input_dims, num_qubits=num_qubits
+            )
+
+    # Set higher priority than Numpy array and matrix classes
+    __array_priority__ = 20
+
+    def __call__(self, *qargs):
+        """Return a shallow copy with qargs attribute set"""
+        if len(qargs) == 1 and isinstance(qargs[0], (tuple, list)):
+            qargs = qargs[0]
+        n_qargs = len(qargs)
+        if n_qargs not in self._op_shape.num_qargs:
+            raise QiskitError(
+                "qargs does not match the number of operator qargs "
+                f"({n_qargs} not in {self._op_shape.num_qargs})"
+            )
+        ret = copy.copy(self)
+        ret._qargs = tuple(qargs)
+        return ret
+
+    def __eq__(self, other):
+        return isinstance(other, type(self)) and self._op_shape == other._op_shape
+
+    @property
+    def qargs(self):
+        """Return the qargs for the operator."""
+        return self._qargs
+
+    @property
+    def dim(self):
+        """Return tuple (input_shape, output_shape)."""
+        return self._op_shape._dim_r, self._op_shape._dim_l
+
+    @property
+    def num_qubits(self):
+        """Return the number of qubits if a N-qubit operator or None otherwise."""
+        return self._op_shape.num_qubits
+
+    @property
+    def _input_dim(self):
+        """Return the total input dimension."""
+        return self._op_shape._dim_r
+
+    @property
+    def _output_dim(self):
+        """Return the total input dimension."""
+        return self._op_shape._dim_l
+
+    def reshape(
+        self,
+        input_dims: None | tuple | int = None,
+        output_dims: None | tuple | int = None,
+        num_qubits: None | int = None,
+    ) -> BaseOperator:
+        """Return a shallow copy with reshaped input and output subsystem dimensions.
+
+        Args:
+            input_dims (None or tuple): new subsystem input dimensions.
+                If None the original input dims will be preserved [Default: None].
+            output_dims (None or tuple): new subsystem output dimensions.
+                If None the original output dims will be preserved [Default: None].
+            num_qubits (None or int): reshape to an N-qubit operator [Default: None].
+
+        Returns:
+            BaseOperator: returns self with reshaped input and output dimensions.
+
+        Raises:
+            QiskitError: if combined size of all subsystem input dimension or
+                         subsystem output dimensions is not constant.
+        """
+        new_shape = OpShape.auto(
+            dims_l=output_dims, dims_r=input_dims, num_qubits=num_qubits, shape=self._op_shape.shape
+        )
+        ret = copy.copy(self)
+        ret._op_shape = new_shape
+        return ret
+
+    def input_dims(self, qargs=None):
+        """Return tuple of input dimension for specified subsystems."""
+        return self._op_shape.dims_r(qargs)
+
+    def output_dims(self, qargs=None):
+        """Return tuple of output dimension for specified subsystems."""
+        return self._op_shape.dims_l(qargs)
+
+    def copy(self):
+        """Make a deep copy of current operator."""
+        return copy.deepcopy(self)

qiskit/quantum_info/operators/channel/__init__.py

@@ -0,0 +1,29 @@
+# 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 Channel Representations Package
+
+For explanation of terminology and details of operations see Ref. [1]
+
+References:
+    [1] C.J. Wood, J.D. Biamonte, D.G. Cory, Quant. Inf. Comp. 15, 0579-0811 (2015)
+        Open access: arXiv:1111.6950 [quant-ph]
+"""
+
+from __future__ import annotations
+from .superop import SuperOp
+from .choi import Choi
+from .kraus import Kraus
+from .stinespring import Stinespring
+from .ptm import PTM
+from .chi import Chi

qiskit/quantum_info/operators/channel/chi.py

@@ -0,0 +1,190 @@
+# 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.
+
+
+"""
+Chi-matrix representation of a Quantum Channel.
+"""
+
+from __future__ import annotations
+import copy
+import numpy as np
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.instruction import Instruction
+from qiskit.exceptions import QiskitError
+from qiskit.quantum_info.operators.channel.quantum_channel import QuantumChannel
+from qiskit.quantum_info.operators.channel.choi import Choi
+from qiskit.quantum_info.operators.channel.superop import SuperOp
+from qiskit.quantum_info.operators.channel.transformations import _to_chi
+from qiskit.quantum_info.operators.mixins import generate_apidocs
+from qiskit.quantum_info.operators.base_operator import BaseOperator
+
+
+class Chi(QuantumChannel):
+    r"""Pauli basis Chi-matrix representation of a quantum channel.
+
+    The Chi-matrix representation of an :math:`n`-qubit quantum channel
+    :math:`\mathcal{E}` is a matrix :math:`\chi` such that the evolution of a
+    :class:`~qiskit.quantum_info.DensityMatrix` :math:`\rho` is given by
+
+    .. math::
+
+        \mathcal{E}(ρ) = \frac{1}{2^n} \sum_{i, j} \chi_{i,j} P_i ρ P_j
+
+    where :math:`[P_0, P_1, ..., P_{4^{n}-1}]` is the :math:`n`-qubit Pauli basis in
+    lexicographic order. It is related to the :class:`Choi` representation by a change
+    of basis of the Choi-matrix into the Pauli basis. The :math:`\frac{1}{2^n}`
+    in the definition above is a normalization factor that arises from scaling the
+    Pauli basis to make it orthonormal.
+
+    See reference [1] for further details.
+
+    References:
+        1. C.J. Wood, J.D. Biamonte, D.G. Cory, *Tensor networks and graphical calculus
+           for open quantum systems*, Quant. Inf. Comp. 15, 0579-0811 (2015).
+           `arXiv:1111.6950 [quant-ph] <https://arxiv.org/abs/1111.6950>`_
+    """
+
+    def __init__(
+        self,
+        data: QuantumCircuit | Instruction | BaseOperator | np.ndarray,
+        input_dims: int | tuple | None = None,
+        output_dims: int | tuple | None = None,
+    ):
+        """Initialize a quantum channel Chi-matrix operator.
+
+        Args:
+            data (QuantumCircuit or
+                  Instruction or
+                  BaseOperator or
+                  matrix): data to initialize superoperator.
+            input_dims (tuple): the input subsystem dimensions.
+                                [Default: None]
+            output_dims (tuple): the output subsystem dimensions.
+                                 [Default: None]
+
+        Raises:
+            QiskitError: if input data is not an N-qubit channel or
+                         cannot be initialized as a Chi-matrix.
+
+        Additional Information:
+            If the input or output dimensions are None, they will be
+            automatically determined from the input data. The Chi matrix
+            representation is only valid for N-qubit channels.
+        """
+        # If the input is a raw list or matrix we assume that it is
+        # already a Chi matrix.
+        if isinstance(data, (list, np.ndarray)):
+            # Initialize from raw numpy or list matrix.
+            chi_mat = np.asarray(data, dtype=complex)
+            # Determine input and output dimensions
+            dim_l, dim_r = chi_mat.shape
+            if dim_l != dim_r:
+                raise QiskitError("Invalid Chi-matrix input.")
+            if input_dims:
+                input_dim = np.prod(input_dims)
+            if output_dims:
+                output_dim = np.prod(input_dims)
+            if output_dims is None and input_dims is None:
+                output_dim = int(np.sqrt(dim_l))
+                input_dim = dim_l // output_dim
+            elif input_dims is None:
+                input_dim = dim_l // output_dim
+            elif output_dims is None:
+                output_dim = dim_l // input_dim
+            # Check dimensions
+            if input_dim * output_dim != dim_l:
+                raise QiskitError("Invalid shape for Chi-matrix input.")
+        else:
+            # Otherwise we initialize by conversion from another Qiskit
+            # object into the QuantumChannel.
+            if isinstance(data, (QuantumCircuit, Instruction)):
+                # If the input is a Terra QuantumCircuit or Instruction we
+                # convert it to a SuperOp
+                data = SuperOp._init_instruction(data)
+            else:
+                # We use the QuantumChannel init transform to initialize
+                # other objects into a QuantumChannel or Operator object.
+                data = self._init_transformer(data)
+            input_dim, output_dim = data.dim
+            # Now that the input is an operator we convert it to a Chi object
+            rep = getattr(data, "_channel_rep", "Operator")
+            chi_mat = _to_chi(rep, data._data, input_dim, output_dim)
+            if input_dims is None:
+                input_dims = data.input_dims()
+            if output_dims is None:
+                output_dims = data.output_dims()
+        # Check input is N-qubit channel
+        num_qubits = int(np.log2(input_dim))
+        if 2**num_qubits != input_dim or input_dim != output_dim:
+            raise QiskitError("Input is not an n-qubit Chi matrix.")
+        super().__init__(chi_mat, num_qubits=num_qubits)
+
+    def __array__(self, dtype=None):
+        if dtype:
+            return np.asarray(self.data, dtype=dtype)
+        return self.data
+
+    @property
+    def _bipartite_shape(self):
+        """Return the shape for bipartite matrix"""
+        return (self._input_dim, self._output_dim, self._input_dim, self._output_dim)
+
+    def _evolve(self, state, qargs=None):
+        return SuperOp(self)._evolve(state, qargs)
+
+    # ---------------------------------------------------------------------
+    # BaseOperator methods
+    # ---------------------------------------------------------------------
+
+    def conjugate(self):
+        # Since conjugation is basis dependent we transform
+        # to the Choi representation to compute the
+        # conjugate channel
+        return Chi(Choi(self).conjugate())
+
+    def transpose(self):
+        return Chi(Choi(self).transpose())
+
+    def adjoint(self):
+        return Chi(Choi(self).adjoint())
+
+    def compose(self, other: Chi, qargs: list | None = None, front: bool = False) -> Chi:
+        if qargs is None:
+            qargs = getattr(other, "qargs", None)
+        if qargs is not None:
+            return Chi(SuperOp(self).compose(other, qargs=qargs, front=front))
+        # If no qargs we compose via Choi representation to avoid an additional
+        # representation conversion to SuperOp and then convert back to Chi
+        return Chi(Choi(self).compose(other, front=front))
+
+    def tensor(self, other: Chi) -> Chi:
+        if not isinstance(other, Chi):
+            other = Chi(other)
+        return self._tensor(self, other)
+
+    def expand(self, other: Chi) -> Chi:
+        if not isinstance(other, Chi):
+            other = Chi(other)
+        return self._tensor(other, self)
+
+    @classmethod
+    def _tensor(cls, a, b):
+        ret = copy.copy(a)
+        ret._op_shape = a._op_shape.tensor(b._op_shape)
+        ret._data = np.kron(a._data, b.data)
+        return ret
+
+
+# Update docstrings for API docs
+generate_apidocs(Chi)

qiskit/quantum_info/operators/channel/choi.py

@@ -0,0 +1,217 @@
+# 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.
+
+
+"""
+Choi-matrix representation of a Quantum Channel.
+"""
+
+from __future__ import annotations
+import copy
+import numpy as np
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.instruction import Instruction
+from qiskit.exceptions import QiskitError
+from qiskit.quantum_info.operators.channel.quantum_channel import QuantumChannel
+from qiskit.quantum_info.operators.op_shape import OpShape
+from qiskit.quantum_info.operators.channel.superop import SuperOp
+from qiskit.quantum_info.operators.channel.transformations import _to_choi
+from qiskit.quantum_info.operators.channel.transformations import _bipartite_tensor
+from qiskit.quantum_info.operators.mixins import generate_apidocs
+from qiskit.quantum_info.operators.base_operator import BaseOperator
+
+
+class Choi(QuantumChannel):
+    r"""Choi-matrix representation of a Quantum Channel.
+
+    The Choi-matrix representation of a quantum channel :math:`\mathcal{E}`
+    is a matrix
+
+    .. math::
+
+        \Lambda = \sum_{i,j} |i\rangle\!\langle j|\otimes
+                    \mathcal{E}\left(|i\rangle\!\langle j|\right)
+
+    Evolution of a :class:`~qiskit.quantum_info.DensityMatrix`
+    :math:`\rho` with respect to the Choi-matrix is given by
+
+    .. math::
+
+        \mathcal{E}(\rho) = \mbox{Tr}_{1}\left[\Lambda
+                            (\rho^T \otimes \mathbb{I})\right]
+
+    where :math:`\mbox{Tr}_1` is the :func:`partial_trace` over subsystem 1.
+
+    See reference [1] for further details.
+
+    References:
+        1. C.J. Wood, J.D. Biamonte, D.G. Cory, *Tensor networks and graphical calculus
+           for open quantum systems*, Quant. Inf. Comp. 15, 0579-0811 (2015).
+           `arXiv:1111.6950 [quant-ph] <https://arxiv.org/abs/1111.6950>`_
+    """
+
+    def __init__(
+        self,
+        data: QuantumCircuit | Instruction | BaseOperator | np.ndarray,
+        input_dims: int | tuple | None = None,
+        output_dims: int | tuple | None = None,
+    ):
+        """Initialize a quantum channel Choi matrix operator.
+
+        Args:
+            data (QuantumCircuit or
+                  Instruction or
+                  BaseOperator or
+                  matrix): data to initialize superoperator.
+            input_dims (tuple): the input subsystem dimensions.
+                                [Default: None]
+            output_dims (tuple): the output subsystem dimensions.
+                                 [Default: None]
+
+        Raises:
+            QiskitError: if input data cannot be initialized as a
+                         Choi matrix.
+
+        Additional Information:
+            If the input or output dimensions are None, they will be
+            automatically determined from the input data. If the input data is
+            a Numpy array of shape (4**N, 4**N) qubit systems will be used. If
+            the input operator is not an N-qubit operator, it will assign a
+            single subsystem with dimension specified by the shape of the input.
+        """
+        # If the input is a raw list or matrix we assume that it is
+        # already a Choi matrix.
+        if isinstance(data, (list, np.ndarray)):
+            # Initialize from raw numpy or list matrix.
+            choi_mat = np.asarray(data, dtype=complex)
+            # Determine input and output dimensions
+            dim_l, dim_r = choi_mat.shape
+            if dim_l != dim_r:
+                raise QiskitError("Invalid Choi-matrix input.")
+            if input_dims:
+                input_dim = np.prod(input_dims)
+            if output_dims:
+                output_dim = np.prod(output_dims)
+            if output_dims is None and input_dims is None:
+                output_dim = int(np.sqrt(dim_l))
+                input_dim = dim_l // output_dim
+            elif input_dims is None:
+                input_dim = dim_l // output_dim
+            elif output_dims is None:
+                output_dim = dim_l // input_dim
+            # Check dimensions
+            if input_dim * output_dim != dim_l:
+                raise QiskitError("Invalid shape for input Choi-matrix.")
+            op_shape = OpShape.auto(
+                dims_l=output_dims, dims_r=input_dims, shape=(output_dim, input_dim)
+            )
+        else:
+            # Otherwise we initialize by conversion from another Qiskit
+            # object into the QuantumChannel.
+            if isinstance(data, (QuantumCircuit, Instruction)):
+                # If the input is a Terra QuantumCircuit or Instruction we
+                # convert it to a SuperOp
+                data = SuperOp._init_instruction(data)
+            else:
+                # We use the QuantumChannel init transform to initialize
+                # other objects into a QuantumChannel or Operator object.
+                data = self._init_transformer(data)
+            op_shape = data._op_shape
+            output_dim, input_dim = op_shape.shape
+            # Now that the input is an operator we convert it to a Choi object
+            rep = getattr(data, "_channel_rep", "Operator")
+            choi_mat = _to_choi(rep, data._data, input_dim, output_dim)
+        super().__init__(choi_mat, op_shape=op_shape)
+
+    def __array__(self, dtype=None):
+        if dtype:
+            return np.asarray(self.data, dtype=dtype)
+        return self.data
+
+    @property
+    def _bipartite_shape(self):
+        """Return the shape for bipartite matrix"""
+        return (self._input_dim, self._output_dim, self._input_dim, self._output_dim)
+
+    def _evolve(self, state, qargs=None):
+        return SuperOp(self)._evolve(state, qargs)
+
+    # ---------------------------------------------------------------------
+    # BaseOperator methods
+    # ---------------------------------------------------------------------
+
+    def conjugate(self):
+        ret = copy.copy(self)
+        ret._data = np.conj(self._data)
+        return ret
+
+    def transpose(self):
+        ret = copy.copy(self)
+        ret._op_shape = self._op_shape.transpose()
+        # Make bipartite matrix
+        d_in, d_out = self.dim
+        data = np.reshape(self._data, (d_in, d_out, d_in, d_out))
+        # Swap input and output indices on bipartite matrix
+        data = np.transpose(data, (1, 0, 3, 2))
+        ret._data = np.reshape(data, (d_in * d_out, d_in * d_out))
+        return ret
+
+    def compose(self, other: Choi, qargs: list | None = None, front: bool = False) -> Choi:
+        if qargs is None:
+            qargs = getattr(other, "qargs", None)
+        if qargs is not None:
+            return Choi(SuperOp(self).compose(other, qargs=qargs, front=front))
+
+        if not isinstance(other, Choi):
+            other = Choi(other)
+        new_shape = self._op_shape.compose(other._op_shape, qargs, front)
+        output_dim, input_dim = new_shape.shape
+
+        if front:
+            first = np.reshape(other._data, other._bipartite_shape)
+            second = np.reshape(self._data, self._bipartite_shape)
+        else:
+            first = np.reshape(self._data, self._bipartite_shape)
+            second = np.reshape(other._data, other._bipartite_shape)
+
+        # Contract Choi matrices for composition
+        data = np.reshape(
+            np.einsum("iAjB,AkBl->ikjl", first, second),
+            (input_dim * output_dim, input_dim * output_dim),
+        )
+        ret = Choi(data)
+        ret._op_shape = new_shape
+        return ret
+
+    def tensor(self, other: Choi) -> Choi:
+        if not isinstance(other, Choi):
+            other = Choi(other)
+        return self._tensor(self, other)
+
+    def expand(self, other: Choi) -> Choi:
+        if not isinstance(other, Choi):
+            other = Choi(other)
+        return self._tensor(other, self)
+
+    @classmethod
+    def _tensor(cls, a, b):
+        ret = copy.copy(a)
+        ret._op_shape = a._op_shape.tensor(b._op_shape)
+        ret._data = _bipartite_tensor(
+            a._data, b.data, shape1=a._bipartite_shape, shape2=b._bipartite_shape
+        )
+        return ret
+
+
+# Update docstrings for API docs
+generate_apidocs(Choi)