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

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,
-        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,174 +0,0 @@
-from dataclasses import dataclass, field
-from typing import Any, Callable, Optional
-from pathlib import Path
-import json
-import logging
-
-from emu_base.base_classes.callback import Callback, AggregationType
-from emu_base.base_classes.aggregators import aggregation_types_definitions
-
-
-@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,
-            )