emu-sv 2.5.1__py3-none-any.whl → 2.6.0__py3-none-any.whl

emu_sv/__init__.py

@@ -13,6 +13,7 @@ from pulser.backend import (
 )
 
 from .dense_operator import DenseOperator
+from .sparse_operator import SparseOperator
 from .sv_backend import SVBackend, SVConfig
 from .state_vector import StateVector, inner
 from .density_matrix_state import DensityMatrix
@@ -36,6 +37,7 @@ __all__ = [
     "StateVector",
     "inner",
     "DensityMatrix",
+    "SparseOperator",
 ]
 
-__version__ = "2.5.1"
+__version__ = "2.6.0"

emu_sv/sparse_operator.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+from functools import reduce
+
+import torch
+
+from typing import Sequence, Type
+
+from emu_base import DEVICE_COUNT
+from emu_sv.state_vector import StateVector
+
+from pulser.backend import (
+    Operator,
+    State,
+)
+from pulser.backend.operator import FullOp, QuditOp
+from pulser.backend.state import Eigenstate
+
+dtype = torch.complex128
+
+
+def sparse_add(self: torch.Tensor, other: torch.Tensor) -> torch.Tensor:
+    return torch.sparse_coo_tensor(
+        torch.cat((self.indices(), other.indices()), dim=1),
+        torch.cat((self.values(), other.values())),
+        size=self.shape,
+    ).coalesce()
+
+
+def sparse_kron(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
+    a, b = a.coalesce(), b.coalesce()
+    sa, sb = a.shape, b.shape
+    shape = (sa[0] * sb[0], sa[1] * sb[1])
+    i = (
+        torch.tensor(sb).reshape(2, 1, 1) * a.indices().reshape(2, -1, 1)
+        + b.indices().reshape(2, 1, -1)
+    ).reshape(2, -1)
+    v = torch.outer(a.values(), b.values()).flatten()
+    return torch.sparse_coo_tensor(i, v, shape, is_coalesced=True)
+
+
+class SparseOperator(Operator[complex, torch.Tensor, StateVector]):
+    """This operator is used to represent a sparse matrix in CSR (Compressed Sparse Row)
+    format for efficient computation on the EMU-SV emulator
+
+    Args:
+        matrix (torch.Tensor): The CSR matrix representation of the operator.
+        gpu (bool): Use GPU for computation. True uses the CPU if GPU not available.
+    """
+
+    def __init__(
+        self,
+        matrix: torch.Tensor,
+        *,
+        gpu: bool = True,
+    ):
+        device = "cuda" if gpu and DEVICE_COUNT > 0 else "cpu"
+        self.matrix = matrix.to(dtype=dtype, device=device)
+
+    def __repr__(self) -> str:
+        return repr(self.matrix)
+
+    def __add__(self, other: Operator) -> SparseOperator:
+        """
+        Element-wise addition of two SparseOperators.
+
+        Args:
+            other: a SparseOperator instance.
+
+        Returns:
+            A new SparseOperator representing the sum.
+        """
+        assert isinstance(
+            other, SparseOperator
+        ), "SparseOperator can only be added to another SparseOperator."
+        # TODO: figure out a better algorithm.
+        # self.matrix + other.matrix doesn't work on mac.
+        return SparseOperator(
+            sparse_add(
+                self.matrix.to_sparse_coo(), other.matrix.to_sparse_coo()
+            ).to_sparse_csr()
+        )
+
+    def __rmul__(self, scalar: complex) -> SparseOperator:
+        """
+        Scalar multiplication of the SparseOperator.
+
+        Args:
+            scalar: a number to scale the operator.
+
+        Returns:
+            A new SparseOperator scaled by the given scalar.
+        """
+
+        return SparseOperator(scalar * self.matrix)
+
+    def __matmul__(self, other: Operator) -> SparseOperator:
+        """
+        Compose two SparseOperators via matrix multiplication.
+
+        Args:
+            other: a SparseOperator instance.
+
+        Returns:
+            A new SparseOperator representing the product `self @ other`.
+        """
+        raise NotImplementedError()
+
+    def apply_to(self, other: State) -> StateVector:
+        """
+        Apply the SparseOperator to a given StateVector.
+
+        Args:
+            other: a StateVector instance.
+
+        Returns:
+            A new StateVector after applying the operator.
+        """
+        assert isinstance(
+            other, StateVector
+        ), "SparseOperator can only be applied to a StateVector."
+
+        return StateVector(self.matrix @ other.vector)
+
+    def expect(self, state: State) -> torch.Tensor:
+        """
+        Compute the expectation value of the operator with respect to a state.
+
+        Args:
+            state: a StateVector instance.
+
+        Returns:
+            The expectation value as a float or complex number.
+        """
+        assert isinstance(
+            state, StateVector
+        ), "Only expectation values of StateVectors are supported."
+
+        return torch.vdot(state.vector, self.apply_to(state).vector).cpu()
+
+    @classmethod
+    def _from_operator_repr(
+        cls: Type[SparseOperator],
+        *,
+        eigenstates: Sequence[Eigenstate],
+        n_qudits: int,
+        operations: FullOp[complex],
+    ) -> tuple[SparseOperator, FullOp[complex]]:
+        """
+        Construct a SparseOperator from an operator representation.
+
+        Args:
+            eigenstates: the eigenstates of the basis to use, e.g. ("r", "g") or ("0", "1").
+            n_qudits: number of qudits in the system.
+            operations: which bitstrings make up the state with what weight.
+
+        Returns:
+            A SparseOperator instance corresponding to the given representation.
+        """
+
+        assert len(set(eigenstates)) == 2, "Only qubits are supported in EMU-SV."
+
+        operators_with_tensors: dict[str, torch.Tensor | QuditOp] = dict()
+
+        if set(eigenstates) == {"r", "g"}:
+            # operators_with_tensors will now contain the basis for single qubit ops,
+            # and potentially user defined strings in terms of {r, g} or {0, 1}
+            operators_with_tensors |= {
+                "gg": torch.tensor([[1.0, 0.0], [0.0, 0.0]], dtype=dtype).to_sparse_coo(),
+                "rg": torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=dtype).to_sparse_coo(),
+                "gr": torch.tensor([[0.0, 1.0], [0.0, 0.0]], dtype=dtype).to_sparse_coo(),
+                "rr": torch.tensor([[0.0, 0.0], [0.0, 1.0]], dtype=dtype).to_sparse_coo(),
+            }
+        elif set(eigenstates) == {"0", "1"}:
+            raise NotImplementedError(
+                "{'0','1'} basis is related to XY Hamiltonian, which is not implemented"
+            )
+        else:
+            raise ValueError("An unsupported basis of eigenstates has been provided.")
+
+        accum_res = torch.sparse_coo_tensor(
+            torch.zeros(2, 0, dtype=torch.int32),
+            torch.zeros(0, dtype=dtype),
+            (2**n_qudits, 2**n_qudits),
+        )
+        for coeff, oper_torch_with_target_qubits in operations:
+
+            def build_torch_operator_from_string(
+                oper: QuditOp | torch.Tensor,
+            ) -> torch.Tensor:
+                if isinstance(oper, torch.Tensor):
+                    return oper
+
+                result: torch.Tensor = torch.zeros((2, 2), dtype=dtype).to_sparse_coo()
+                for opstr, coeff in oper.items():
+                    tensor = build_torch_operator_from_string(
+                        operators_with_tensors[opstr]
+                    )
+                    operators_with_tensors[opstr] = tensor
+                    result += tensor * coeff
+                return result
+
+            single_qubit_gates = [torch.eye(2, dtype=dtype).to_sparse_coo()] * n_qudits
+
+            for operator_torch, target_qubits in oper_torch_with_target_qubits:
+                factor = build_torch_operator_from_string(operator_torch)
+                for target_qubit in target_qubits:
+                    single_qubit_gates[target_qubit] = factor
+
+            accum_res = sparse_add(
+                accum_res, coeff * reduce(sparse_kron, single_qubit_gates)
+            )
+
+        return SparseOperator(accum_res.to_sparse_csr()), operations
+
+    def __deepcopy__(self, memo: dict) -> SparseOperator:
+        """torch CSR tensor does not deepcopy automatically"""
+        cls = self.__class__
+        result = cls(torch.clone(self.matrix), gpu=self.matrix.is_cuda)
+        memo[id(self)] = result
+        return result

{emu_sv-2.5.1.dist-info → emu_sv-2.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emu-sv
-Version: 2.5.1
+Version: 2.6.0
 Summary: Pasqal State Vector based pulse emulator built on PyTorch
 Project-URL: Documentation, https://pasqal-io.github.io/emulators/
 Project-URL: Repository, https://github.com/pasqal-io/emulators
@@ -25,7 +25,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.10
-Requires-Dist: emu-base==2.5.1
+Requires-Dist: emu-base==2.6.0
 Description-Content-Type: text/markdown
 
 <div align="center">

{emu_sv-2.5.1.dist-info → emu_sv-2.6.0.dist-info}/RECORD

@@ -1,15 +1,16 @@
-emu_sv/__init__.py,sha256=1ivRLU63LbUtgOdxldhEaw5RX_5RpC4HvSu_NQm0Ei8,771
+emu_sv/__init__.py,sha256=0ykYwInHIgbHkUig_cY9uFesmU4F8bc8D_DIV511yEo,837
 emu_sv/custom_callback_implementations.py,sha256=_7XLIDzJ-p3DVqz-Jyv0eYbl8nih2x2p-pM4cBCLumA,6367
 emu_sv/dense_operator.py,sha256=GvF0swsiFRqp83bpyaU_CXap2vm74-JLI5lHo-0Hbdk,5901
 emu_sv/density_matrix_state.py,sha256=6QmLZvqEHLR64r0nD7D2jZIiAYOgciNVCjh3ywfvIs0,7243
 emu_sv/hamiltonian.py,sha256=CqNGuWJlO2ZljK47wt130s-5uKiOldQUsC3tjwk1mKA,6106
 emu_sv/lindblad_operator.py,sha256=pgjRNLBcvEM2-qxM8uy9wL74OtrD4A8trQeERi_AXH8,8892
+emu_sv/sparse_operator.py,sha256=xHJapSAKaMCgT5nG0gzMXGk2fCfjHY03OTO_rysszns,7535
 emu_sv/state_vector.py,sha256=v4rqC_qBGc5vO5EMHcHR6BdASjeKujO6_sCdd3pGd0c,9990
 emu_sv/sv_backend.py,sha256=-soOkSEzEBK1dCKnYnbtvYjmNZtZra1_4jP3H1ROOtM,737
 emu_sv/sv_backend_impl.py,sha256=-xWE30B5RI32nOG2pUR8lL3q-wufwvzxegiJexW5g4w,8952
 emu_sv/sv_config.py,sha256=o1esIqflxfN1ZtdwoVBAIWlzZIf9B5X9pvsQe1zHfdg,5433
 emu_sv/time_evolution.py,sha256=Uy3qMdt3BlLB6Aq1-o5uajRTu_3fPuBCtcusHxFPPJc,13545
 emu_sv/utils.py,sha256=t0nMDVo6DF5bQW-vbsyRMCmvkyNxCU-v0Enmns9aOAU,1151
-emu_sv-2.5.1.dist-info/METADATA,sha256=w55nOTevr_aCUsni08uNOcks62kWPiJdYIQFMnadtIQ,3595
-emu_sv-2.5.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-emu_sv-2.5.1.dist-info/RECORD,,
+emu_sv-2.6.0.dist-info/METADATA,sha256=YNa_iPn5JUl5N9FMdaHOwF1Pm000JwsYkLUUcKB-8FQ,3595
+emu_sv-2.6.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+emu_sv-2.6.0.dist-info/RECORD,,