emu-base 1.2.7__py3-none-any.whl → 2.0.1__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.7"
+__version__ = "2.0.1"

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/pulser_adapter.py

@@ -1,13 +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 pulser.register.base_register import BaseRegister
+from pulser.backend.config import EmulationConfig
 
-from emu_base.base_classes.config import BackendConfig
 from emu_base.lindblad_operators import get_lindblad_operators
 from emu_base.utils import dist2, dist3
 
@@ -229,15 +229,23 @@ 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.callbacks:
-            observable_times |= set(obs.evaluation_times)
-        self.target_times = list(observable_times)
+        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 = (
@@ -266,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.7.dist-info → emu_base-2.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emu-base
-Version: 1.2.7
+Version: 2.0.1
 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.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+emu_base/__init__.py,sha256=ZKjTNCGsq85QyEaQgRUOXC9QcPg3W5Kjix-98JCejzs,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.1.dist-info/METADATA,sha256=Aj7pVr9uE3PWpLShQNgHEknUSznis0ZNG799P7UyRp0,3522
+emu_base-2.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emu_base-2.0.1.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,64 +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

emu_base/base_classes/config.py

@@ -1,106 +0,0 @@
-from __future__ import annotations
-from pulser.noise_model import NoiseModel
-import logging
-import sys
-import pathlib
-from typing import TYPE_CHECKING
-import torch
-
-if TYPE_CHECKING:
-    from emu_base.base_classes.callback import Callback
-
-
-class BackendConfig:
-    """The base backend configuration.
-
-    Args:
-        observables: a list of callbacks to compute observables
-        with_modulation: if True, run the sequence with hardware modulation
-        noise_model: The pulser.NoiseModel to use in the simulation.
-        interaction_matrix: When specified, override the interaction terms in the Hamiltonian.
-            This corresponds to the $U_{ij}$ terms in the documentation. Must be symmetric.
-        interaction_cutoff: set interaction coefficients smaller than this to 0.
-            This can improve the memory profile of the application for some backends.
-        log_level: The output verbosity. Should be one of the constants from logging.
-        log_file: a path to a file where to store the log, instead of printing to stdout
-
-    Examples:
-        >>> observables = [BitStrings(400, 100)] #compute 100 bitstrings at 400ns
-        >>> noise_model = pulser.noise_model.NoiseModel()
-        >>> interaction_matrix = [[1 for _ in range(nqubits)] for _ in range(nqubits)]
-        >>> interaction_cutoff = 2.0 #this will turn off all the above interactions again
-        >>> log_level = logging.warn
-    """
-
-    def __init__(
-        self,
-        *,
-        observables: list[Callback] | None = None,
-        with_modulation: bool = False,
-        noise_model: NoiseModel | None = None,
-        interaction_matrix: list[list[float]] | None = None,
-        interaction_cutoff: float = 0.0,
-        log_level: int = logging.INFO,
-        log_file: pathlib.Path | None = None,
-    ):
-        if observables is None:
-            observables = []
-        self.callbacks = (
-            observables  # we can add other types of callbacks, and just stack them
-        )
-        self.with_modulation = with_modulation
-        self.noise_model = noise_model
-
-        if interaction_matrix is not None and not (
-            isinstance(interaction_matrix, list)
-            and isinstance(interaction_matrix[0], list)
-            and isinstance(interaction_matrix[0][0], float)
-        ):
-            raise ValueError(
-                "Interaction matrix must be provided as a Python list of lists of floats"
-            )
-
-        if interaction_matrix is not None:
-            int_mat = torch.tensor(interaction_matrix)
-            tol = 1e-10
-            if not (
-                int_mat.numel() != 0
-                and torch.all(torch.isreal(int_mat))
-                and int_mat.dim() == 2
-                and int_mat.shape[0] == int_mat.shape[1]
-                and torch.allclose(int_mat, int_mat.T, atol=tol)
-                and torch.norm(torch.diag(int_mat)) < tol
-            ):
-                raise ValueError("Interaction matrix is not symmetric and zero diag")
-
-        self.interaction_matrix = interaction_matrix
-        self.interaction_cutoff = interaction_cutoff
-        self.logger = logging.getLogger("global_logger")
-        self.log_file = log_file
-        self.log_level = log_level
-
-        self.init_logging()
-
-        if noise_model is not None and (
-            noise_model.runs != 1
-            or noise_model.samples_per_run != 1
-            or noise_model.runs is not None
-            or noise_model.samples_per_run is not None
-        ):
-            self.logger.warning(
-                "Warning: The runs and samples_per_run values of the NoiseModel are ignored!"
-            )
-
-    def init_logging(self) -> None:
-        if self.log_file is None:
-            logging.basicConfig(
-                level=self.log_level, format="%(message)s", stream=sys.stdout, force=True
-            )  # default to stream = sys.stderr
-        else:
-            logging.basicConfig(
-                level=self.log_level,
-                format="%(message)s",
-                filename=str(self.log_file),
-                filemode="w",
-                force=True,
-            )

emu_base/base_classes/default_callbacks.py

@@ -1,300 +0,0 @@
-from copy import deepcopy
-from typing import Any
-
-from emu_base.base_classes.callback import Callback, AggregationType
-from emu_base.base_classes.config import BackendConfig
-from emu_base.base_classes.operator import Operator
-from emu_base.base_classes.state import State
-
-
-class StateResult(Callback):
-    """
-    Store the quantum state in whatever format the backend provides
-
-    Args:
-        evaluation_times: the times at which to store the state
-    """
-
-    def __init__(self, evaluation_times: set[int]):
-        super().__init__(evaluation_times)
-
-    name = "state"
-
-    def apply(self, config: BackendConfig, t: int, state: State, H: Operator) -> Any:
-        return deepcopy(state)
-
-
-class BitStrings(Callback):
-    """
-    Store bitstrings sampled from the current state. Error rates are taken from the config
-    passed to the run method of the backend. The bitstrings are stored as a Counter[str].
-
-    Args:
-        evaluation_times: the times at which to sample bitstrings
-        num_shots: how many bitstrings to sample each time this observable is computed
-    """
-
-    def __init__(self, evaluation_times: set[int], num_shots: int = 1000):
-        super().__init__(evaluation_times)
-        self.num_shots = num_shots
-
-    name = "bitstrings"
-
-    def apply(self, config: BackendConfig, t: int, state: State, H: Operator) -> Any:
-        p_false_pos = (
-            0.0 if config.noise_model is None else config.noise_model.p_false_pos
-        )
-        p_false_neg = (
-            0.0 if config.noise_model is None else config.noise_model.p_false_neg
-        )
-
-        return state.sample(self.num_shots, p_false_pos, p_false_neg)
-
-    default_aggregation_type = AggregationType.BAG_UNION
-
-
-_fidelity_counter = -1
-
-
-class Fidelity(Callback):
-    """
-    Store $<ψ|φ(t)>$ for the given state $|ψ>$,
-    and the state $|φ(t)>$ obtained by time evolution.
-
-    Args:
-        evaluation_times: the times at which to compute the fidelity
-        state: the state |ψ>. Note that this must be of appropriate type for the backend
-
-    Examples:
-        >>> state = State.from_state_string(...) #see State API
-        >>> fidelity = Fidelity([400], state) #measure fidelity on state at t=400ns
-    """
-
-    def __init__(self, evaluation_times: set[int], state: State):
-        super().__init__(evaluation_times)
-        global _fidelity_counter
-        _fidelity_counter += 1
-        self.index = _fidelity_counter
-        self.state = state
-
-    @property
-    def name(self) -> str:
-        return f"fidelity_{self.index}"
-
-    def apply(self, config: BackendConfig, t: int, state: State, H: Operator) -> Any:
-        return self.state.inner(state)
-
-
-_expectation_counter = -1
-
-
-class Expectation(Callback):
-    """
-    Store the expectation of the given operator on the current state
-    (i.e. $\\langle φ(t)|\\mathrm{operator}|φ(t)\\rangle$).
-
-    Args:
-        evaluation_times: the times at which to compute the expectation
-        operator: the operator to measure. Must be of appropriate type for the backend.
-
-    Examples:
-        >>> op = Operator.from_operator_string(...) #see Operator API
-        >>> expectation = Expectation([400], op) #measure the expecation of op at t=400ns
-    """
-
-    def __init__(self, evaluation_times: set[int], operator: Operator):
-        super().__init__(evaluation_times)
-        global _expectation_counter
-        _expectation_counter += 1
-        self.index = _expectation_counter
-        self.operator = operator
-
-    @property
-    def name(self) -> str:
-        return f"expectation_{self.index}"
-
-    def apply(self, config: BackendConfig, t: int, state: State, H: Operator) -> Any:
-        return self.operator.expect(state)
-
-    default_aggregation_type = AggregationType.MEAN
-
-
-class CorrelationMatrix(Callback):
-    """
-    Store the correlation matrix for the current state.
-    Requires specification of the basis used in the emulation
-    https://pulser.readthedocs.io/en/stable/conventions.html
-    It currently supports
-    - the rydberg basis ('r','g')
-    - the xy basis ('0', '1')
-    and returns
-
-    `[[<φ(t)|n_i n_j|φ(t)> for j in qubits] for i in qubits]`
-
-    n_i being the operator that projects qubit i onto the state that measures as 1.
-    The diagonal of this matrix is the QubitDensity. The correlation matrix
-    is stored as a list of lists.
-
-    Args:
-        evaluation_times: the times at which to compute the correlation matrix
-        basis: the basis used by the sequence
-        nqubits: the number of qubits in the Register
-
-    Notes:
-        See the API for `Operator.from_operator_string` for an example of what to do with
-        basis and nqubits.
-    """
-
-    def __init__(self, evaluation_times: set[int], basis: tuple[str, ...], nqubits: int):
-        super().__init__(evaluation_times)
-        self.operators: list[list[Operator]] | None = None
-        self.basis = set(basis)
-        if self.basis == {"r", "g"}:
-            self.op_string = "rr"
-        elif self.basis == {"0", "1"}:
-            self.op_string = "11"
-        else:
-            raise ValueError("Unsupported basis provided")
-        self.nqubits = nqubits
-
-    name = "correlation_matrix"
-
-    def apply(self, config: BackendConfig, t: int, state: State, H: Operator) -> Any:
-        if hasattr(state, "get_correlation_matrix") and callable(
-            state.get_correlation_matrix
-        ):
-            return state.get_correlation_matrix()
-
-        if self.operators is None or not isinstance(self.operators[0], type(H)):
-            self.operators = [
-                [
-                    H.from_operator_string(
-                        self.basis,
-                        self.nqubits,
-                        [(1.0, [({self.op_string: 1.0}, list({i, j}))])],
-                    )
-                    for j in range(self.nqubits)
-                ]
-                for i in range(self.nqubits)
-            ]
-        return [[op.expect(state).real for op in ops] for ops in self.operators]
-
-    default_aggregation_type = AggregationType.MEAN
-
-
-class QubitDensity(Callback):
-    """
-    Requires specification of the basis used in the emulation
-    https://pulser.readthedocs.io/en/stable/conventions.html
-    It currently supports
-    - the rydberg basis ('r','g')
-    - the xy basis ('0', '1')
-    and returns
-
-    `[<φ(t)|n_i|φ(t)> for i in qubits]`
-
-    n_i being the operator that projects qubit i onto the state that measures as 1.
-    The qubit density is stored as a list.
-
-    Args:
-        evaluation_times: the times at which to compute the density
-        basis: the basis used by the sequence
-        nqubits: the number of qubits in the Register
-
-    Notes:
-        See the API for `State.from_state_string` for an example of what to do with
-        basis and nqubits.
-    """
-
-    def __init__(self, evaluation_times: set[int], basis: tuple[str, ...], nqubits: int):
-        super().__init__(evaluation_times)
-        self.operators: list[Operator] | None = None
-        self.basis = set(basis)
-        if self.basis == {"r", "g"}:
-            self.op_string = "rr"
-        elif self.basis == {"0", "1"}:
-            self.op_string = "11"
-        else:
-            raise ValueError("Unsupported basis provided")
-        self.nqubits = nqubits
-
-    name = "qubit_density"
-
-    def apply(self, config: BackendConfig, t: int, state: State, H: Operator) -> Any:
-        if self.operators is None or not isinstance(self.operators[0], type(H)):
-            self.operators = [
-                H.from_operator_string(
-                    self.basis, self.nqubits, [(1.0, [({self.op_string: 1.0}, [i])])]
-                )
-                for i in range(self.nqubits)
-            ]
-        return [op.expect(state).real for op in self.operators]
-
-    default_aggregation_type = AggregationType.MEAN
-
-
-class Energy(Callback):
-    """
-    Store the expectation value of the current Hamiltonian
-    (i.e. $\\langle φ(t)|H(t)|φ(t) \\rangle$)
-
-    Args:
-        evaluation_times: the times at which to compute the expectation
-    """
-
-    def __init__(self, evaluation_times: set[int]):
-        super().__init__(evaluation_times)
-
-    name = "energy"
-
-    def apply(self, config: BackendConfig, t: int, state: State, H: Operator) -> Any:
-        return H.expect(state).real
-
-    default_aggregation_type = AggregationType.MEAN
-
-
-class EnergyVariance(Callback):
-    """
-    Store the variance of the current Hamiltonian
-    (i.e. $\\langle φ(t)|H(t)^2|φ(t)\\rangle - \\langle φ(t)|H(t)|φ(t)\\rangle^2$)
-
-    Args:
-        evaluation_times: the times at which to compute the variance
-    """
-
-    def __init__(self, evaluation_times: set[int]):
-        super().__init__(evaluation_times)
-
-    name = "energy_variance"
-
-    def apply(self, config: BackendConfig, t: int, state: State, H: Operator) -> Any:
-        h_squared = H @ H
-        return h_squared.expect(state).real - H.expect(state).real ** 2
-
-    # Explicitely setting this to None out of safety: in the case of MonteCarlo,
-    # the aggregated variance cannot be computed from this callback.
-    # Instead, one first need to average Energy and SecondMomentOfEnergy,
-    # and then compute the variance with the formula:
-    # AggregatedEnergyVariance = AveragedSecondMomentOfEnergy - AveragedEnergy**2
-    default_aggregation_type = None
-
-
-class SecondMomentOfEnergy(Callback):
-    """
-    Store the expectation value $\\langle φ(t)|H(t)^2|φ(t)\\rangle$.
-    Useful for computing the variance when averaging over many executions of the program.
-
-    Args:
-        evaluation_times: the times at which to compute the variance
-    """
-
-    def __init__(self, evaluation_times: set[int]):
-        super().__init__(evaluation_times)
-
-    name = "second_moment_of_energy"
-
-    def apply(self, config: BackendConfig, t: int, state: State, H: Operator) -> Any:
-        h_squared = H @ H
-        return h_squared.expect(state).real
-
-    default_aggregation_type = AggregationType.MEAN

emu_base/base_classes/operator.py

@@ -1,126 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from typing import Any, Iterable
-
-from emu_base.base_classes.state import State
-
-
-QuditOp = dict[str, complex]  # single qubit operator
-TensorOp = list[tuple[QuditOp, list[int]]]  # QuditOp applied to list of qubits
-FullOp = list[tuple[complex, TensorOp]]  # weighted sum of TensorOp
-
-
-class Operator(ABC):
-    @abstractmethod
-    def __mul__(self, other: State) -> State:
-        """
-        Apply the operator to a state
-
-        Args:
-            other: the state to apply this operator to
-
-        Returns:
-            the resulting state
-        """
-        pass
-
-    @abstractmethod
-    def __add__(self, other: Operator) -> Operator:
-        """
-        Computes the sum of two operators.
-
-        Args:
-            other: the other operator
-
-        Returns:
-           the summed operator
-        """
-        pass
-
-    @abstractmethod
-    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
-        """
-
-    @staticmethod
-    @abstractmethod
-    def from_operator_string(
-        basis: Iterable[str],
-        nqubits: int,
-        operations: FullOp,
-        operators: dict[str, QuditOp] = {},
-        /,
-        **kwargs: Any,
-    ) -> Operator:
-        """
-        Create an operator in the backend-specific format from the
-        pulser abstract representation
-        <https://www.notion.so/pasqal/Abstract-State-and-Operator-Definition>
-        By default it supports strings 'ij', where i and j in basis,
-        to denote |i><j|, but additional symbols can be defined in operators
-        For a list of existing bases, see
-        <https://pulser.readthedocs.io/en/stable/conventions.html>
-
-        Args:
-            basis: the eigenstates in the basis to use
-            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 whatever format the backend provides.
-
-        Examples:
-            >>> basis = {"r", "g"} #rydberg basis
-            >>> nqubits = 3 #or whatever
-            >>> x = {"rg": 1.0, "gr": 1.0}
-            >>> z = {"gg": 1.0, "rr": -1.0}
-            >>> operators = {"X": x, "Z": z} #define X and Z as conveniences
-            >>>
-            >>> operations = [ # 4 X1X + 3 1Z1
-            >>>     (
-            >>>         1.0,
-            >>>         [
-            >>>             ({"X": 2.0}, [0, 2]),
-            >>>             ({"Z": 3.0}, [1]),
-            >>>         ],
-            >>>     )
-            >>> ]
-            >>> op = Operator.from_operator_string(basis, nqubits, operations, operators)
-        """
-        pass
-
-    @abstractmethod
-    def __rmul__(self, scalar: complex) -> Operator:
-        """
-        Scale the operator by a scale factor.
-
-        Args:
-            scalar: the scale factor
-
-        Returns:
-            the scaled operator
-        """
-        pass
-
-    @abstractmethod
-    def __matmul__(self, other: Operator) -> Operator:
-        """
-        Compose two operators. The ordering is that
-        self is applied after other.
-
-        Args:
-            other: the operator to compose with self
-
-        Returns:
-            the composed operator
-        """
-        pass

emu_base/base_classes/results.py

@@ -1,183 +0,0 @@
-from dataclasses import dataclass, field
-from typing import Any, Callable, Optional
-from pathlib import Path
-import json
-import logging
-import torch
-
-from emu_base.base_classes.callback import Callback, AggregationType
-from emu_base.base_classes.aggregators import aggregation_types_definitions
-
-
-class ResultsEncoder(json.JSONEncoder):
-    def default(self, obj: Any) -> Any:
-        if isinstance(obj, torch.Tensor):
-            return obj.tolist()
-        return super().default(obj)
-
-
-@dataclass
-class Results:
-    """
-    This class contains emulation results. Since the results written by
-    an emulator are defined through callbacks, the contents of this class
-    are not known a-priori.
-    """
-
-    statistics: Any = None  # Backend-specific data
-
-    _results: dict[str, dict[int, Any]] = field(default_factory=dict)
-    _default_aggregation_types: dict[str, Optional[AggregationType]] = field(
-        default_factory=dict
-    )
-
-    @classmethod
-    def aggregate(
-        cls,
-        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_names())
-
-        if not all(
-            set(results.get_result_names()) == 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 = cls()
-
-        for stored_callback in stored_callbacks:
-            aggregation_type = aggregator_functions.get(
-                stored_callback,
-                results_to_aggregate[0].get_aggregation_type(stored_callback),
-            )
-
-            if aggregation_type is None:
-                logging.getLogger("global_logger").warning(
-                    f"Skipping aggregation of `{stored_callback}`"
-                )
-                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(stored_callback)
-            if not all(
-                results.get_result_times(stored_callback) == 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"
-                )
-
-            aggregated._results[stored_callback] = {
-                t: aggregation_function(
-                    [result[stored_callback, t] for result in results_to_aggregate]
-                )
-                for t in evaluation_times
-            }
-
-        return aggregated
-
-    def store(self, *, callback: Callback, time: Any, value: Any) -> None:
-        self._results.setdefault(callback.name, {})
-
-        if time in self._results[callback.name]:
-            raise ValueError(
-                f"A value is already stored for observable '{callback.name}' at time {time}"
-            )
-
-        self._results[callback.name][time] = value
-        self._default_aggregation_types[callback.name] = callback.default_aggregation_type
-
-    def __getitem__(self, key: Any) -> Any:
-        if isinstance(key, tuple):
-            # results["energy", t]
-            callback_name, time = key
-
-            if callback_name not in self._results:
-                raise ValueError(
-                    f"No value for observable '{callback_name}' has been stored"
-                )
-
-            if time not in self._results[callback_name]:
-                raise ValueError(
-                    f"No value stored at time {time} for observable '{callback_name}'"
-                )
-
-            return self._results[callback_name][time]
-
-        # results["energy"][t]
-        assert isinstance(key, str)
-        callback_name = key
-        if callback_name not in self._results:
-            raise ValueError(f"No value for observable '{callback_name}' has been stored")
-
-        return self._results[key]
-
-    def get_result_names(self) -> list[str]:
-        """
-        get a list of results present in this object
-
-        Args:
-
-        Returns:
-            list of results by name
-
-        """
-        return list(self._results.keys())
-
-    def get_result_times(self, name: str) -> list[int]:
-        """
-        get a list of times for which the given result has been stored
-
-        Args:
-            name: name of the result to get times of
-
-        Returns:
-            list of times in ns
-
-        """
-        return list(self._results[name].keys())
-
-    def get_result(self, name: str, time: int) -> Any:
-        """
-        get the given result at the given time
-
-        Args:
-            name: name of the result to get
-            time: time in ns at which to get the result
-
-        Returns:
-            the result
-
-        """
-        return self._results[name][time]
-
-    def get_aggregation_type(self, name: str) -> Optional[AggregationType]:
-        return self._default_aggregation_types[name]
-
-    def dump(self, file_path: Path) -> None:
-        with file_path.open("w") as file_handle:
-            json.dump(
-                {
-                    "observables": self._results,
-                    "statistics": self.statistics,
-                },
-                file_handle,
-                cls=ResultsEncoder,
-            )

emu_base/base_classes/state.py

@@ -1,97 +0,0 @@
-from __future__ import annotations
-from typing import Any, Iterable
-from abc import ABC, abstractmethod
-from collections import Counter
-
-
-class State(ABC):
-    """
-    Base class enforcing an API for quantum states.
-    Each backend will implement its own type of state, and the
-    below methods.
-    """
-
-    @abstractmethod
-    def inner(self, other: State) -> float | complex:
-        """
-        Compute the inner product between this state and other.
-        Note that self is the left state in the inner product,
-        so this function is linear in other, and anti-linear in self
-
-        Args:
-            other: the other state
-
-        Returns:
-            inner product
-        """
-        pass
-
-    @abstractmethod
-    def sample(
-        self, num_shots: int, p_false_pos: float = 0.0, p_false_neg: float = 0.0
-    ) -> Counter[str]:
-        """
-        Sample bitstrings from the state, taking into account 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: the rate at which a 1 is read as a 0
-
-        Returns:
-            the measured bitstrings, by count
-        """
-        pass
-
-    @abstractmethod
-    def __add__(self, other: State) -> State:
-        """
-        Computes the sum of two states.
-
-        Args:
-            other: the other state
-
-        Returns:
-            the summed state
-        """
-        pass
-
-    @abstractmethod
-    def __rmul__(self, scalar: complex) -> State:
-        """
-        Scale the state by a scale factor.
-
-        Args:
-            scalar: the scale factor
-
-        Returns:
-            the scaled state
-        """
-        pass
-
-    @staticmethod
-    @abstractmethod
-    def from_state_string(
-        *, basis: Iterable[str], nqubits: int, strings: dict[str, complex], **kwargs: Any
-    ) -> State:
-        """
-        Construct a state from the pulser abstract representation
-        <https://www.notion.so/pasqal/Abstract-State-and-Operator-Definition>
-        For a list of existing bases, see
-        <https://pulser.readthedocs.io/en/stable/conventions.html>
-
-        Args:
-            basis: A tuple containing the basis states.
-            nqubits: the number of qubits.
-            strings: A dictionary mapping state strings to complex or floats amplitudes
-
-        Returns:
-            the state in whatever format the backend provides.
-
-        Examples:
-            >>> afm_string_state = {"rrr": 1.0 / math.sqrt(2), "ggg": 1.0 / math.sqrt(2)}
-            >>> afm_state = State.from_state_string(
-            >>>     basis=("r", "g"), nqubits=3, strings=afm_string_state
-            >>> )
-        """
-        pass

emu_base-1.2.7.dist-info/RECORD

@@ -1,20 +0,0 @@
-emu_base/__init__.py,sha256=i2Gv8rIusAD2hXepDFdFTfC5FQOOpNXtB0F1xoSd6QQ,1186
-emu_base/constants.py,sha256=41LYkKLUCz-oxPbd-j7nUDZuhIbUrnez6prT0uR0jcE,56
-emu_base/lindblad_operators.py,sha256=Nsl1YrWb8IDM9Z50ucy2Ed44p_IRETnlbr6qaqAgV50,1629
-emu_base/pulser_adapter.py,sha256=SIkw3Mrob4RPTt4QNYzC8CUJ0tj-sTj-t-fEKEyRTtU,10858
-emu_base/utils.py,sha256=RM8O0qfPAJfcdqqAojwEEKV7I3ZfVDklnTisTGhUg5k,233
-emu_base/base_classes/__init__.py,sha256=Su6fHtjCyg0fw-7y7e7nbMfDASppNRQs8iGaAOkO3c4,570
-emu_base/base_classes/aggregators.py,sha256=BDzFq12q36p12TXp2qv3g7a9cHnXbT1hhMZJLVojkDU,1862
-emu_base/base_classes/backend.py,sha256=7tnwb9MnRbwRN1_JTqliYftjqExuOE-Rrwz9AU2Pc4c,1645
-emu_base/base_classes/callback.py,sha256=JXah_ZDNM8iyPWy7IOwW481qRFyqVvlSM-0OkjBzV0A,3055
-emu_base/base_classes/config.py,sha256=oLS2jwmxqwMbLKIPdqohK-KPIcXdtpG3sRr_Y12poNQ,4105
-emu_base/base_classes/default_callbacks.py,sha256=F44kkuwWdVcvMGZ9vJ2q7ug-_P8IQyJv-SVxSVWHW_w,9940
-emu_base/base_classes/operator.py,sha256=MJjuDUTwJLbaSJzSNCKDWGvmGCGAEIEWISLoPSSzNsU,3501
-emu_base/base_classes/results.py,sha256=w4js7gThb49sNjEEDfEf0tYRwK004GrafWPeEOvyeCg,5810
-emu_base/base_classes/state.py,sha256=7iIyZmBqqJ6G4SyYZ3kyylWjAqiYIx0aW5B0T74EPZI,2707
-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-1.2.7.dist-info/METADATA,sha256=JpfSGDOQtIu2hwwoHXgBNgf8ZmIkUh0MUDiwJYPZL_Q,3522
-emu_base-1.2.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-emu_base-1.2.7.dist-info/RECORD,,