emu-base 1.2.6__py3-none-any.whl → 2.0.0__py3-none-any.whl

emu_base/__init__.py

@@ -1,43 +1,13 @@
-from .base_classes.results import Results
-from .base_classes.callback import Callback, AggregationType
-from .base_classes.config import BackendConfig
-from .base_classes.operator import Operator
-from .base_classes.state import State
-from .base_classes.backend import Backend
-from .base_classes.default_callbacks import (
-    BitStrings,
-    CorrelationMatrix,
-    Energy,
-    EnergyVariance,
-    Expectation,
-    Fidelity,
-    QubitDensity,
-    StateResult,
-    SecondMomentOfEnergy,
-)
 from .constants import DEVICE_COUNT
 from .pulser_adapter import PulserData, HamiltonianType
 from .math.brents_root_finding import find_root_brents
 from .math.krylov_exp import krylov_exp, DEFAULT_MAX_KRYLOV_DIM
+from .aggregators import AggregationType, aggregate
 
 __all__ = [
     "__version__",
-    "Results",
-    "BackendConfig",
-    "Operator",
-    "State",
-    "Backend",
     "AggregationType",
-    "Callback",
-    "StateResult",
-    "BitStrings",
-    "QubitDensity",
-    "CorrelationMatrix",
-    "Expectation",
-    "Fidelity",
-    "Energy",
-    "EnergyVariance",
-    "SecondMomentOfEnergy",
+    "aggregate",
     "PulserData",
     "find_root_brents",
     "krylov_exp",
@@ -46,4 +16,4 @@ __all__ = [
     "DEVICE_COUNT",
 ]
 
-__version__ = "1.2.6"
+__version__ = "2.0.0"

emu_base/aggregators.py

@@ -0,0 +1,158 @@
+import statistics
+import torch
+from typing import Any, Callable
+import collections
+from enum import Enum, auto
+from pulser.backend import (
+    Results,
+)
+import logging
+
+
+_NUMERIC_TYPES = {int, float, complex}
+
+
+class AggregationType(Enum):
+    """
+    Defines how to combine multiple values from different simulation results.
+    """
+
+    MEAN = auto()  # statistics.fmean or list/matrix-wise equivalent
+    BAG_UNION = auto()  # Counter.__add__
+
+
+def mean_aggregator(
+    values: list[Any],
+) -> (
+    complex
+    | float
+    | list[complex]
+    | list[float]
+    | list[list[complex]]
+    | list[list[float]]
+    | torch.Tensor
+):  # FIXME: support tuples?
+    if values == []:
+        raise ValueError("Cannot average 0 samples")
+
+    element_type = type(values[0])
+
+    if element_type in _NUMERIC_TYPES:
+        return statistics.fmean(values)
+
+    if element_type == torch.Tensor:
+        acc = torch.zeros_like(values[0])
+        for ten in values:
+            acc += ten
+        return acc / len(values)
+
+    if element_type != list:
+        raise NotImplementedError("Cannot average this type of data")
+
+    if values[0] == []:
+        raise ValueError("Cannot average list of empty lists")
+
+    sub_element_type = type(values[0][0])
+
+    if sub_element_type in _NUMERIC_TYPES:
+        dim = len(values[0])
+        return [statistics.fmean(value[i] for value in values) for i in range(dim)]
+
+    if sub_element_type != list:  # FIXME: ABC.Iterable? Collection? subclass?
+        raise ValueError(f"Cannot average list of lists of {sub_element_type}")
+
+    if values[0][0] == []:
+        raise ValueError("Cannot average list of matrices with no columns")
+
+    if (sub_sub_element_type := type(values[0][0][0])) not in _NUMERIC_TYPES:
+        raise ValueError(f"Cannot average list of matrices of {sub_sub_element_type}")
+
+    dim1 = len(values[0])
+    dim2 = len(values[0][0])
+    return [
+        [statistics.fmean(value[i][j] for value in values) for j in range(dim2)]
+        for i in range(dim1)
+    ]
+
+
+def bag_union_aggregator(values: list[collections.Counter]) -> collections.Counter:
+    return sum(values, start=collections.Counter())
+
+
+aggregation_types_definitions: dict[AggregationType, Callable] = {
+    AggregationType.MEAN: mean_aggregator,
+    AggregationType.BAG_UNION: bag_union_aggregator,
+}
+
+
+def _get_aggregation_type(tag: str) -> AggregationType | None:
+    if tag.startswith("bitstrings"):
+        return AggregationType.BAG_UNION
+    if tag.startswith("expectation"):
+        return AggregationType.MEAN
+    if tag.startswith("fidelity"):
+        return AggregationType.MEAN
+    if tag.startswith("correlation_matrix"):
+        return AggregationType.MEAN
+    if tag.startswith("occupation"):
+        return AggregationType.MEAN
+    if tag.startswith("energy"):
+        return AggregationType.MEAN
+    if tag.startswith("energy_second_moment"):
+        return AggregationType.MEAN
+    else:
+        return None
+
+
+def aggregate(
+    results_to_aggregate: list[Results],
+    **aggregator_functions: Callable[[Any], Any],
+) -> Results:
+    if len(results_to_aggregate) == 0:
+        raise ValueError("no results to aggregate")
+    if len(results_to_aggregate) == 1:
+        return results_to_aggregate[0]
+    stored_callbacks = set(results_to_aggregate[0].get_result_tags())
+    if not all(
+        set(results.get_result_tags()) == stored_callbacks
+        for results in results_to_aggregate
+    ):
+        raise ValueError(
+            "Monte-Carlo results seem to provide from incompatible simulations: "
+            "they do not all contain the same observables"
+        )
+    aggregated = Results(
+        atom_order=results_to_aggregate[0].atom_order,
+        total_duration=results_to_aggregate[0].total_duration,
+    )
+    for tag in stored_callbacks:
+        aggregation_type = aggregator_functions.get(
+            tag,
+            _get_aggregation_type(tag),
+        )
+        if aggregation_type is None:
+            logging.getLogger("global_logger").warning(f"Skipping aggregation of `{tag}`")
+            continue
+        aggregation_function: Any = (
+            aggregation_type
+            if callable(aggregation_type)
+            else aggregation_types_definitions[aggregation_type]
+        )
+        evaluation_times = results_to_aggregate[0].get_result_times(tag)
+        if not all(
+            results.get_result_times(tag) == evaluation_times
+            for results in results_to_aggregate
+        ):
+            raise ValueError(
+                "Monte-Carlo results seem to provide from incompatible simulations: "
+                "the callbacks are not stored at the same times"
+            )
+
+        uuid = results_to_aggregate[0]._find_uuid(tag)
+        for t in results_to_aggregate[0].get_result_times(tag):
+            v = aggregation_function(
+                [result.get_result(tag, t) for result in results_to_aggregate]
+            )
+            aggregated._store_raw(uuid=uuid, tag=tag, time=t, value=v)
+
+    return aggregated

emu_base/lindblad_operators.py

@@ -32,7 +32,10 @@ def get_lindblad_operators(
         ]
 
     if noise_type == "eff_noise":
-        if not all(op.shape == (2, 2) for op in noise_model.eff_noise_opers):
+        if not all(
+            isinstance(op, torch.Tensor) and op.shape == (2, 2)
+            for op in noise_model.eff_noise_opers
+        ):
             raise ValueError("Only 2 * 2 effective noise operator matrices are supported")
 
         return [

emu_base/pulser_adapter.py

@@ -1,11 +1,13 @@
 import pulser
-from typing import Tuple
+from typing import Tuple, Sequence
 import torch
 import math
 from pulser.noise_model import NoiseModel
+from pulser.register.base_register import BaseRegister
 from enum import Enum
 
-from emu_base.base_classes.config import BackendConfig
+from pulser.backend.config import EmulationConfig
+
 from emu_base.lindblad_operators import get_lindblad_operators
 from emu_base.utils import dist2, dist3
 
@@ -16,7 +18,7 @@ class HamiltonianType(Enum):
 
 
 def _get_qubit_positions(
-    register: pulser.Register,
+    register: BaseRegister,
 ) -> list[torch.Tensor]:
     """Conversion from pulser Register to emu-mps register (torch type).
     Each element will be given as [Rx,Ry,Rz]"""
@@ -31,7 +33,7 @@ def _get_qubit_positions(
 def _rydberg_interaction(sequence: pulser.Sequence) -> torch.Tensor:
     """
     Computes the Ising interaction matrix from the qubit positions.
-    Hᵢⱼ=C₆/Rᵢⱼ⁶ (nᵢ⊗ nⱼ)
+    Hᵢⱼ=C₆/R⁶ᵢⱼ (nᵢ⊗ nⱼ)
     """
 
     num_qubits = len(sequence.register.qubit_ids)
@@ -88,7 +90,7 @@ def _xy_interaction(sequence: pulser.Sequence) -> torch.Tensor:
 def _extract_omega_delta_phi(
     *,
     sequence: pulser.Sequence,
-    dt: int,
+    target_times: list[int],
     with_modulation: bool,
     laser_waist: float | None,
 ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
@@ -125,7 +127,7 @@ def _extract_omega_delta_phi(
 
     max_duration = sequence.get_duration(include_fall_time=with_modulation)
 
-    nsamples = math.ceil(max_duration / dt - 1 / 2)
+    nsamples = len(target_times) - 1
     omega = torch.zeros(
         nsamples,
         len(sequence.register.qubit_ids),
@@ -157,12 +159,11 @@ def _extract_omega_delta_phi(
             for slot in ch_samples.slots:
                 global_times |= set(i for i in range(slot.ti, slot.tf))
 
-    step = 0
-    t = (step + 1 / 2) * dt
     omega_1 = torch.zeros_like(omega[0])
     omega_2 = torch.zeros_like(omega[0])
 
-    while t < max_duration:
+    for i in range(nsamples):
+        t = (target_times[i] + target_times[i + 1]) / 2
         # The sampled values correspond to the start of each interval
         # To maximize the order of the solver, we need the values in the middle
         if math.ceil(t) < max_duration:
@@ -173,10 +174,10 @@ def _extract_omega_delta_phi(
                 t2 = math.ceil(t)
                 omega_1[q_pos] = locals_a_d_p[q_id]["amp"][t1]
                 omega_2[q_pos] = locals_a_d_p[q_id]["amp"][t2]
-                delta[step, q_pos] = (
+                delta[i, q_pos] = (
                     locals_a_d_p[q_id]["det"][t1] + locals_a_d_p[q_id]["det"][t2]
                 ) / 2.0
-                phi[step, q_pos] = (
+                phi[i, q_pos] = (
                     locals_a_d_p[q_id]["phase"][t1] + locals_a_d_p[q_id]["phase"][t2]
                 ) / 2.0
             # omegas at different times need to have the laser waist applied independently
@@ -184,21 +185,19 @@ def _extract_omega_delta_phi(
                 omega_1 *= waist_factors
             if t2 in global_times:
                 omega_2 *= waist_factors
-            omega[step] = 0.5 * (omega_1 + omega_2)
+            omega[i] = 0.5 * (omega_1 + omega_2)
         else:
             # We're in the final step and dt=1, approximate this using linear extrapolation
             # we can reuse omega_1 and omega_2 from before
             for q_pos, q_id in enumerate(sequence.register.qubit_ids):
-                delta[step, q_pos] = (
+                delta[i, q_pos] = (
                     3.0 * locals_a_d_p[q_id]["det"][t2] - locals_a_d_p[q_id]["det"][t1]
                 ) / 2.0
-                phi[step, q_pos] = (
+                phi[i, q_pos] = (
                     3.0 * locals_a_d_p[q_id]["phase"][t2]
                     - locals_a_d_p[q_id]["phase"][t1]
                 ) / 2.0
-            omega[step] = torch.clamp(0.5 * (3 * omega_2 - omega_1).real, min=0.0)
-        step += 1
-        t = (step + 1 / 2) * dt
+            omega[i] = torch.clamp(0.5 * (3 * omega_2 - omega_1).real, min=0.0)
 
     return omega, delta, phi
 
@@ -221,7 +220,7 @@ def _get_all_lindblad_noise_operators(
 
 
 class PulserData:
-    slm_end_time: int
+    slm_end_time: float
     full_interaction_matrix: torch.Tensor
     masked_interaction_matrix: torch.Tensor
     omega: torch.Tensor
@@ -230,15 +229,31 @@ class PulserData:
     hamiltonian_type: HamiltonianType
     lindblad_ops: list[torch.Tensor]
 
-    def __init__(self, *, sequence: pulser.Sequence, config: BackendConfig, dt: int):
+    def __init__(self, *, sequence: pulser.Sequence, config: EmulationConfig, dt: int):
         self.qubit_count = len(sequence.register.qubit_ids)
+        sequence_duration = sequence.get_duration()
+        # the end value is exclusive, so add +1
+        observable_times = set(torch.arange(0, sequence.get_duration() + 1, dt).tolist())
+        observable_times.add(sequence.get_duration())
+        for obs in config.observables:
+            times: Sequence[float]
+            if obs.evaluation_times is not None:
+                times = obs.evaluation_times
+            elif config.default_evaluation_times != "Full":
+                times = (
+                    config.default_evaluation_times.tolist()  # type: ignore[union-attr,assignment]
+                )
+            observable_times |= set([round(time * sequence_duration) for time in times])
+
+        self.target_times: list[int] = list(observable_times)
+        self.target_times.sort()
 
         laser_waist = (
             config.noise_model.laser_waist if config.noise_model is not None else None
         )
         self.omega, self.delta, self.phi = _extract_omega_delta_phi(
             sequence=sequence,
-            dt=dt,
+            target_times=self.target_times,
             with_modulation=config.with_modulation,
             laser_waist=laser_waist,
         )
@@ -259,9 +274,7 @@ class PulserData:
                 "the interaction matrix"
             )
 
-            self.full_interaction_matrix = torch.tensor(
-                config.interaction_matrix, dtype=torch.float64
-            )
+            self.full_interaction_matrix = config.interaction_matrix.as_tensor()
         elif self.hamiltonian_type == HamiltonianType.Rydberg:
             self.full_interaction_matrix = _rydberg_interaction(sequence)
         elif self.hamiltonian_type == HamiltonianType.XY:

{emu_base-1.2.6.dist-info → emu_base-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emu-base
-Version: 1.2.6
+Version: 2.0.0
 Summary: Pasqal base classes for emulators
 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: pulser-core==1.3.*
+Requires-Dist: pulser-core==1.4.*
 Requires-Dist: torch==2.5.0
 Description-Content-Type: text/markdown
 

emu_base-2.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+emu_base/__init__.py,sha256=b60wKpJR1-oUIEv68t0-WNza2IXSL7joPQVt5Hw-rj8,493
+emu_base/aggregators.py,sha256=bB-rldoDAErxQMpL715K5lpiabGOpkCY0GyxW7mfHuc,5000
+emu_base/constants.py,sha256=41LYkKLUCz-oxPbd-j7nUDZuhIbUrnez6prT0uR0jcE,56
+emu_base/lindblad_operators.py,sha256=Nsl1YrWb8IDM9Z50ucy2Ed44p_IRETnlbr6qaqAgV50,1629
+emu_base/pulser_adapter.py,sha256=dRD80z_dVXkCjDBLRIkmqNGg5M78VEKkQuk3H5JdZSM,11241
+emu_base/utils.py,sha256=RM8O0qfPAJfcdqqAojwEEKV7I3ZfVDklnTisTGhUg5k,233
+emu_base/math/__init__.py,sha256=6BbIytYV5uC-e5jLMtIErkcUl_PvfSNnhmVFY9Il8uQ,97
+emu_base/math/brents_root_finding.py,sha256=AVx6L1Il6rpPJWrLJ7cn6oNmJyZOPRgEaaZaubC9lsU,3711
+emu_base/math/krylov_exp.py,sha256=UCFNeq-j2ukgBsOPC9_Jiv1aqpy88SrslDLiCxIGBwk,3840
+emu_base-2.0.0.dist-info/METADATA,sha256=uoylMuopYijyAJ9G8iY_cxXanQlJGu1ibvkd17Soi2g,3522
+emu_base-2.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emu_base-2.0.0.dist-info/RECORD,,

emu_base/base_classes/__init__.py

@@ -1,31 +0,0 @@
-from .operator import Operator
-from .state import State
-from .results import Results
-from .callback import Callback
-from .default_callbacks import (
-    StateResult,
-    BitStrings,
-    QubitDensity,
-    CorrelationMatrix,
-    Expectation,
-    Fidelity,
-    Energy,
-    EnergyVariance,
-    SecondMomentOfEnergy,
-)
-
-__all__ = [
-    "Operator",
-    "State",
-    "Results",
-    "Callback",
-    "StateResult",
-    "BitStrings",
-    "QubitDensity",
-    "CorrelationMatrix",
-    "Expectation",
-    "Fidelity",
-    "Energy",
-    "EnergyVariance",
-    "SecondMomentOfEnergy",
-]

emu_base/base_classes/aggregators.py

@@ -1,59 +0,0 @@
-import statistics
-from typing import Any, Callable
-import collections
-from emu_base.base_classes.callback import AggregationType
-
-
-_NUMERIC_TYPES = {int, float, complex}
-
-
-def mean_aggregator(
-    values: list[Any],
-) -> complex | float | list[complex] | list[float] | list[list[complex]] | list[
-    list[float]
-]:  # FIXME: support tuples?
-    if values == []:
-        raise ValueError("Cannot average 0 samples")
-
-    element_type = type(values[0])
-
-    if element_type in _NUMERIC_TYPES:
-        return statistics.fmean(values)
-
-    if element_type != list:
-        raise NotImplementedError("Cannot average this type of data")
-
-    if values[0] == []:
-        raise ValueError("Cannot average list of empty lists")
-
-    sub_element_type = type(values[0][0])
-
-    if sub_element_type in _NUMERIC_TYPES:
-        dim = len(values[0])
-        return [statistics.fmean(value[i] for value in values) for i in range(dim)]
-
-    if sub_element_type != list:  # FIXME: ABC.Iterable? Collection? subclass?
-        raise ValueError(f"Cannot average list of lists of {sub_element_type}")
-
-    if values[0][0] == []:
-        raise ValueError("Cannot average list of matrices with no columns")
-
-    if (sub_sub_element_type := type(values[0][0][0])) not in _NUMERIC_TYPES:
-        raise ValueError(f"Cannot average list of matrices of {sub_sub_element_type}")
-
-    dim1 = len(values[0])
-    dim2 = len(values[0][0])
-    return [
-        [statistics.fmean(value[i][j] for value in values) for j in range(dim2)]
-        for i in range(dim1)
-    ]
-
-
-def bag_union_aggregator(values: list[collections.Counter]) -> collections.Counter:
-    return sum(values, start=collections.Counter())
-
-
-aggregation_types_definitions: dict[AggregationType, Callable] = {
-    AggregationType.MEAN: mean_aggregator,
-    AggregationType.BAG_UNION: bag_union_aggregator,
-}

emu_base/base_classes/backend.py

@@ -1,48 +0,0 @@
-import warnings
-from abc import ABC, abstractmethod
-
-from pulser import Sequence
-
-from emu_base.base_classes.config import BackendConfig
-from emu_base.base_classes.results import Results
-
-
-class Backend(ABC):
-    """
-    Base class for different emulation backends.
-    Forces backends to implement a run method.
-    """
-
-    @staticmethod
-    def validate_sequence(sequence: Sequence) -> None:
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", category=DeprecationWarning)
-
-        if not isinstance(sequence, Sequence):
-            raise TypeError(
-                "The provided sequence has to be a valid " "pulser.Sequence instance."
-            )
-        if sequence.is_parametrized() or sequence.is_register_mappable():
-            raise ValueError(
-                "Not supported"
-                "The provided sequence needs to be built to be simulated. Call"
-                " `Sequence.build()` with the necessary parameters."
-            )
-        if not sequence._schedule:
-            raise ValueError("The provided sequence has no declared channels.")
-        if all(sequence._schedule[x][-1].tf == 0 for x in sequence.declared_channels):
-            raise ValueError("No instructions given for the channels in the sequence.")
-
-    @abstractmethod
-    def run(self, sequence: Sequence, config: BackendConfig) -> Results:
-        """
-        Emulates the given sequence.
-
-        Args:
-            sequence: a Pulser sequence to simulate
-            config: the config. Should be of the appropriate type for the backend
-
-        Returns:
-            the simulation results
-        """
-        pass

emu_base/base_classes/callback.py

@@ -1,90 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any, Optional, TYPE_CHECKING
-from enum import Enum, auto
-
-from emu_base.base_classes.config import BackendConfig
-from emu_base.base_classes.operator import Operator
-from emu_base.base_classes.state import State
-
-if TYPE_CHECKING:
-    from emu_base.base_classes.results import Results
-
-
-class AggregationType(Enum):
-    """
-    Defines how to combine multiple values from different simulation results.
-    """
-
-    MEAN = auto()  # statistics.fmean or list/matrix-wise equivalent
-    BAG_UNION = auto()  # Counter.__add__
-
-
-class Callback(ABC):
-    def __init__(self, evaluation_times: set[int]):
-        """
-        The callback base class that can be subclassed to add new kinds of results
-        to the Results object returned by the Backend
-
-        Args:
-            evaluation_times: the times at which to add a result to Results
-        """
-        self.evaluation_times = evaluation_times
-
-    def __call__(
-        self, config: BackendConfig, t: int, state: State, H: Operator, result: "Results"
-    ) -> None:
-        """
-        This function is called after each time step performed by the emulator.
-        By default it calls apply to compute a result and put it in `result`
-        if `t` in `self.evaluation_times`.
-        It can be overloaded to define any custom behaviour for a `Callback`.
-
-        Args:
-            config: the config object passed to the run method
-            t: the current time in ns
-            state: the current state
-            H: the Hamiltonian at this time
-            result: the results object
-        """
-        if t in self.evaluation_times:
-            value_to_store = self.apply(config, t, state, H)
-            result.store(callback=self, time=t, value=value_to_store)
-
-    @property
-    @abstractmethod
-    def name(self) -> str:
-        """
-        The name of the observable, can be used to index into the Results object.
-        Some Callbacks might have multiple instances, such as a callback to compute
-        a fidelity on some given state. In that case, this method could make sure
-        each instance has a unique name.
-
-        Returns:
-            the name of the callback
-        """
-        pass
-
-    @abstractmethod
-    def apply(self, config: BackendConfig, t: int, state: State, H: Operator) -> Any:
-        """
-        This method must be implemented by subclasses. The result of this method
-        gets put in the Results object.
-
-        Args:
-            config: the config object passed to the run method
-            t: the current time in ns
-            state: the current state
-            H: the Hamiltonian at this time
-
-        Returns:
-            the result to put in Results
-        """
-        pass
-
-    @property
-    def default_aggregation_type(self) -> Optional[AggregationType]:
-        """
-        Defines how to combine by default multiple values from different simulation results.
-        None means no default, therefore aggregator function is always user-provided.
-        """
-        return None