emu-base 1.2.5__py3-none-any.whl → 1.2.7__py3-none-any.whl

emu_base/__init__.py

@@ -15,6 +15,7 @@ from .base_classes.default_callbacks import (
     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
@@ -42,6 +43,7 @@ __all__ = [
     "krylov_exp",
     "HamiltonianType",
     "DEFAULT_MAX_KRYLOV_DIM",
+    "DEVICE_COUNT",
 ]
 
-__version__ = "1.2.5"
+__version__ = "1.2.7"

emu_base/base_classes/aggregators.py

@@ -9,9 +9,14 @@ _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?
+) -> (
+    complex
+    | float
+    | list[complex]
+    | list[float]
+    | list[list[complex]]
+    | list[list[float]]
+):  # FIXME: support tuples?
     if values == []:
         raise ValueError("Cannot average 0 samples")
 

emu_base/base_classes/config.py

@@ -37,7 +37,7 @@ class BackendConfig:
         *,
         observables: list[Callback] | None = None,
         with_modulation: bool = False,
-        noise_model: NoiseModel = None,
+        noise_model: NoiseModel | None = None,
         interaction_matrix: list[list[float]] | None = None,
         interaction_cutoff: float = 0.0,
         log_level: int = logging.INFO,

emu_base/base_classes/results.py

@@ -3,11 +3,19 @@ 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:
     """
@@ -171,4 +179,5 @@ class Results:
                     "statistics": self.statistics,
                 },
                 file_handle,
+                cls=ResultsEncoder,
             )

emu_base/constants.py

@@ -0,0 +1,4 @@
+import torch
+
+
+DEVICE_COUNT = torch.cuda.device_count()

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

@@ -5,6 +5,8 @@ import math
 from pulser.noise_model import NoiseModel
 from enum import Enum
 
+from pulser.register.base_register import BaseRegister
+
 from emu_base.base_classes.config import BackendConfig
 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,27 +159,45 @@ 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
-
-    while t < max_duration:
-        for q_pos, q_id in enumerate(sequence.register.qubit_ids):
-            omega[step, q_pos] = (
-                locals_a_d_p[q_id]["amp"][math.floor(t)]
-                + locals_a_d_p[q_id]["amp"][math.ceil(t)]
-            ) / 2.0
-            delta[step, q_pos] = (
-                locals_a_d_p[q_id]["det"][math.floor(t)]
-                + locals_a_d_p[q_id]["det"][math.ceil(t)]
-            ) / 2.0
-            phi[step, q_pos] = (
-                locals_a_d_p[q_id]["phase"][math.floor(t)]
-                + locals_a_d_p[q_id]["phase"][math.ceil(t)]
-            ) / 2.0
-        if t in global_times:
-            omega[step] *= waist_factors
-        step += 1
-        t = (step + 1 / 2) * dt
+    omega_1 = torch.zeros_like(omega[0])
+    omega_2 = torch.zeros_like(omega[0])
+
+    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:
+            # If we're not the final step, approximate this using linear interpolation
+            # Note that for dt even, t1=t2
+            for q_pos, q_id in enumerate(sequence.register.qubit_ids):
+                t1 = math.floor(t)
+                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[i, q_pos] = (
+                    locals_a_d_p[q_id]["det"][t1] + locals_a_d_p[q_id]["det"][t2]
+                ) / 2.0
+                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
+            if t1 in global_times:
+                omega_1 *= waist_factors
+            if t2 in global_times:
+                omega_2 *= waist_factors
+            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[i, q_pos] = (
+                    3.0 * locals_a_d_p[q_id]["det"][t2] - locals_a_d_p[q_id]["det"][t1]
+                ) / 2.0
+                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[i] = torch.clamp(0.5 * (3 * omega_2 - omega_1).real, min=0.0)
 
     return omega, delta, phi
 
@@ -200,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
@@ -212,12 +232,20 @@ class PulserData:
     def __init__(self, *, sequence: pulser.Sequence, config: BackendConfig, dt: int):
         self.qubit_count = len(sequence.register.qubit_ids)
 
+        # 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)
+        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,
         )
@@ -250,11 +278,12 @@ class PulserData:
         ] = 0.0
         self.masked_interaction_matrix = self.full_interaction_matrix.clone()
 
-        slm_targets = sequence._slm_mask_targets
         self.slm_end_time = (
             sequence._slm_mask_time[1] if len(sequence._slm_mask_time) > 1 else 0.0
         )
 
-        for target in slm_targets:
+        # disable interaction for SLM masked qubits
+        slm_targets = list(sequence._slm_mask_targets)
+        for target in sequence.register.find_indices(slm_targets):
             self.masked_interaction_matrix[target] = 0.0
             self.masked_interaction_matrix[:, target] = 0.0

{emu_base-1.2.5.dist-info → emu_base-1.2.7.dist-info}/METADATA

@@ -1,7 +1,10 @@
 Metadata-Version: 2.4
 Name: emu-base
-Version: 1.2.5
+Version: 1.2.7
 Summary: Pasqal base classes for emulators
+Project-URL: Documentation, https://pasqal-io.github.io/emulators/
+Project-URL: Repository, https://github.com/pasqal-io/emulators
+Project-URL: Issues, https://github.com/pasqal-io/emulators/issues
 Author-email: Anton Quelle <anton.quelle@pasqal.com>, Mauro Mendizabal <mauro.mendizabal-pico@pasqal.com>, Stefano Grava <stefano.grava@pasqal.com>, Pablo Le Henaff <pablo.le-henaff@pasqal.com>
 License: PASQAL OPEN-SOURCE SOFTWARE LICENSE AGREEMENT (MIT-derived)
         
@@ -28,75 +31,8 @@ Description-Content-Type: text/markdown
 
 <div align="center">
   <img src="docs/logos/LogoTaglineSoftGreen.svg">
-
-  # Emu-MPS
 </div>
 
-**Emu-mps** is a backend for the [Pulser low-level Quantum Programming toolkit](https://pulser.readthedocs.io) that lets you run Quantum Algorithms on a simulated device, using GPU acceleration if available. More in depth, emu-mps is designed to **emu**late the dynamics of programmable arrays of neutral atoms, with matrix product states (**mps**). While benchmarking is incomplete as of this writing, early results suggest that this design makes emu-mps faster and more memory-efficient than previous generations of quantum emulators at running simulations with large numbers of qubits.
-
-As of this writing, Emu-MPS is provided for Linux and macOS but will not work under Windows.
-
-## Installation
-
-**Warning:** installing emu-mps will update pulser-core
-
-### Using `hatch`, `uv` or any pyproject-compatible Python manager
-
-To add `emu-mps` to your project, edit your `pyproject.toml` to add the line
-
-```toml
-  "emu-mps"
-```
-
-to the list of `dependencies`.
-
-
-### Using `pip` or `pipx`
-To install the `pipy` package using `pip` or `pipx`
-
-1. Create a `venv` if that's not done yet
-
-```sh
-$ python -m venv venv
-
-```
-
-2. Enter the venv
-
-If you're running Unix:
-
-```sh
-$ . venv/bin/activate
-```
-
-If you're running Windows:
-
-```sh
-C:\> /path/to/new/virtual/environment/Scripts/activate
-```
-
-3. Install the package
-
-```sh
-$ pip install emu-mps
-# or
-$ pipx install emu-mps
-```
-
-
-Join us on [Slack](https://pasqalworkspace.slack.com/archives/C07MUV5K7EU) or by [e-mail](mailto:emulation@pasqal.com) to give us feedback about how you plan to use Emu-MPS or if you require specific feature-upgrades.
-
-## Usage
-
-For the time being, the easiest way to learn how to use this package is to look
-at the [examples](examples/emu_mps_examples) and [notebooks](https://pasqal-io.github.io/emulators/latest/).
-
-See also the [full documentation](https://github.com/pasqal-io/emulators/blob/main/docs/index.md) for
-the API, information about contributing, benchmarks, etc.
-
-
-## Getting in touch
+# Welcome to the Pasqal analog emulators
 
-- [Pasqal Community Portal](https://community.pasqal.com/) (forums, chat, tutorials, examples, code library).
-- [GitHub Repository](https://github.com/pasqal-io/quantum-evolution-kernel) (source code, issue tracker).
-- [Professional Support](https://www.pasqal.com/contact-us/) (if you need tech support, custom licenses, a variant of this library optimized for your workload, your own QPU, remote access to a QPU, ...)
+Welcome, and please see the [GitHub pages](https://pasqal-io.github.io/emulators/) for a landing page to this repo.

{emu_base-1.2.5.dist-info → emu_base-1.2.7.dist-info}/RECORD

@@ -1,19 +1,20 @@
-emu_base/__init__.py,sha256=5X57qf5fo0zv8vmeaDbrW9ThsAEIjy5HPsCpQEIL8iI,1130
-emu_base/lindblad_operators.py,sha256=eXkXsLt_fV7jhF31EkxzYFU04rOJV3uWXsl6t1aTAqs,1562
-emu_base/pulser_adapter.py,sha256=vnIiOpjJBXEwMmuWqOdRIlHmkkYnvvPmsSfRNPzBi2k,9118
+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=bcvoGfZCkPKv-CI29gTma6HBphGh7bjBq2Ome77eRJM,1840
+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=Dg2CwC9sc5HYwszQAJSVjkSd3wuQrv6aEZGYBRnFl48,4098
+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=7-Mz3jmFy19hd3PIA5idK610mC3b5jOf3EKBmV14Jv4,5569
+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.5.dist-info/METADATA,sha256=wD4pmz4VvisVEZmM3Z44CC_fiwB6SMw-O9fFKPHvb7w,5576
-emu_base-1.2.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-emu_base-1.2.5.dist-info/RECORD,,
+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,,