emu-sv 1.0.0__py3-none-any.whl

emu_sv/__init__.py

@@ -0,0 +1,42 @@
+from emu_sv.state_vector import StateVector, inner
+from emu_sv.dense_operator import DenseOperator
+from emu_sv.sv_backend import SVBackend, SVConfig
+from emu_base.base_classes import Results
+from emu_base.base_classes.callback import AggregationType
+
+from emu_base.base_classes import (
+    Callback,
+    BitStrings,
+    CorrelationMatrix,
+    Energy,
+    EnergyVariance,
+    Expectation,
+    QubitDensity,
+    StateResult,
+    SecondMomentOfEnergy,
+    Fidelity,
+)
+
+__all__ = [
+    "__version__",
+    "StateVector",
+    "DenseOperator",
+    "inner",
+    "SVBackend",
+    "SVConfig",
+    "Callback",
+    "BitStrings",
+    "CorrelationMatrix",
+    "Energy",
+    "EnergyVariance",
+    "Expectation",
+    "Fidelity",
+    "QubitDensity",
+    "StateResult",
+    "SecondMomentOfEnergy",
+    "AggregationType",
+    "Results",
+]
+
+
+__version__ = "1.0.0"

emu_sv/custom_callback_implementations.py

@@ -0,0 +1,93 @@
+import math
+import torch
+
+from emu_base.base_classes.config import BackendConfig
+from emu_base.base_classes.default_callbacks import (
+    QubitDensity,
+    EnergyVariance,
+    SecondMomentOfEnergy,
+    CorrelationMatrix,
+)
+from emu_base.base_classes.operator import Operator
+
+from emu_sv import StateVector
+from emu_sv.hamiltonian import RydbergHamiltonian
+
+
+def qubit_density_sv_impl(
+    self: QubitDensity, config: BackendConfig, t: int, state: StateVector, H: Operator
+) -> torch.Tensor:
+    """
+    Custom implementation of the qubit density ❬ψ|nᵢ|ψ❭ for the state vector solver.
+    """
+    nqubits = int(math.log2(len(state.vector)))
+    state_tensor = state.vector.reshape((2,) * nqubits)
+
+    qubit_density = torch.zeros(nqubits, dtype=torch.float64, device=state_tensor.device)
+    for i in range(nqubits):
+        qubit_density[i] = state_tensor.select(i, 1).norm() ** 2
+    return qubit_density
+
+
+def correlation_matrix_sv_impl(
+    self: CorrelationMatrix,
+    config: BackendConfig,
+    t: int,
+    state: StateVector,
+    H: Operator,
+) -> torch.Tensor:
+    """
+    Custom implementation of the density-density correlation ❬ψ|nᵢnⱼ|ψ❭ for the state vector solver.
+
+    TODO: extend to arbitrary two-point correlation ❬ψ|AᵢBⱼ|ψ❭
+    """
+    nqubits = int(math.log2(len(state.vector)))
+    state_tensor = state.vector.reshape((2,) * nqubits)
+
+    correlation = torch.zeros(
+        nqubits, nqubits, dtype=torch.float64, device=state_tensor.device
+    )
+
+    for i in range(nqubits):
+        select_i = state_tensor.select(i, 1)
+        for j in range(i, nqubits):  # select the upper triangle
+            if i == j:
+                value = select_i.norm() ** 2
+            else:
+                value = select_i.select(j - 1, 1).norm() ** 2
+
+            correlation[i, j] = value
+            correlation[j, i] = value
+    return correlation
+
+
+def energy_variance_sv_impl(
+    self: EnergyVariance,
+    config: BackendConfig,
+    t: int,
+    state: StateVector,
+    H: RydbergHamiltonian,
+) -> torch.Tensor:
+    """
+    Custom implementation of the energy variance ❬ψ|H²|ψ❭-❬ψ|H|ψ❭² for the state vector solver.
+    """
+    hstate = H * state.vector
+    h_squared = torch.vdot(hstate, hstate).real
+    energy = torch.vdot(state.vector, hstate).real
+    energy_variance: torch.Tensor = h_squared - energy**2
+    return energy_variance
+
+
+def second_moment_sv_impl(
+    self: SecondMomentOfEnergy,
+    config: BackendConfig,
+    t: int,
+    state: StateVector,
+    H: RydbergHamiltonian,
+) -> torch.Tensor:
+    """
+    Custom implementation of the second moment of energy ❬ψ|H²|ψ❭
+    for the state vector solver.
+    """
+    hstate = H * state.vector
+    return torch.vdot(hstate, hstate).real

emu_sv/dense_operator.py

@@ -0,0 +1,199 @@
+from __future__ import annotations
+import itertools
+from typing import Any, Iterable
+
+import torch
+from emu_base.base_classes.operator import FullOp, QuditOp
+from emu_base import Operator, State, DEVICE_COUNT
+from emu_sv.state_vector import StateVector
+
+dtype = torch.complex128
+
+
+def _validate_operator_targets(operations: FullOp, nqubits: int) -> None:
+    """Check for `operator_for_string` method"""
+    for tensorop in operations:
+        target_qids = (factor[1] for factor in tensorop[1])
+        target_qids_list = list(itertools.chain(*target_qids))
+        target_qids_set = set(target_qids_list)
+        if len(target_qids_set) < len(target_qids_list):
+            # Either the qubit id has been defined twice in an operation:
+            for qids in target_qids:
+                if len(set(qids)) < len(qids):
+                    raise ValueError("Duplicate atom ids in argument list.")
+            # Or it was defined in two different operations
+            raise ValueError("Each qubit can be targeted by only one operation.")
+        if max(target_qids_set) >= nqubits:
+            raise ValueError(
+                "The operation targets more qubits than there are in the register."
+            )
+
+
+class DenseOperator(Operator):
+    """Operators in EMU-SV are dense matrices"""
+
+    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 __matmul__(self, other: Operator) -> DenseOperator:
+        """
+        Apply this operator to a other. The ordering is that
+        self is applied after other.
+
+        Args:
+            other: the operator to compose with self
+
+        Returns:
+            the composed operator
+        """
+        assert isinstance(
+            other, DenseOperator
+        ), "DenseOperator can only be multiplied with Operator"
+
+        return DenseOperator(self.matrix @ other.matrix)
+
+    def __add__(self, other: Operator) -> DenseOperator:
+        """
+        Returns the sum of two matrices
+
+        Args:
+            other: the other operator
+
+        Returns:
+            the summed operator
+        """
+        assert isinstance(other, DenseOperator), "MPO can only be added to another MPO"
+
+        return DenseOperator(self.matrix + other.matrix)
+
+    def __rmul__(self, scalar: complex) -> DenseOperator:
+        """
+        Multiply a DenseOperator by scalar.
+
+        Args:
+            scalar: the scale factor to multiply with
+
+        Returns:
+            the scaled MPO
+        """
+
+        return DenseOperator(self.matrix * scalar)
+
+    def __mul__(self, other: State) -> StateVector:
+        """
+        Applies this DenseOperator to the given StateVector.
+
+        Args:
+            other: the state to apply this operator to
+
+        Returns:
+            the resulting state
+        """
+        assert isinstance(
+            other, StateVector
+        ), "DenseOperator can only be applied to another DenseOperator"
+
+        return StateVector(self.matrix @ other.vector)
+
+    def expect(self, state: State) -> float | complex:
+        """
+        Compute the expectation value of self on the given state.
+
+        Args:
+            state: the state with which to compute
+
+        Returns:
+            the expectation
+        """
+        assert isinstance(
+            state, StateVector
+        ), "currently, only expectation values of StateVectors are \
+        supported"
+
+        return torch.vdot(state.vector, self.matrix @ state.vector).item()
+
+    @staticmethod
+    def from_operator_string(
+        basis: Iterable[str],
+        nqubits: int,
+        operations: FullOp,
+        operators: dict[str, QuditOp] = {},
+        /,
+        **kwargs: Any,
+    ) -> DenseOperator:
+        """
+        See the base class
+
+        Args:
+            basis: the eigenstates in the basis to use e.g. ('r', 'g')
+            nqubits: how many qubits there are in the state
+            operations: which bitstrings make up the state with what weight
+            operators: additional symbols to be used in operations
+
+        Returns:
+            the operator in MPO form.
+        """
+
+        _validate_operator_targets(operations, nqubits)
+
+        operators_with_tensors: dict[str, torch.Tensor | QuditOp] = dict(operators)
+
+        basis = set(basis)
+        if basis == {"r", "g"}:
+            # operators_with_tensors will now contain the basis for single qubit ops,
+            # and potentially user defined strings in terms of these
+            operators_with_tensors |= {
+                "gg": torch.tensor([[1.0, 0.0], [0.0, 0.0]], dtype=torch.complex128),
+                "gr": torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.complex128),
+                "rg": torch.tensor([[0.0, 1.0], [0.0, 0.0]], dtype=torch.complex128),
+                "rr": torch.tensor([[0.0, 0.0], [0.0, 1.0]], dtype=torch.complex128),
+            }
+        elif basis == {"0", "1"}:
+            # operators_with_tensors will now contain the basis for single qubit ops,
+            # and potentially user defined strings in terms of these
+            operators_with_tensors |= {
+                "00": torch.tensor([[1.0, 0.0], [0.0, 0.0]], dtype=torch.complex128),
+                "01": torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.complex128),
+                "10": torch.tensor([[0.0, 1.0], [0.0, 0.0]], dtype=torch.complex128),
+                "11": torch.tensor([[0.0, 0.0], [0.0, 1.0]], dtype=torch.complex128),
+            }
+        else:
+            raise ValueError("Unsupported basis provided")
+
+        accum_res = torch.zeros(2**nqubits, 2**nqubits, dtype=torch.complex128)
+        for coeff, tensorop in operations:
+            # this function will recurse through the operators_with_tensors,
+            # and replace any definitions in terms of strings by the computed matrix
+            def replace_operator_string(op: QuditOp | torch.Tensor) -> torch.Tensor:
+                if isinstance(op, torch.Tensor):
+                    return op
+
+                result = torch.zeros(2, 2, dtype=torch.complex128)
+                for opstr, coeff in op.items():
+                    tensor = replace_operator_string(operators_with_tensors[opstr])
+                    operators_with_tensors[opstr] = tensor
+                    result += tensor * coeff
+                return result
+
+            total_op_per_qubit = [torch.eye(2, 2, dtype=torch.complex128)] * nqubits
+
+            for op in tensorop:
+                factor = replace_operator_string(op[0])
+                for target_qubit in op[1]:
+                    total_op_per_qubit[target_qubit] = factor
+
+            dense_op = total_op_per_qubit[0]
+            for single_qubit_operator in total_op_per_qubit[1:]:
+                dense_op = torch.kron(dense_op, single_qubit_operator)
+
+            accum_res += coeff * dense_op
+        return DenseOperator(accum_res)

emu_sv/hamiltonian.py

@@ -0,0 +1,157 @@
+import torch
+from emu_sv.state_vector import StateVector
+
+
+class RydbergHamiltonian:
+    """
+    Representation of the Rydberg Hamiltonian with light-matter interaction:
+
+        H = ∑ⱼΩⱼ/2[cos(ϕⱼ)σˣⱼ + sin(ϕⱼ)σʸⱼ] - ∑ⱼΔⱼnⱼ + ∑ᵢ﹥ⱼUᵢⱼnᵢnⱼ
+
+    The Hamiltonian is parameterized by driving strengths or amplitudes Ωⱼ (`omegas`), detuning
+    values Δⱼ (`deltas`), phases ϕⱼ (`phis`) and interaction terms Uᵢⱼ (`interaction_matrix`).
+    Implements an efficient H*|ψ❭ as custom sparse matrix-vector multiplication.
+
+    Attributes:
+        omegas (torch.Tensor): driving strength Ωⱼ for each qubit, scaled by a factor 1/2.
+        deltas (torch.Tensor): detuning values Δⱼ for each qubit.
+        phis (torch.Tensor): phase values ϕⱼ for each qubit.
+        interaction_matrix (torch.Tensor): matrix Uᵢⱼ representing pairwise Rydberg
+            interaction strengths between qubits.
+        nqubits (int): number of qubits in the system.
+        diag (torch.Tensor): diagonal elements of the Hamiltonian,
+            calculated based on `deltas` and `interaction_matrix`.
+        inds (torch.Tensor): index tensor used for vector manipulations
+            in matrix-vector multiplications.
+
+    Methods:
+        __mul__(vec): implements matrix-vector multiplication with a state vector.
+        _create_diagonal(): constructs the diagonal elements of the Hamiltonian
+            based on `deltas` and `interaction_matrix`.
+        _apply_sigma_operators_complex(): apply all driving sigma operators,
+             with driving strenght `omegas` and phases `phis`.
+        _apply_sigma_operators_real(): only applies ∑ⱼ(Ωⱼ/2)σˣⱼ when all phases are zero (ϕⱼ=0).
+    """
+
+    def __init__(
+        self,
+        omegas: torch.Tensor,
+        deltas: torch.Tensor,
+        phis: torch.Tensor,
+        interaction_matrix: torch.Tensor,
+        device: torch.device,
+    ):
+        self.nqubits: int = len(omegas)
+        self.omegas: torch.Tensor = omegas / 2.0
+        self.deltas: torch.Tensor = deltas
+        self.phis: torch.Tensor = phis
+        self.interaction_matrix: torch.Tensor = interaction_matrix
+        self.device: torch.device = device
+
+        self.diag: torch.Tensor = self._create_diagonal()
+        self.inds = torch.tensor([1, 0], device=self.device)  # flips the state, for σˣ
+
+        self._apply_sigma_operators = self._apply_sigma_operators_real
+        if self.phis.any():
+            self._apply_sigma_operators = self._apply_sigma_operators_complex
+
+    def __mul__(self, vec: torch.Tensor) -> torch.Tensor:
+        """
+        Apply the `RydbergHamiltonian` to the input state vector, i.e. H*|ψ❭.
+
+        - The diagonal part of the Hamiltonian (Δⱼ and Uᵢⱼ terms) is stored and
+        applyed directly as H.diag*|ψ❭.
+        - The off-diagonal part (Ωⱼ and ϕⱼ terms) are applied sequentially across
+        qubit indices in `self._apply_sigma_operators`.
+
+        Args:
+            vec (torch.Tensor): vec (torch.Tensor): the input state vector.
+
+        Returns:
+            the resulting state vector.
+        """
+        # (-∑ⱼΔⱼnⱼ + ∑ᵢ﹥ⱼUᵢⱼnᵢnⱼ)|ψ❭
+        diag_result = self.diag * vec
+        # ∑ⱼΩⱼ/2[cos(ϕⱼ)σˣⱼ + sin(ϕⱼ)σʸⱼ]|ψ❭
+        sigma_result = self._apply_sigma_operators(vec)
+        result: torch.Tensor
+        result = diag_result + sigma_result
+
+        return result
+
+    def _apply_sigma_operators_real(self, vec: torch.Tensor) -> torch.Tensor:
+        """
+        Apply the ∑ⱼ(Ωⱼ/2)σˣⱼ operator to the input vector |ψ❭.
+
+        Args:
+            vec (torch.Tensor): the input state vector.
+
+        Returns:
+            the resulting state vector.
+        """
+        result = torch.zeros_like(vec)
+
+        dim_to_act = 1
+        for n, omega_n in enumerate(self.omegas):
+            shape_n = (2**n, 2, 2 ** (self.nqubits - n - 1))
+            vec = vec.reshape(shape_n)
+            result = result.reshape(shape_n)
+            result.index_add_(dim_to_act, self.inds, vec, alpha=omega_n)
+
+        return result.reshape(-1)
+
+    def _apply_sigma_operators_complex(self, vec: torch.Tensor) -> torch.Tensor:
+        """
+        Apply the ∑ⱼΩⱼ/2[cos(ϕⱼ)σˣⱼ + sin(ϕⱼ)σʸⱼ] operator to the input vector |ψ❭.
+
+        Args:
+            vec (torch.Tensor): the input state vector.
+
+        Returns:
+            the resulting state vector.
+        """
+        c_omegas = self.omegas * torch.exp(1j * self.phis)
+        result = torch.zeros_like(vec)
+
+        dim_to_act = 1
+        for n, c_omega_n in enumerate(c_omegas):
+            shape_n = (2**n, 2, 2 ** (self.nqubits - n - 1))
+            vec = vec.reshape(shape_n)
+            result = result.reshape(shape_n)
+            result.index_add_(
+                dim_to_act, self.inds[0], vec[:, 0, :].unsqueeze(1), alpha=c_omega_n
+            )
+            result.index_add_(
+                dim_to_act,
+                self.inds[1],
+                vec[:, 1, :].unsqueeze(1),
+                alpha=c_omega_n.conj(),
+            )
+
+        return result.reshape(-1)
+
+    def _create_diagonal(self) -> torch.Tensor:
+        """
+        Return the diagonal elements of the Rydberg Hamiltonian matrix
+
+            H.diag = -∑ⱼΔⱼnⱼ + ∑ᵢ﹥ⱼUᵢⱼnᵢnⱼ
+        """
+        diag = torch.zeros(2**self.nqubits, dtype=torch.complex128, device=self.device)
+
+        for i in range(self.nqubits):
+            diag = diag.reshape(2**i, 2, -1)
+            i_fixed = diag[:, 1, :]
+            i_fixed -= self.deltas[i]
+            for j in range(i + 1, self.nqubits):
+                i_fixed = i_fixed.reshape(2**i, 2 ** (j - i - 1), 2, -1)
+                # replacing i_j_fixed by i_fixed breaks the code :)
+                i_j_fixed = i_fixed[:, :, 1, :]
+                i_j_fixed += self.interaction_matrix[i, j]
+        return diag.reshape(-1)
+
+    def expect(self, state: StateVector) -> torch.Tensor:
+        """Return the energy expectation value E=❬ψ|H|ψ❭"""
+        assert isinstance(
+            state, StateVector
+        ), "Currently, only expectation values of StateVectors are supported"
+        return torch.vdot(state.vector, self * state.vector)

emu_sv/state_vector.py

@@ -0,0 +1,271 @@
+from __future__ import annotations
+
+from collections import Counter
+from typing import Any, Iterable
+import math
+
+
+from emu_base import State, DEVICE_COUNT
+
+import torch
+
+dtype = torch.complex128
+
+
+class StateVector(State):
+    """
+    Represents a quantum state vector in a computational basis.
+
+    This class extends the `State` class to handle state vectors,
+    providing various utilities for initialization, normalization,
+    manipulation, and measurement. The state vector must have a length
+    that is a power of 2, representing 2ⁿ basis states for n qubits.
+
+    Attributes:
+        vector: 1D tensor representation of a state vector.
+        gpu: store the vector on GPU if True, otherwise on CPU
+    """
+
+    def __init__(
+        self,
+        vector: torch.Tensor,
+        *,
+        gpu: bool = True,
+    ):
+        # NOTE: this accepts also zero vectors.
+
+        assert math.log2(
+            len(vector)
+        ).is_integer(), "The number of elements in the vector should be power of 2"
+
+        device = "cuda" if gpu and DEVICE_COUNT > 0 else "cpu"
+        self.vector = vector.to(dtype=dtype, device=device)
+
+    def _normalize(self) -> None:
+        # NOTE: use this in the callbacks
+        """Checks if the input is normalized or not"""
+        norm_state = torch.linalg.vector_norm(self.vector)
+
+        if not torch.allclose(norm_state, torch.tensor(1.0, dtype=torch.float64)):
+            self.vector = self.vector / norm_state
+
+    @classmethod
+    def zero(cls, num_sites: int, gpu: bool = True) -> StateVector:
+        """
+        Returns a zero uninitialized "state" vector. Warning, this has no physical meaning as-is!
+
+        Args:
+            num_sites: the number of qubits
+            gpu: whether gpu or cpu
+
+        Returns:
+            The zero state
+
+        Examples:
+            >>> StateVector.zero(2)
+            tensor([0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j], dtype=torch.complex128)
+        """
+
+        device = "cuda" if gpu and DEVICE_COUNT > 0 else "cpu"
+        vector = torch.zeros(2**num_sites, dtype=dtype, device=device)
+        return cls(vector, gpu=gpu)
+
+    @classmethod
+    def make(cls, num_sites: int, gpu: bool = True) -> StateVector:
+        """
+        Returns a State vector in ground state |000..0>.
+        The vector in the output of StateVector has the shape (2,)*number of qubits
+
+        Args:
+            num_sites: the number of qubits
+            gpu: whether gpu or cpu
+
+        Returns:
+            The described state
+
+        Examples:
+            >>> StateVector.make(2)
+            tensor([1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j], dtype=torch.complex128)
+        """
+
+        result = cls.zero(num_sites=num_sites, gpu=gpu)
+        result.vector[0] = 1.0
+        return result
+
+    def inner(self, other: State) -> float | complex:
+        """
+        Compute <self, other>. The type of other must be StateVector.
+
+        Args:
+            other: the other state
+
+        Returns:
+            the inner product
+        """
+        assert isinstance(
+            other, StateVector
+        ), "Other state also needs to be a StateVector"
+        assert (
+            self.vector.shape == other.vector.shape
+        ), "States do not have the same number of sites"
+
+        return torch.vdot(self.vector, other.vector).item()
+
+    def sample(
+        self, num_shots: int = 1000, p_false_pos: float = 0.0, p_false_neg: float = 0.0
+    ) -> Counter[str]:
+        """
+        Samples bitstrings, taking into account the specified error rates.
+
+        Args:
+            num_shots: how many bitstrings to sample
+            p_false_pos: the rate at which a 0 is read as a 1
+            p_false_neg: teh rate at which a 1 is read as a 0
+
+        Returns:
+            the measured bitstrings, by count
+        """
+
+        probabilities = torch.abs(self.vector) ** 2
+        probabilities /= probabilities.sum()  # multinomial does not normalize the input
+
+        outcomes = torch.multinomial(probabilities, num_shots, replacement=True)
+
+        # Convert outcomes to bitstrings and count occurrences
+        counts = Counter([self._index_to_bitstring(outcome) for outcome in outcomes])
+
+        # NOTE: false positives and negatives
+        return counts
+
+    def _index_to_bitstring(self, index: int) -> str:
+        """
+        Convert an integer index into its corresponding bitstring representation.
+        """
+        nqubits = int(math.log2(self.vector.reshape(-1).shape[0]))
+        return format(index, f"0{nqubits}b")
+
+    def __add__(self, other: State) -> StateVector:
+        """Sum of two state vectors
+
+        Args:
+            other: the vector to add to this vector
+
+        Returns:
+            The summed state
+        """
+        assert isinstance(
+            other, StateVector
+        ), "Other state also needs to be a StateVector"
+        result = self.vector + other.vector
+        return StateVector(result)
+
+    def __rmul__(self, scalar: complex) -> StateVector:
+        """Scalar multiplication
+
+        Args:
+            scalar: the scalar to multiply with
+
+        Returns:
+            The scaled state
+        """
+        result = scalar * self.vector
+
+        return StateVector(result)
+
+    def norm(self) -> float | complex:
+        """Returns the norm of the state
+
+        Returns:
+            the norm of the state
+        """
+        norm: float | complex = torch.linalg.vector_norm(self.vector).item()
+        return norm
+
+    def __repr__(self) -> str:
+        return repr(self.vector)
+
+    @staticmethod
+    def from_state_string(
+        *,
+        basis: Iterable[str],
+        nqubits: int,
+        strings: dict[str, complex],
+        **kwargs: Any,
+    ) -> StateVector:
+        """Transforms a state given by a string into a state vector.
+
+        Construct a state from the pulser abstract representation
+        https://pulser.readthedocs.io/en/stable/conventions.html
+
+        Args:
+            basis: A tuple containing the basis states (e.g., ('r', 'g')).
+            nqubits: the number of qubits.
+            strings: A dictionary mapping state strings to complex or floats amplitudes.
+
+        Returns:
+            The resulting state.
+
+        Examples:
+            >>> basis = ("r","g")
+            >>> n = 2
+            >>> st=StateVector.from_state_string(basis=basis,nqubits=n,strings={"rr":1.0,"gg":1.0})
+            >>> print(st)
+            tensor([0.7071+0.j, 0.0000+0.j, 0.0000+0.j, 0.7071+0.j], dtype=torch.complex128)
+        """
+
+        basis = set(basis)
+        if basis == {"r", "g"}:
+            one = "r"
+        elif basis == {"0", "1"}:
+            one = "1"
+        else:
+            raise ValueError("Unsupported basis provided")
+
+        accum_state = StateVector.zero(num_sites=nqubits, **kwargs)
+
+        for state, amplitude in strings.items():
+            bin_to_int = int(
+                state.replace(one, "1").replace("g", "0"), 2
+            )  # "0" basis is already in "0"
+            accum_state.vector[bin_to_int] = torch.tensor([amplitude])
+
+        accum_state._normalize()
+
+        return accum_state
+
+
+def inner(left: StateVector, right: StateVector) -> torch.Tensor:
+    """
+    Wrapper around StateVector.inner.
+
+    Args:
+        left:  StateVector argument
+        right: StateVector argument
+
+    Returns:
+        the inner product
+
+    Examples:
+        >>> factor = math.sqrt(2.0)
+        >>> basis = ("r","g")
+        >>> nqubits = 2
+        >>> string_state1 = {"gg":1.0,"rr":1.0}
+        >>> state1 = StateVector.from_state_string(basis=basis,
+        >>>     nqubits=nqubits,strings=string_state1)
+        >>> string_state2 = {"gr":1.0/factor,"rr":1.0/factor}
+        >>> state2 = StateVector.from_state_string(basis=basis,
+        >>>     nqubits=nqubits,strings=string_state2)
+        >>> inner(state1,state2).item()
+        (0.4999999999999999+0j)
+    """
+
+    assert (left.vector.shape == right.vector.shape) and (
+        left.vector.dim() == 1
+    ), "Shape of a and b should be the same and both needs to be 1D tesnor"
+    return torch.inner(left.vector, right.vector)
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

emu_sv/sv_backend.py

@@ -0,0 +1,123 @@
+from emu_base.base_classes.backend import Backend, BackendConfig
+from emu_base.base_classes.results import Results
+from emu_sv.sv_config import SVConfig
+from pulser import Sequence
+from emu_base.pulser_adapter import PulserData
+from emu_sv.time_evolution import do_time_step
+from emu_sv import StateVector
+import torch
+from time import time
+from resource import RUSAGE_SELF, getrusage
+from emu_base import DEVICE_COUNT
+
+
+class SVBackend(Backend):
+    """
+    A backend for emulating Pulser sequences using state vectors and sparse matrices.
+    """
+
+    def run(self, sequence: Sequence, sv_config: BackendConfig) -> Results:
+        """
+        Emulates the given sequence.
+
+        Args:
+            sequence: a Pulser sequence to simulate
+            sv_config: the backends config. Should be of type SVConfig
+
+        Returns:
+            the simulation results
+        """
+        assert isinstance(sv_config, SVConfig)
+
+        self.validate_sequence(sequence)
+
+        results = Results()
+
+        data = PulserData(sequence=sequence, config=sv_config, dt=sv_config.dt)
+        omega, delta, phi = data.omega, data.delta, data.phi
+
+        nsteps = omega.shape[0]
+        nqubits = omega.shape[1]
+        device = "cuda" if sv_config.gpu and DEVICE_COUNT > 0 else "cpu"
+
+        if sv_config.initial_state is not None:
+            state = sv_config.initial_state
+            state.vector = state.vector.to(device)
+        else:
+            state = StateVector.make(nqubits, gpu=sv_config.gpu)
+
+        dt = sv_config.dt * 1e-3  # ns to µs
+
+        for step in range(nsteps):
+
+            start = time()
+
+            state.vector, H = do_time_step(
+                dt,
+                omega[step],
+                delta[step],
+                phi[step],
+                data.full_interaction_matrix,
+                state.vector,
+                sv_config.krylov_tolerance,
+            )
+
+            for callback in sv_config.callbacks:
+                callback(
+                    sv_config,
+                    (step + 1) * sv_config.dt,
+                    state,
+                    H,  # type: ignore[arg-type]
+                    results,
+                )
+
+            end = time()
+            self.log_step_statistics(
+                results,
+                step=step,
+                duration=end - start,
+                timestep_count=nsteps,
+                state=state,
+                sv_config=sv_config,
+            )
+
+        return results
+
+    @staticmethod
+    def log_step_statistics(
+        results: Results,
+        *,
+        step: int,
+        duration: float,
+        timestep_count: int,
+        state: StateVector,
+        sv_config: SVConfig,
+    ) -> None:
+        if state.vector.is_cuda:
+            max_mem_per_device = (
+                torch.cuda.max_memory_allocated(device) * 1e-6
+                for device in range(torch.cuda.device_count())
+            )
+            max_mem = max(max_mem_per_device)
+        else:
+            max_mem = getrusage(RUSAGE_SELF).ru_maxrss * 1e-3
+
+        sv_config.logger.info(
+            f"step = {step + 1}/{timestep_count}, "
+            + f"RSS = {max_mem:.3f} MB, "
+            + f"Δt = {duration:.3f} s"
+        )
+
+        if results.statistics is None:
+            assert step == 0
+            results.statistics = {"steps": []}
+
+        assert "steps" in results.statistics
+        assert len(results.statistics["steps"]) == step
+
+        results.statistics["steps"].append(
+            {
+                "RSS": max_mem,
+                "duration": duration,
+            }
+        )

emu_sv/sv_config.py

@@ -0,0 +1,90 @@
+from emu_base.base_classes import (
+    CorrelationMatrix,
+    QubitDensity,
+    EnergyVariance,
+    SecondMomentOfEnergy,
+)
+
+import copy
+
+
+from emu_base import BackendConfig
+from emu_sv import StateVector
+from typing import Any
+
+from emu_sv.custom_callback_implementations import (
+    qubit_density_sv_impl,
+    energy_variance_sv_impl,
+    second_moment_sv_impl,
+    correlation_matrix_sv_impl,
+)
+
+from types import MethodType
+
+
+class SVConfig(BackendConfig):
+    """
+    The configuration of the emu-sv SVBackend. The kwargs passed to this class
+    are passed on to the base class.
+    See the API for that class for a list of available options.
+
+    Args:
+        initial_state: the initial state to use in the simulation
+        dt: the timestep size that the solver uses. Note that observables are
+            only calculated if the evaluation_times are divisible by dt.
+        max_krylov_dim:
+            the size of the krylov subspace that the Lanczos algorithm maximally builds
+        krylov_tolerance:
+            the Lanczos algorithm uses this as the convergence tolerance
+        gpu: Use 1 gpu if True, and a GPU is available, otherwise, cpu.
+            Will cause errors if True when a gpu is not available
+        kwargs: arguments that are passed to the base class
+
+    Examples:
+        >>> gpu = True
+        >>> dt = 1 #this will impact the runtime
+        >>> krylov_tolerance = 1e-8 #the simulation will be faster, but less accurate
+        >>> SVConfig(gpu=gpu, dt=dt, krylov_tolerance=krylov_tolerance,
+        >>>     with_modulation=True) #the last arg is taken from the base class
+    """
+
+    def __init__(
+        self,
+        *,
+        initial_state: StateVector | None = None,
+        dt: int = 10,
+        max_krylov_dim: int = 100,
+        krylov_tolerance: float = 1e-10,
+        gpu: bool = True,
+        **kwargs: Any,
+    ):
+        super().__init__(**kwargs)
+
+        self.initial_state = initial_state
+        self.dt = dt
+        self.max_krylov_dim = max_krylov_dim
+        self.gpu = gpu
+        self.krylov_tolerance = krylov_tolerance
+
+        for num, obs in enumerate(self.callbacks):  # monkey patch
+            obs_copy = copy.deepcopy(obs)
+            if isinstance(obs, QubitDensity):
+                obs_copy.apply = MethodType(  # type: ignore[method-assign]
+                    qubit_density_sv_impl, obs
+                )
+                self.callbacks[num] = obs_copy
+            elif isinstance(obs, EnergyVariance):
+                obs_copy.apply = MethodType(  # type: ignore[method-assign]
+                    energy_variance_sv_impl, obs
+                )
+                self.callbacks[num] = obs_copy
+            elif isinstance(obs, SecondMomentOfEnergy):
+                obs_copy.apply = MethodType(  # type: ignore[method-assign]
+                    second_moment_sv_impl, obs
+                )
+                self.callbacks[num] = obs_copy
+            elif isinstance(obs, CorrelationMatrix):
+                obs_copy.apply = MethodType(  # type: ignore[method-assign]
+                    correlation_matrix_sv_impl, obs
+                )
+                self.callbacks[num] = obs_copy

emu_sv/time_evolution.py

@@ -0,0 +1,32 @@
+import torch
+
+from emu_base.math.krylov_exp import krylov_exp
+from emu_sv.hamiltonian import RydbergHamiltonian
+
+
+def do_time_step(
+    dt: float,
+    omegas: torch.Tensor,
+    deltas: torch.Tensor,
+    phis: torch.Tensor,
+    full_interaction_matrix: torch.Tensor,
+    state_vector: torch.Tensor,
+    krylov_tolerance: float,
+) -> tuple[torch.Tensor, RydbergHamiltonian]:
+    ham = RydbergHamiltonian(
+        omegas=omegas,
+        deltas=deltas,
+        phis=phis,
+        interaction_matrix=full_interaction_matrix,
+        device=state_vector.device,
+    )
+    op = lambda x: -1j * dt * (ham * x)
+    return (
+        krylov_exp(
+            op,
+            state_vector,
+            norm_tolerance=krylov_tolerance,
+            exp_tolerance=krylov_tolerance,
+        ),
+        ham,
+    )

emu_sv-1.0.0.dist-info/METADATA

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: emu-sv
+Version: 1.0.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
+Project-URL: Issues, https://github.com/pasqal-io/emulators/issues
+Author-email: Anton Quelle <anton.quelle@pasqal.com>, Mauro Mendizabal <mauro.mendizabal-pico@pasqal.com>, Stefano Grava <stefano.grava@pasqal.com>, Pablo Le Henaff <pablo.le-henaff@pasqal.com>
+License: PASQAL OPEN-SOURCE SOFTWARE LICENSE AGREEMENT (MIT-derived)
+        
+        The author of the License is:
+          Pasqal, a Société par Actions Simplifiée (Simplified Joint Stock Company) registered under number 849 441 522 at the Registre du commerce et des sociétés (Trade and Companies Register) of Evry – France, headquartered at 7 rue Leonard de Vinci – 91300 – Massy – France, duly represented by its Président, M. Georges-Olivier REYMOND,
+        
+        Hereafter referred to as « the Licensor »
+        
+        - Permission is hereby granted, free of charge, to any person obtaining a copy of this software (the “Licensee”) and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. The Software is “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and non-infringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise arising from, out of or in connection with the Software or the use or other dealings in the Software.
+        
+        - If use of the Software leads to the necessary use of any patent of the Licensor and/or any of its Affiliates (defined as a company owned or controlled by the Licensor), the Licensee is granted a royalty-free license, in any country where such patent is in force, to use the object of such patent; or use the process covered by such patent,
+        
+        - Such a patent license is granted for internal research or academic use of the Licensee's, which includes use by employees and students of the Licensee, acting on behalf of the Licensee, for research purposes only.
+        
+        - The License is governed by the laws of France. Any dispute relating to the License, notably its execution, performance and/or termination shall be brought to, heard and tried by the Tribunal Judiciaire de Paris, regardless of the rules of jurisdiction in the matter.
+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==1.2.6
+Description-Content-Type: text/markdown
+
+<div align="center">
+  <img src="docs/logos/LogoTaglineSoftGreen.svg">
+</div>
+
+# Welcome to the Pasqal analog emulators
+
+Welcome, and please see the [GitHub pages](https://pasqal-io.github.io/emulators/) for a landing page to this repo.

emu_sv-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+emu_sv/__init__.py,sha256=Ji7PePRQka8XrVMw3N3i2k_sBwMQIj6LBOZFGZ0HNvs,845
+emu_sv/custom_callback_implementations.py,sha256=H7fy0trUtY00wid6VeRJ2inUazFbkMlgavTfm8QtGq8,2754
+emu_sv/dense_operator.py,sha256=69rv1J5jsHSRoPsgZqKJZnttCgMLIk4tDCBsOaOBVR8,7034
+emu_sv/hamiltonian.py,sha256=uzR7XHsv0QXBbcNuk93-phrO-On-WfJCINWz7Zofc90,6270
+emu_sv/state_vector.py,sha256=XsbHDNu6LDBop_qVVUoaw8blVPOystP8MOQ9demME6g,8125
+emu_sv/sv_backend.py,sha256=cghNpJq8ALdcoHCnx0xHcZBM9x8URLRFo0_sZ5CXXvY,3576
+emu_sv/sv_config.py,sha256=NUAxqYG0NTWbarVreFr1Tb-8FzB0LVQ0fYnb2QSCzxo,3161
+emu_sv/time_evolution.py,sha256=48C0DL_SOu7Jdjk2QKBNPsevOpQlgsPYUHE7cScY-ZM,796
+emu_sv-1.0.0.dist-info/METADATA,sha256=yqdJOFSlS5RqKiBC-Tx_LSL2n3hFnkt1unkv3UMNJG8,3513
+emu_sv-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emu_sv-1.0.0.dist-info/RECORD,,

emu_sv-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any