emu-sv 2.2.1__py3-none-any.whl → 2.4.0__py3-none-any.whl

emu_sv/__init__.py

@@ -38,4 +38,4 @@ __all__ = [
     "DensityMatrix",
 ]
 
-__version__ = "2.2.1"
+__version__ = "2.4.0"

emu_sv/dense_operator.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import itertools
 from functools import reduce
 
 import torch
@@ -20,25 +19,6 @@ from pulser.backend.state import Eigenstate
 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[complex, torch.Tensor, StateVector]):
     """DenseOperator in EMU-SV use dense matrices"""
 
@@ -149,7 +129,6 @@ class DenseOperator(Operator[complex, torch.Tensor, StateVector]):
             A DenseOperator instance corresponding to the given representation.
         """
 
-        _validate_operator_targets(operations, n_qudits)
         assert len(set(eigenstates)) == 2, "Only qubits are supported in EMU-SV."
 
         operators_with_tensors: dict[str, torch.Tensor | QuditOp] = dict()

emu_sv/density_matrix_state.py

@@ -4,7 +4,7 @@ import math
 from typing import Mapping, TypeVar, Type, Sequence
 import torch
 from pulser.backend import State
-from emu_base import DEVICE_COUNT
+from emu_base import DEVICE_COUNT, apply_measurement_errors
 from emu_sv.state_vector import StateVector
 from emu_sv.utils import index_to_bitstring
 from pulser.backend.state import Eigenstate
@@ -80,7 +80,9 @@ class DensityMatrix(State[complex, torch.Tensor]):
             self.matrix.shape == other.matrix.shape
         ), "States do not have the same number of sites"
 
-        return torch.vdot(self.matrix.flatten(), other.matrix.flatten())
+        return torch.vdot(
+            self.matrix.flatten(), other.matrix.to(self.matrix.device).flatten()
+        )
 
     @classmethod
     def from_state_vector(cls, state: StateVector) -> DensityMatrix:
@@ -176,8 +178,6 @@ class DensityMatrix(State[complex, torch.Tensor]):
          Counter({'00': 517, '11': 483})
         """
 
-        assert p_false_neg == p_false_pos == 0.0, "Error rates must be 0.0"
-
         probabilities = torch.abs(self.matrix.diagonal())
 
         outcomes = torch.multinomial(probabilities, num_shots, replacement=True)
@@ -187,6 +187,12 @@ class DensityMatrix(State[complex, torch.Tensor]):
             [index_to_bitstring(self.n_qudits, outcome) for outcome in outcomes]
         )
 
+        if p_false_neg > 0 or p_false_pos > 0:
+            counts = apply_measurement_errors(
+                counts,
+                p_false_pos=p_false_pos,
+                p_false_neg=p_false_neg,
+            )
         return counts
 
 

emu_sv/state_vector.py

@@ -8,7 +8,7 @@ import torch
 
 from emu_sv.utils import index_to_bitstring
 
-from emu_base import DEVICE_COUNT
+from emu_base import DEVICE_COUNT, apply_measurement_errors
 from pulser.backend import State
 from pulser.backend.state import Eigenstate
 
@@ -134,7 +134,7 @@ class StateVector(State[complex, torch.Tensor]):
         ), "States do not have the same shape"
 
         # by our internal convention inner and norm return to cpu
-        return torch.vdot(self.vector, other.vector).cpu()
+        return torch.vdot(self.vector, other.vector.to(self.vector.device)).cpu()
 
     def sample(
         self,
@@ -155,7 +155,6 @@ class StateVector(State[complex, torch.Tensor]):
         Returns:
             the measured bitstrings, by count
         """
-        assert p_false_neg == p_false_pos == 0.0, "Error rates must be 0.0"
 
         probabilities = torch.abs(self.vector) ** 2
 
@@ -166,7 +165,12 @@ class StateVector(State[complex, torch.Tensor]):
             [index_to_bitstring(self.n_qudits, outcome) for outcome in outcomes]
         )
 
-        # NOTE: false positives and negatives
+        if p_false_neg > 0 or p_false_pos > 0:
+            counts = apply_measurement_errors(
+                counts,
+                p_false_pos=p_false_pos,
+                p_false_neg=p_false_neg,
+            )
         return counts
 
     def __add__(self, other: State) -> StateVector:

emu_sv/sv_backend_impl.py

@@ -1,15 +1,14 @@
 from abc import abstractmethod
 import time
 import typing
+import torch
 
 from emu_sv.hamiltonian import RydbergHamiltonian
 from emu_sv.lindblad_operator import RydbergLindbladian
 from pulser import Sequence
-import torch
-from resource import RUSAGE_SELF, getrusage
 
 from pulser.backend import Results, Observable, State, EmulationConfig
-from emu_base import PulserData
+from emu_base import PulserData, get_max_rss
 
 from emu_sv.state_vector import StateVector
 from emu_sv.density_matrix_state import DensityMatrix
@@ -45,20 +44,12 @@ class Statistics(Observable):
         assert isinstance(state, StateVector | DensityMatrix)
         assert isinstance(config, SVConfig)
         duration = self.data[-1]
-        if isinstance(state, StateVector) and 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)
-        elif isinstance(state, DensityMatrix) and state.matrix.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
+        max_mem = get_max_rss(
+            isinstance(state, StateVector)
+            and state.vector.is_cuda
+            or isinstance(state, DensityMatrix)
+            and state.matrix.is_cuda
+        )
 
         config.logger.info(
             f"step = {len(self.data)}/{self.timestep_count}, "
@@ -77,6 +68,8 @@ class BaseSVBackendImpl:
     This class is used to handle the state vector and density matrix evolution.
     """
 
+    well_prepared_qubits_filter: typing.Optional[torch.Tensor]
+
     def __init__(self, config: SVConfig, pulser_data: PulserData):
         self._config = config
         self._pulser_data = pulser_data
@@ -86,6 +79,7 @@ class BaseSVBackendImpl:
         self.phi = pulser_data.phi
         self.nsteps = pulser_data.omega.shape[0]
         self.nqubits = pulser_data.omega.shape[1]
+        self.full_interaction_matrix = pulser_data.full_interaction_matrix
         self.state: State
         self.time = time.time()
         self.results = Results(atom_order=(), total_duration=self.target_times[-1])
@@ -95,7 +89,6 @@ class BaseSVBackendImpl:
             timestep_count=self.nsteps,
         )
         self._current_H: None | RydbergLindbladian | RydbergHamiltonian = None
-
         if self._config.initial_state is not None and (
             self._config.initial_state.n_qudits != self.nqubits
         ):
@@ -103,6 +96,32 @@ class BaseSVBackendImpl:
                 "Mismatch in number of atoms: initial state has "
                 f"{self._config.initial_state.n_qudits} and the sequence has {self.nqubits}"
             )
+        self.init_dark_qubits()
+
+        if (
+            self._config.initial_state is not None
+            and self._config.noise_model.state_prep_error > 0.0
+        ):
+            raise NotImplementedError(
+                "Initial state and state preparation error can not be together."
+            )
+
+    def init_dark_qubits(self) -> None:
+        if self._config.noise_model.state_prep_error > 0.0:
+            bad_atoms = self._pulser_data.hamiltonian.bad_atoms
+            self.well_prepared_qubits_filter = torch.tensor(
+                [bool(bad_atoms[x]) for x in self._pulser_data.qubit_ids]
+            )
+        else:
+            self.well_prepared_qubits_filter = None
+
+        if self.well_prepared_qubits_filter is not None:
+
+            self.full_interaction_matrix[self.well_prepared_qubits_filter, :] = 0.0
+            self.full_interaction_matrix[:, self.well_prepared_qubits_filter] = 0.0
+            self.omega[:, self.well_prepared_qubits_filter] = 0.0
+            self.delta[:, self.well_prepared_qubits_filter] = 0.0
+            self.phi[:, self.well_prepared_qubits_filter] = 0.0
 
     def step(self, step_idx: int) -> None:
         """One step of the evolution"""
@@ -153,7 +172,7 @@ class SVBackendImpl(BaseSVBackendImpl):
 
     def __init__(self, config: SVConfig, pulser_data: PulserData):
         """
-        For running sequences without noise. The state will evolve accoring
+        For running sequences without noise. The state will evolve according
         to e^(-iH t)
 
         Args:
@@ -179,7 +198,7 @@ class SVBackendImpl(BaseSVBackendImpl):
             self.omega[step_idx],
             self.delta[step_idx],
             self.phi[step_idx],
-            self._pulser_data.full_interaction_matrix,
+            self.full_interaction_matrix,
             self.state.vector,
             self._config.krylov_tolerance,
         )
@@ -216,7 +235,7 @@ class NoisySVBackendImpl(BaseSVBackendImpl):
             self.omega[step_idx],
             self.delta[step_idx],
             self.phi[step_idx],
-            self._pulser_data.full_interaction_matrix,
+            self.full_interaction_matrix,
             self.state.matrix,
             self._config.krylov_tolerance,
             self.pulser_lindblads,

emu_sv/sv_config.py

@@ -5,15 +5,17 @@ import sys
 from types import MethodType
 from typing import Any, ClassVar
 
+from emu_sv.utils import choose
+
 from emu_sv.custom_callback_implementations import (
+    qubit_occupation_sv_impl,
+    qubit_occupation_sv_den_mat_impl,
     correlation_matrix_sv_impl,
     correlation_matrix_sv_den_mat_impl,
     energy_second_moment_sv_impl,
     energy_second_moment_den_mat_impl,
     energy_variance_sv_impl,
     energy_variance_sv_den_mat_impl,
-    qubit_occupation_sv_impl,
-    qubit_occupation_sv_den_mat_impl,
 )
 
 from pulser.backend import (
@@ -105,10 +107,6 @@ class SVConfig(EmulationConfig):
                 "Warning: The runs and samples_per_run "
                 "values of the NoiseModel are ignored!"
             )
-        if "SPAM" in self.noise_model.noise_types:
-            raise NotImplementedError(
-                "SPAM errors are currently not supported in emu-sv."
-            )
 
     def _expected_kwargs(self) -> set[str]:
         return super()._expected_kwargs() | {
@@ -129,37 +127,25 @@ class SVConfig(EmulationConfig):
 
             if isinstance(obs, Occupation):
                 obs_copy.apply = MethodType(  # type: ignore[method-assign]
-                    (
-                        qubit_occupation_sv_impl
-                        if self.noise_model.noise_types == ()
-                        else qubit_occupation_sv_den_mat_impl
-                    ),
+                    choose(qubit_occupation_sv_impl, qubit_occupation_sv_den_mat_impl),
                     obs_copy,
                 )
             if isinstance(obs, CorrelationMatrix):
                 obs_copy.apply = MethodType(  # type: ignore[method-assign]
-                    (
-                        correlation_matrix_sv_impl
-                        if self.noise_model.noise_types == ()
-                        else correlation_matrix_sv_den_mat_impl
+                    choose(
+                        correlation_matrix_sv_impl, correlation_matrix_sv_den_mat_impl
                     ),
                     obs_copy,
                 )
             if isinstance(obs, EnergyVariance):
                 obs_copy.apply = MethodType(  # type: ignore[method-assign]
-                    (
-                        energy_variance_sv_impl
-                        if self.noise_model.noise_types == ()
-                        else energy_variance_sv_den_mat_impl
-                    ),
+                    choose(energy_variance_sv_impl, energy_variance_sv_den_mat_impl),
                     obs_copy,
                 )
             elif isinstance(obs, EnergySecondMoment):
                 obs_copy.apply = MethodType(  # type: ignore[method-assign]
-                    (
-                        energy_second_moment_sv_impl
-                        if self.noise_model.noise_types == ()
-                        else energy_second_moment_den_mat_impl
+                    choose(
+                        energy_second_moment_sv_impl, energy_second_moment_den_mat_impl
                     ),
                     obs_copy,
                 )

emu_sv/utils.py

@@ -1,3 +1,8 @@
+from typing import Callable
+
+from pyparsing import Any
+
+
 def index_to_bitstring(nqubits: int, index: int) -> str:
     """
     Convert an integer index into its corresponding bitstring representation.
@@ -6,3 +11,24 @@ def index_to_bitstring(nqubits: int, index: int) -> str:
     msg = f"index {index} can not exceed Hilbert space size d**{nqubits}"
     assert index < 2**nqubits, msg
     return format(index, f"0{nqubits}b")
+
+
+def choose(
+    state_vector_version: Callable,
+    density_matrix_version: Callable,
+) -> Callable:
+    """Returns the observable result function that chooses the correct
+    implementation based on the type of state (StateVector or DensityMatrix).
+    """
+    from emu_sv.state_vector import StateVector
+    from emu_sv.density_matrix_state import DensityMatrix
+
+    def result(self: Any, *, state: StateVector | DensityMatrix, **kwargs: Any) -> Any:
+        if isinstance(state, StateVector):
+            return state_vector_version(self, state=state, **kwargs)
+        elif isinstance(state, DensityMatrix):
+            return density_matrix_version(self, state=state, **kwargs)
+        else:
+            raise TypeError(f"Unsupported state: {type(state).__name__}")
+
+    return result

{emu_sv-2.2.1.dist-info → emu_sv-2.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emu-sv
-Version: 2.2.1
+Version: 2.4.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.2.1
+Requires-Dist: emu-base==2.4.0
 Description-Content-Type: text/markdown
 
 <div align="center">

emu_sv-2.4.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+emu_sv/__init__.py,sha256=Oc9_UlpE7Nioggmg-pX4_8iQnh7_o9jl8n_wBTu5NJg,771
+emu_sv/custom_callback_implementations.py,sha256=_7XLIDzJ-p3DVqz-Jyv0eYbl8nih2x2p-pM4cBCLumA,6367
+emu_sv/dense_operator.py,sha256=AvgntJNwwtf3Wl66CIWSwUezVYV3vignCL24SQQQwQg,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/state_vector.py,sha256=dkAnxEQxK-4Fn6UxhDbcb1z1EsHFUpOyVy0mjHkKFBI,9894
+emu_sv/sv_backend.py,sha256=-soOkSEzEBK1dCKnYnbtvYjmNZtZra1_4jP3H1ROOtM,737
+emu_sv/sv_backend_impl.py,sha256=OYsJK_DJ8dmq3QZLKiBejXrq22R5Auyye-pai07NeeY,8798
+emu_sv/sv_config.py,sha256=J4yb9-Na5hAbShDySzPfbt0WXvL8JpfrTEikTK8nH9s,5943
+emu_sv/time_evolution.py,sha256=_VH4f2RF6lGKzO08WxTYJ5Aw8_pTTMRKcyMnIuxH03I,13382
+emu_sv/utils.py,sha256=t0nMDVo6DF5bQW-vbsyRMCmvkyNxCU-v0Enmns9aOAU,1151
+emu_sv-2.4.0.dist-info/METADATA,sha256=HKTJmI_Ra3dcFw2QthE2TEvEiYcvcZmrHkrFMuGY794,3595
+emu_sv-2.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emu_sv-2.4.0.dist-info/RECORD,,

emu_sv-2.2.1.dist-info/RECORD

@@ -1,15 +0,0 @@
-emu_sv/__init__.py,sha256=sREepAk-h3a3-e7PGexVNmYmj5hf4fVIrKk78vnDKiE,771
-emu_sv/custom_callback_implementations.py,sha256=_7XLIDzJ-p3DVqz-Jyv0eYbl8nih2x2p-pM4cBCLumA,6367
-emu_sv/dense_operator.py,sha256=NfgzVpnNitc5ZSM4RlfpAc5Ls2wFPNsTxdeFdhJSg1o,6909
-emu_sv/density_matrix_state.py,sha256=5W_UKIAYHb0k3ryRLQ2dbFUgrb5ju5jceDGAekM2gNE,7035
-emu_sv/hamiltonian.py,sha256=CqNGuWJlO2ZljK47wt130s-5uKiOldQUsC3tjwk1mKA,6106
-emu_sv/lindblad_operator.py,sha256=pgjRNLBcvEM2-qxM8uy9wL74OtrD4A8trQeERi_AXH8,8892
-emu_sv/state_vector.py,sha256=zKHCdgl_eRIOPE4qVKO53ig9UyYTQ7a_guNFXgynU7g,9753
-emu_sv/sv_backend.py,sha256=-soOkSEzEBK1dCKnYnbtvYjmNZtZra1_4jP3H1ROOtM,737
-emu_sv/sv_backend_impl.py,sha256=mdPWBLDwH0q7EEwQTmLNLLx5tycMmsCQbUifIHvciMk,8059
-emu_sv/sv_config.py,sha256=0geciKkrF3h8pU_UAQ8R-G6WxfYb_X5XIrxZavGxK5Q,6511
-emu_sv/time_evolution.py,sha256=_VH4f2RF6lGKzO08WxTYJ5Aw8_pTTMRKcyMnIuxH03I,13382
-emu_sv/utils.py,sha256=-axfQ2tqw0C7I9yw-28g7lytyk373DNBjDALh4kLBrM,302
-emu_sv-2.2.1.dist-info/METADATA,sha256=_NvCSEGYdw9ZXATsZKME-GX0ECeiJcDy8MthY9C5ZUU,3595
-emu_sv-2.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-emu_sv-2.2.1.dist-info/RECORD,,