emu-base 1.2.1__py3-none-any.whl

emu_base/pulser_adapter.py

@@ -0,0 +1,248 @@
+import pulser
+from typing import Tuple
+import torch
+import math
+from pulser.noise_model import NoiseModel
+from enum import Enum
+
+from emu_base.base_classes.config import BackendConfig
+from emu_base.lindblad_operators import get_lindblad_operators
+from emu_base.utils import dist2, dist3
+
+
+class HamiltonianType(Enum):
+    Rydberg = 1
+    XY = 2
+
+
+def _get_qubit_positions(
+    register: pulser.Register,
+) -> list[torch.Tensor]:
+    """Conversion from pulser Register to emu-mps register (torch type).
+    Each element will be given as [Rx,Ry,Rz]"""
+
+    positions = [position.as_tensor() for position in register.qubits.values()]
+
+    if len(positions[0]) == 2:
+        return [torch.cat((position, torch.zeros(1))) for position in positions]
+    return positions
+
+
+def _rydberg_interaction(sequence: pulser.Sequence) -> torch.Tensor:
+    """
+    Computes the Ising interaction matrix from the qubit positions.
+    Hᵢⱼ=C₆/Rᵢⱼ⁶ (nᵢ⊗ nⱼ)
+    """
+
+    num_qubits = len(sequence.register.qubit_ids)
+
+    c6 = sequence.device.interaction_coeff
+
+    qubit_positions = _get_qubit_positions(sequence.register)
+    interaction_matrix = torch.zeros(num_qubits, num_qubits)
+
+    for numi in range(len(qubit_positions)):
+        for numj in range(numi + 1, len(qubit_positions)):
+            interaction_matrix[numi][numj] = (
+                c6 / dist2(qubit_positions[numi], qubit_positions[numj]) ** 3
+            )
+            interaction_matrix[numj, numi] = interaction_matrix[numi, numj]
+    return interaction_matrix
+
+
+def _xy_interaction(sequence: pulser.Sequence) -> torch.Tensor:
+    """
+    Computes the XY interaction matrix from the qubit positions.
+    C₃ (1−3 cos(𝜃ᵢⱼ)²)/ Rᵢⱼ³ (𝜎ᵢ⁺ 𝜎ⱼ⁻ +  𝜎ᵢ⁻ 𝜎ⱼ⁺)
+    """
+    num_qubits = len(sequence.register.qubit_ids)
+
+    c3 = sequence.device.interaction_coeff_xy
+
+    qubit_positions = _get_qubit_positions(sequence.register)
+    interaction_matrix = torch.zeros(num_qubits, num_qubits)
+    mag_field = torch.tensor(sequence.magnetic_field)  # by default [0.0,0.0,30.0]
+    mag_norm = torch.norm(mag_field)
+
+    for numi in range(len(qubit_positions)):
+        for numj in range(numi + 1, len(qubit_positions)):
+            cosine = 0
+            if mag_norm >= 1e-8:  # selected by hand
+                cosine = torch.dot(
+                    (qubit_positions[numi] - qubit_positions[numj]), mag_field
+                ) / (torch.norm(qubit_positions[numi] - qubit_positions[numj]) * mag_norm)
+
+            interaction_matrix[numi][numj] = (
+                c3  # check this value with pulser people
+                * (1 - 3 * cosine**2)
+                / dist3(qubit_positions[numi], qubit_positions[numj])
+            )
+            interaction_matrix[numj, numi] = interaction_matrix[numi, numj]
+
+    return interaction_matrix
+
+
+def _extract_omega_delta_phi(
+    *,
+    sequence: pulser.Sequence,
+    dt: int,
+    with_modulation: bool,
+    laser_waist: float | None,
+) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    """
+    Samples the Pulser sequence and returns a tuple of tensors (omega, delta, phi)
+    containing:
+    - omega[i, q] = amplitude at time i * dt for qubit q
+    - delta[i, q] = detuning at time i * dt for qubit q
+    - phi[i, q] = phase at time i * dt for qubit q
+
+    if laser_waist is w_0 != None, the omega values coming from the global pulse channel
+    will me modulated as $\\Omega_i=\\Omega_i e^{-r_i^2/w_0^2}$
+    """
+
+    if with_modulation and sequence._slm_mask_targets:
+        raise NotImplementedError(
+            "Simulation of sequences combining an SLM mask and output "
+            "modulation is not supported."
+        )
+
+    samples = pulser.sampler.sample(
+        sequence,
+        modulation=with_modulation,
+        extended_duration=sequence.get_duration(include_fall_time=with_modulation),
+    )
+    sequence_dict = samples.to_nested_dict(all_local=True, samples_type="tensor")["Local"]
+
+    if "ground-rydberg" in sequence_dict and len(sequence_dict) == 1:
+        locals_a_d_p = sequence_dict["ground-rydberg"]
+    elif "XY" in sequence_dict and len(sequence_dict) == 1:
+        locals_a_d_p = sequence_dict["XY"]
+    else:
+        raise ValueError("Emu-MPS only accepts ground-rydberg or mw_global channels")
+
+    max_duration = sequence.get_duration(include_fall_time=with_modulation)
+
+    nsamples = math.ceil(max_duration / dt - 1 / 2)
+    omega = torch.zeros(
+        nsamples,
+        len(sequence.register.qubit_ids),
+        dtype=torch.complex128,
+    )
+
+    delta = torch.zeros(
+        nsamples,
+        len(sequence.register.qubit_ids),
+        dtype=torch.complex128,
+    )
+    phi = torch.zeros(
+        nsamples,
+        len(sequence.register.qubit_ids),
+        dtype=torch.complex128,
+    )
+
+    if laser_waist:
+        qubit_positions = _get_qubit_positions(sequence.register)
+        waist_factors = torch.tensor(
+            [math.exp(-((x[:2].norm() / laser_waist) ** 2)) for x in qubit_positions]
+        )
+    else:
+        waist_factors = torch.ones(len(sequence.register.qubit_ids))
+
+    global_times = set()
+    for ch, ch_samples in samples.channel_samples.items():
+        if samples._ch_objs[ch].addressing == "Global":
+            for slot in ch_samples.slots:
+                global_times |= set(i for i in range(slot.ti, slot.tf))
+
+    step = 0
+    t = int((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"][t]
+            delta[step, q_pos] = locals_a_d_p[q_id]["det"][t]
+            phi[step, q_pos] = locals_a_d_p[q_id]["phase"][t]
+        if t in global_times:
+            omega[step] *= waist_factors
+        step += 1
+        t = int((step + 1 / 2) * dt)
+
+    return omega, delta, phi
+
+
+_NON_LINDBLADIAN_NOISE = {"SPAM", "doppler", "amplitude"}
+
+
+def _get_all_lindblad_noise_operators(
+    noise_model: NoiseModel | None,
+) -> list[torch.Tensor]:
+    if noise_model is None:
+        return []
+
+    return [
+        op
+        for noise_type in noise_model.noise_types
+        if noise_type not in _NON_LINDBLADIAN_NOISE
+        for op in get_lindblad_operators(noise_type=noise_type, noise_model=noise_model)
+    ]
+
+
+class PulserData:
+    slm_end_time: int
+    full_interaction_matrix: torch.Tensor
+    masked_interaction_matrix: torch.Tensor
+    omega: torch.Tensor
+    delta: torch.Tensor
+    phi: torch.Tensor
+    hamiltonian_type: HamiltonianType
+    lindblad_ops: list[torch.Tensor]
+
+    def __init__(self, *, sequence: pulser.Sequence, config: BackendConfig, dt: int):
+        self.qubit_count = len(sequence.register.qubit_ids)
+
+        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,
+            with_modulation=config.with_modulation,
+            laser_waist=laser_waist,
+        )
+        self.lindblad_ops = _get_all_lindblad_noise_operators(config.noise_model)
+        self.has_lindblad_noise: bool = self.lindblad_ops != []
+
+        addressed_basis = sequence.get_addressed_bases()[0]
+        if addressed_basis == "ground-rydberg":  # for local and global
+            self.hamiltonian_type = HamiltonianType.Rydberg
+        elif addressed_basis == "XY":
+            self.hamiltonian_type = HamiltonianType.XY
+        else:
+            raise ValueError(f"Unsupported basis: {addressed_basis}")
+
+        if config.interaction_matrix is not None:
+            assert len(config.interaction_matrix) == self.qubit_count, (
+                "The number of qubits in the register should be the same as the size of "
+                "the interaction matrix"
+            )
+
+            self.full_interaction_matrix = torch.tensor(
+                config.interaction_matrix, dtype=torch.float64
+            )
+        elif self.hamiltonian_type == HamiltonianType.Rydberg:
+            self.full_interaction_matrix = _rydberg_interaction(sequence)
+        elif self.hamiltonian_type == HamiltonianType.XY:
+            self.full_interaction_matrix = _xy_interaction(sequence)
+        self.full_interaction_matrix[
+            torch.abs(self.full_interaction_matrix) < config.interaction_cutoff
+        ] = 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:
+            self.masked_interaction_matrix[target] = 0.0
+            self.masked_interaction_matrix[:, target] = 0.0

emu_base/utils.py

@@ -0,0 +1,9 @@
+import torch
+
+
+def dist2(left: torch.tensor, right: torch.tensor) -> torch.Tensor:
+    return torch.norm(left - right) ** 2
+
+
+def dist3(left: torch.tensor, right: torch.tensor) -> torch.Tensor:
+    return torch.norm(left - right) ** 3

emu_base-1.2.1.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: emu-base
+Version: 1.2.1
+Summary: Pasqal base classes for emulators
+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: Proprietary
+Classifier: License :: Other/Proprietary License
+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.1.*
+Requires-Dist: torch==2.5.0
+Description-Content-Type: text/markdown
+
+<div align="center">
+  <img src="docs/logos/LogoTaglineSoftGreen.svg">
+
+  # Emu-MPS
+</div>
+
+**EMU-MPS** is a Pulser backend, designed to **EMU**late the dynamics of programmable arrays of neutral atoms, with matrix product states (**MPS**). It allows users to increase the number of qubits and reduce computation time.
+
+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.
+
+
+## Getting started
+
+You can install from source, or download the package from the private pypi registry that pasqal maintains in gitlab.
+For developers, we recommend installing from source, for users we recommend installing from the registry.
+
+**Warning:** installing emu-mps will update pulser-core
+
+We always recommend using a virtual environment.
+
+<details>
+  <summary>Click me to see how it is done</summary>
+
+  #### Create a virtual environment using python
+
+  ```
+  python -m venv .venv
+  ```
+
+  Or
+
+  ```
+  python -m venv /path/to/new/virtual/environment
+  ```
+
+  Replace `/path/to/new/virtual/environment` with your desired directory path.
+
+  Then activate the environment On linux or MacOS
+
+  ```
+  source /path/to/new/virtual/environment/bin/activate
+  ```
+
+  While on Windows it's
+
+  ```
+  C:\> /path/to/new/virtual/environment/Scripts/activate
+  ```
+
+  Remember to replace `/path/to/new/virtual/environment` with the actual path to your virtual environment. Once the environment is activated, you can clone emu_mps and install it using
+
+</details>
+
+### installing from the registry
+
+When pip is configured to know about the pasqal registry, Emu-MPS installs as
+
+```bash
+pip install emu-mps
+```
+When pip is not already configured, the easiest way to do so, is to add a file `~/.config/pip/pip.conf` containing:
+
+```
+[global]
+extra-index-url=https://gitlab.pasqal.com/api/v4/projects/597/packages/pypi/simple
+                possible.other.urls
+```
+
+As this shows, it is also possible to have multiple extra repositories configured. Note that the order is not important.
+
+It is also possible to add the `extra-index-url` to the `pip install` command directly, if you somehow don't want to create a `pip.conf` file.
+
+### installing from source
+git clone this [repository ](https://gitlab.pasqal.com/emulation/rydberg-atoms/emu-ct) or download
+
+
+Then, `cd` into the root folder of the repo and type
+
+```bash
+pip install -e .
+```
+
+<details>
+  <summary>Guidelines for developers </summary>
+  We recommend using an environment, git clone the repository, then inside the `emu_mps` folder
+
+```bash
+pip install -e .
+```
+
+  Also, the installation of pytest, nbmake, pre-commit.
+
+  Do not forget to run the unit test suite by simply running `pytest` command.
+
+  Another way can be using hatch.
+
+  #### virtual environment with `hatch`
+
+  ```bash
+  python -m pip install hatch
+  python -m hatch -v shell
+  ```
+
+  When inside the shell with development dependencies, install first the pre-commit hook:
+  ```
+  pre-commit install
+  ```
+</details>
+
+## Check the tutorial notebooks and example scripts
+
+For more information, you can check the tutorials and examples located in the [examples folder](https://gitlab.pasqal.com/emulation/rydberg-atoms/emu-ct/-/tree/main/examples?ref_type=heads)
+
+## Documentation
+
+Please check the [documentation](./docs/index.md) page for more info about contributing, the API, benchmarks, etc.
+
+
+![Code Coverage](https://img.shields.io/badge/Coverage-95%25-brightgreen.svg)

emu_base-1.2.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+emu_base/__init__.py,sha256=afeGAvgNi3tn7J0cWS2JBQxYZ-HYWS6o1skt0Ev319c,1130
+emu_base/lindblad_operators.py,sha256=eXkXsLt_fV7jhF31EkxzYFU04rOJV3uWXsl6t1aTAqs,1562
+emu_base/pulser_adapter.py,sha256=AjBT9CM0HX5vh8JaU1wRZq1QgXVAryAsYMNKmtPk9x4,8730
+emu_base/utils.py,sha256=YCi7UngUzZYSOONhecUdFSB_OkH_aadMTvixzqHYYAc,235
+emu_base/base_classes/__init__.py,sha256=Su6fHtjCyg0fw-7y7e7nbMfDASppNRQs8iGaAOkO3c4,570
+emu_base/base_classes/aggregators.py,sha256=bcvoGfZCkPKv-CI29gTma6HBphGh7bjBq2Ome77eRJM,1840
+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=e7ZRNcBBTEfD_TrODZqCRncvOTUs07TivH04dKaiXrI,3333
+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/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=TKvlByRKfCNZdS_YcfCtTk4D7YGhJ-2eIylLVT-X7i4,3784
+emu_base-1.2.1.dist-info/METADATA,sha256=NJK1z5qdfuhJj4B-7f3jfJ4IgxyUp3JHGBqvdxTPhXA,4220
+emu_base-1.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emu_base-1.2.1.dist-info/RECORD,,

emu_base-1.2.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any