emu-base 2.1.1__py3-none-any.whl → 2.2.1__py3-none-any.whl

emu_base/__init__.py

@@ -2,10 +2,14 @@ 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 .jump_lindblad_operators import compute_noise_from_lindbladians
+from .math.matmul import matmul_2x2_with_batched
 from .aggregators import AggregationType, aggregate
 
 __all__ = [
     "__version__",
+    "compute_noise_from_lindbladians",
+    "matmul_2x2_with_batched",
     "AggregationType",
     "aggregate",
     "PulserData",
@@ -16,4 +20,4 @@ __all__ = [
     "DEVICE_COUNT",
 ]
 
-__version__ = "2.1.1"
+__version__ = "2.2.1"

emu_base/math/krylov_energy_min.py

@@ -0,0 +1,130 @@
+import torch
+from typing import Callable, Tuple
+
+DEFAULT_MAX_KRYLOV_DIM: int = 100
+
+
+def _lowest_eigen_pair(
+    T_trunc: torch.Tensor,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Return the lowest eigenpair of the hermitian matrix T_trunc.
+    """
+    eig_energy, eig_state = torch.linalg.eigh(T_trunc)
+    return eig_energy[0], eig_state[:, 0]
+
+
+class KrylovEnergyResult:
+    def __init__(
+        self,
+        ground_state: torch.Tensor,
+        ground_energy: float,
+        converged: bool,
+        happy_breakdown: bool,
+        iteration_count: int,
+    ):
+        self.ground_state = ground_state
+        self.ground_energy = ground_energy
+        self.converged = converged
+        self.happy_breakdown = happy_breakdown
+        self.iteration_count = iteration_count
+
+
+def krylov_energy_minimization_impl(
+    op: Callable[[torch.Tensor], torch.Tensor],
+    psi_local: torch.Tensor,
+    residual_tolerance: float,
+    norm_tolerance: float,
+    max_krylov_dim: int = DEFAULT_MAX_KRYLOV_DIM,
+) -> KrylovEnergyResult:
+    """
+    Computes the ground state of a Hermitian operator using Lanczos algorithm.
+    The Rayleigh quotient ⟨ψ|H|ψ⟩ is minimized over the Krylov subspace.
+
+    The convergence of the results is determined by a residual norm criterion or a happy breakdown.
+    """
+
+    device = psi_local.device
+    dtype = psi_local.dtype
+
+    initial_norm = psi_local.norm()
+    lanczos_vectors = [psi_local / initial_norm]
+    T = torch.zeros(max_krylov_dim + 2, max_krylov_dim + 2, dtype=dtype, device=device)
+
+    converged = False
+    happy_breakdown = False
+    iteration_count = 0
+
+    for j in range(max_krylov_dim):
+        w = op(lanczos_vectors[-1])
+
+        for k in range(max(0, j - 1), j + 1):
+            alpha = torch.tensordot(lanczos_vectors[k].conj(), w, dims=w.dim())
+            T[k, j] = alpha
+            w = w - alpha * lanczos_vectors[k]
+
+        beta = w.norm()
+        T[j + 1, j] = beta
+
+        effective_dim = len(lanczos_vectors)
+        size = effective_dim + (0 if beta < norm_tolerance else 1)
+        T_truncated = T[:size, :size]
+
+        ground_energy, ground_eigenvector = _lowest_eigen_pair(
+            T_truncated
+        )  # in Krylov subspace
+        iteration_count = j + 1
+
+        # happy breakdown check
+        if beta < norm_tolerance:
+            final_state = sum(
+                c * vec for c, vec in zip(ground_eigenvector, lanczos_vectors)
+            )
+            final_state = final_state / final_state.norm()
+            happy_breakdown = True
+            converged = True
+            break
+
+        # Reconstruct final state in original Hilbert space
+        lanczos_vectors.append(w / beta)
+        final_state = sum(c * vec for c, vec in zip(ground_eigenvector, lanczos_vectors))
+        final_state = final_state / final_state.norm()
+
+        # residual norm convergence check
+        residual_norm = torch.norm(op(final_state) - ground_energy * final_state)
+        if residual_norm < residual_tolerance:
+            happy_breakdown = False
+            converged = True
+            break
+
+    return KrylovEnergyResult(
+        ground_state=final_state,
+        ground_energy=ground_energy.item(),
+        converged=converged,
+        happy_breakdown=happy_breakdown,
+        iteration_count=iteration_count,
+    )
+
+
+def krylov_energy_minimization(
+    op: Callable[[torch.Tensor], torch.Tensor],
+    v: torch.Tensor,
+    norm_tolerance: float,
+    residual_tolerance: float,
+    max_krylov_dim: int = DEFAULT_MAX_KRYLOV_DIM,
+) -> Tuple[torch.Tensor, float]:
+
+    result = krylov_energy_minimization_impl(
+        op=op,
+        psi_local=v,
+        norm_tolerance=norm_tolerance,
+        residual_tolerance=residual_tolerance,
+        max_krylov_dim=max_krylov_dim,
+    )
+
+    if not result.converged and not result.happy_breakdown:
+        raise RecursionError(
+            "Krylov ground state solver did not converge within allotted iterations."
+        )
+
+    return result.ground_state, result.ground_energy

emu_base/math/krylov_exp.py

@@ -1,6 +1,7 @@
 from typing import Callable
 import torch
 
+
 DEFAULT_MAX_KRYLOV_DIM: int = 100
 
 
@@ -36,11 +37,14 @@ def krylov_exp_impl(
     Convergence is checked using the exponential of the "extended T matrix", a criterion
     described in "Expokit: A Software Package for Computing Matrix Exponentials"
     (https://www.maths.uq.edu.au/expokit/paper.pdf).
+
+    The input tensor object `v` becomes invalid after calling that function.
     """
 
     initial_norm = v.norm()
+    v /= initial_norm
 
-    lanczos_vectors = [v / initial_norm]
+    lanczos_vectors = [v]
     T = torch.zeros(max_krylov_dim + 2, max_krylov_dim + 2, dtype=v.dtype)
 
     for j in range(max_krylov_dim):
@@ -52,7 +56,7 @@ def krylov_exp_impl(
         for k in range(k_start, j + 1):
             overlap = torch.tensordot(lanczos_vectors[k].conj(), w, dims=w.dim())
             T[k, j] = overlap
-            w = w - overlap * lanczos_vectors[k]
+            w -= overlap * lanczos_vectors[k]
 
         n2 = w.norm()
         T[j + 1, j] = n2
@@ -67,7 +71,7 @@ def krylov_exp_impl(
                 result=result, converged=True, happy_breakdown=True, iteration_count=j + 1
             )
 
-        w = w / n2
+        w /= n2
         lanczos_vectors.append(w)
 
         # Compute exponential of extended T matrix

emu_base/math/matmul.py

@@ -0,0 +1,32 @@
+import torch
+
+
+def matmul_2x2_with_batched(left: torch.Tensor, right: torch.Tensor) -> torch.Tensor:
+    result = torch.zeros_like(right)
+    zero = torch.tensor(0, device=right.device)
+    one = torch.tensor(1, device=right.device)
+    result = result.index_add_(
+        1,
+        zero,
+        right.select(1, 0).unsqueeze(1),
+        alpha=left[0, 0],  # type: ignore [arg-type]
+    )
+    result = result.index_add_(
+        1,
+        zero,
+        right.select(1, 1).unsqueeze(1),
+        alpha=left[0, 1],  # type: ignore [arg-type]
+    )
+    result = result.index_add_(
+        1,
+        one,
+        right.select(1, 0).unsqueeze(1),
+        alpha=left[1, 0],  # type: ignore [arg-type]
+    )
+    result = result.index_add_(
+        1,
+        one,
+        right.select(1, 1).unsqueeze(1),
+        alpha=left[1, 1],  # type: ignore [arg-type]
+    )
+    return result

emu_base/pulser_adapter.py

@@ -1,15 +1,15 @@
-import pulser
-from typing import Tuple, Sequence
+from typing import Tuple, Sequence, Any
+from enum import Enum
 import torch
 import math
+import pulser
 from pulser.noise_model import NoiseModel
 from pulser.register.base_register import BaseRegister, QubitId
-from enum import Enum
-
 from pulser.backend.config import EmulationConfig
-
 from emu_base.jump_lindblad_operators import get_lindblad_operators
-from emu_base.utils import dist2, dist3
+
+KB_PER_RUBIDIUM_MASS = 95.17241379310344  # J/K/kg
+KEFF = 8.7  # µm^-1, conversion from atom velocity to detuning
 
 
 class HamiltonianType(Enum):
@@ -17,14 +17,36 @@ class HamiltonianType(Enum):
     XY = 2
 
 
+SUPPORTED_NOISES: dict = {
+    HamiltonianType.Rydberg: {
+        "amplitude",
+        "dephasing",
+        "relaxation",
+        "depolarizing",
+        "doppler",
+        "eff_noise",
+        "SPAM",
+        # "leakage",
+    },
+    HamiltonianType.XY: {
+        "dephasing",
+        "depolarizing",
+        "eff_noise",
+        "SPAM",
+    },  # , "leakage"},
+}
+
+
 def _get_qubit_positions(
     register: BaseRegister,
 ) -> 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()]
-
+    positions = [
+        position.as_tensor().to(dtype=torch.float64)
+        for position in register.qubits.values()
+    ]
     if len(positions[0]) == 2:
         return [torch.cat((position, torch.zeros(1))) for position in positions]
     return positions
@@ -32,59 +54,118 @@ 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ⱼ)
-    """
+    Returns the Rydberg interaction matrix from the qubit positions.
+        Uᵢⱼ=C₆/|rᵢ-rⱼ|⁶
 
-    num_qubits = len(sequence.register.qubit_ids)
+    see Pulser
+    [documentation](https://pulser.readthedocs.io/en/stable/conventions.html#interaction-hamiltonian).
+    """
 
+    nqubits = len(sequence.register.qubit_ids)
     c6 = sequence.device.interaction_coeff
+    positions = _get_qubit_positions(sequence.register)
 
-    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]
+    interaction_matrix = torch.zeros(nqubits, nqubits, dtype=torch.float64)
+    for i in range(nqubits):
+        for j in range(i + 1, nqubits):
+            rij = torch.dist(positions[i], positions[j])
+            interaction_matrix[[i, j], [j, i]] = c6 / rij**6
     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ᵢⱼ³ (𝜎ᵢ⁺ 𝜎ⱼ⁻ +  𝜎ᵢ⁻ 𝜎ⱼ⁺)
+    Returns the XY interaction matrix from the qubit positions.
+        Uᵢⱼ=C₃(1−3cos(𝜃ᵢⱼ)²)/|rᵢ-rⱼ|³
+    with
+        cos(𝜃ᵢⱼ) = (rᵢ-rⱼ)·m/|m||rᵢ-rⱼ|
+
+    see Pulser
+    [documentation](https://pulser.readthedocs.io/en/stable/conventions.html#interaction-hamiltonian).
     """
-    num_qubits = len(sequence.register.qubit_ids)
 
+    nqubits = len(sequence.register.qubit_ids)
     c3 = sequence.device.interaction_coeff_xy
+    mag_field = torch.tensor(sequence.magnetic_field, dtype=torch.float64)
+    mag_field /= mag_field.norm()
+    positions = _get_qubit_positions(sequence.register)
+
+    interaction_matrix = torch.zeros(nqubits, nqubits, dtype=torch.float64)
+    for i in range(nqubits):
+        for j in range(i + 1, nqubits):
+            rij = torch.dist(positions[i], positions[j])
+            cos_ij = torch.dot(positions[i] - positions[j], mag_field) / rij
+            interaction_matrix[[i, j], [j, i]] = c3 * (1 - 3 * cos_ij**2) / rij**3
+    return interaction_matrix
 
-    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.linalg.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.linalg.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])
+def _get_amp_factors(
+    samples: pulser.sampler.SequenceSamples,
+    amp_sigma: float,
+    laser_waist: float | None,
+    qubit_positions: list[torch.Tensor],
+    q_ids: tuple[str, ...],
+) -> dict[int, torch.Tensor]:
+    def perp_dist(pos: torch.Tensor, axis: torch.Tensor) -> Any:
+        return torch.linalg.vector_norm(pos - torch.vdot(pos, axis) * axis)
+
+    times_to_amp_factors: dict[int, torch.Tensor] = {}
+    for ch, ch_samples in samples.channel_samples.items():
+        ch_obj = samples._ch_objs[ch]
+        prop_dir = torch.tensor(
+            ch_obj.propagation_dir or [0.0, 1.0, 0.0], dtype=torch.float64
+        )
+        prop_dir /= prop_dir.norm()
+
+        # each channel has a noise on its laser amplitude
+        # we assume each channel has the same noise amplitude currently
+        # the hardware currently has only a global channel anyway
+        sigma_factor = (
+            1.0
+            if amp_sigma == 0.0
+            else torch.max(torch.tensor(0), torch.normal(1.0, amp_sigma, (1,))).item()
+        )
+        for slot in ch_samples.slots:
+            factors = (
+                torch.tensor(
+                    [
+                        math.exp(-((perp_dist(x, prop_dir) / laser_waist) ** 2))
+                        for x in qubit_positions
+                    ],
+                    dtype=torch.float64,
+                )  # the lasers have a gaussian profile perpendicular to the propagation direction
+                if laser_waist and ch_obj.addressing == "Global"
+                else torch.ones(
+                    len(q_ids), dtype=torch.float64
+                )  # but for a local channel, this does not matter
             )
-            interaction_matrix[numj, numi] = interaction_matrix[numi, numj]
 
-    return interaction_matrix
+            # add the amplitude noise for the targeted qubits
+            factors[[x in slot.targets for x in q_ids]] *= sigma_factor
+
+            for i in range(slot.ti, slot.tf):
+                if i in times_to_amp_factors:  # multiple local channels at the same time
+                    # pulser enforces that no two lasers target the same qubit simultaneously
+                    # so only a single factor will be != 1.0 for each qubit
+                    times_to_amp_factors[i] = factors * times_to_amp_factors[i]
+                else:
+                    times_to_amp_factors[i] = factors
+    return times_to_amp_factors
+
+
+def _get_delta_offset(nqubits: int, temperature: float) -> torch.Tensor:
+    """
+    The delta values are shifted due to atomic velocities.
+    The atomic velocities follow the Maxwell distribution
+    https://en.wikipedia.org/wiki/Maxwell%E2%80%93Boltzmann_distribution
+    and then a given residual velocity is converted to a delta offset per
+    https://en.wikipedia.org/wiki/Doppler_broadening
+    """
+    if temperature == 0.0:
+        return torch.zeros(nqubits, dtype=torch.float64)
+    t = temperature * 1e-6  # microKelvin -> Kelvin
+    sigma = KEFF * math.sqrt(KB_PER_RUBIDIUM_MASS * t)
+    return torch.normal(0.0, sigma, (nqubits,))
 
 
 def _extract_omega_delta_phi(
@@ -93,6 +174,8 @@ def _extract_omega_delta_phi(
     target_times: list[int],
     with_modulation: bool,
     laser_waist: float | None,
+    amp_sigma: float,
+    temperature: float,
 ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
     """
     Samples the Pulser sequence and returns a tuple of tensors (omega, delta, phi)
@@ -111,6 +194,8 @@ def _extract_omega_delta_phi(
             "modulation is not supported."
         )
 
+    q_ids = sequence.register.qubit_ids
+
     samples = pulser.sampler.sample(
         sequence,
         modulation=with_modulation,
@@ -123,44 +208,34 @@ def _extract_omega_delta_phi(
     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)
+        raise ValueError("Only `ground-rydberg` and `mw_global` channels are supported.")
 
     nsamples = len(target_times) - 1
     omega = torch.zeros(
         nsamples,
-        len(sequence.register.qubit_ids),
+        len(q_ids),
         dtype=torch.complex128,
     )
 
     delta = torch.zeros(
         nsamples,
-        len(sequence.register.qubit_ids),
+        len(q_ids),
         dtype=torch.complex128,
     )
     phi = torch.zeros(
         nsamples,
-        len(sequence.register.qubit_ids),
+        len(q_ids),
         dtype=torch.complex128,
     )
+    qubit_positions = _get_qubit_positions(sequence.register)
 
-    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))
+    times_to_amp_factors = _get_amp_factors(
+        samples, amp_sigma, laser_waist, qubit_positions, q_ids
+    )
 
     omega_1 = torch.zeros_like(omega[0])
     omega_2 = torch.zeros_like(omega[0])
+    max_duration = sequence.get_duration(include_fall_time=with_modulation)
 
     for i in range(nsamples):
         t = (target_times[i] + target_times[i + 1]) / 2
@@ -169,9 +244,9 @@ def _extract_omega_delta_phi(
         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)
+            t1 = math.floor(t)
+            t2 = math.ceil(t)
+            for q_pos, q_id in enumerate(q_ids):
                 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] = (
@@ -181,15 +256,13 @@ def _extract_omega_delta_phi(
                     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_1 *= times_to_amp_factors.get(t1, 1.0)
+            omega_2 *= times_to_amp_factors.get(t2, 1.0)
             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):
+            for q_pos, q_id in enumerate(q_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
@@ -199,6 +272,8 @@ def _extract_omega_delta_phi(
                 ) / 2.0
             omega[i] = torch.clamp(0.5 * (3 * omega_2 - omega_1).real, min=0.0)
 
+    doppler_offset = _get_delta_offset(len(q_ids), temperature)
+    delta += doppler_offset
     return omega, delta, phi
 
 
@@ -250,17 +325,17 @@ class PulserData:
         self.target_times: list[int] = list(observable_times)
         self.target_times.sort()
 
-        laser_waist = (
-            config.noise_model.laser_waist if config.noise_model is not None else None
-        )
+        laser_waist = config.noise_model.laser_waist
+        amp_sigma = config.noise_model.amp_sigma
+        temperature = config.noise_model.temperature
         self.omega, self.delta, self.phi = _extract_omega_delta_phi(
             sequence=sequence,
             target_times=self.target_times,
             with_modulation=config.with_modulation,
             laser_waist=laser_waist,
+            amp_sigma=amp_sigma,
+            temperature=temperature,
         )
-        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
@@ -270,6 +345,18 @@ class PulserData:
         else:
             raise ValueError(f"Unsupported basis: {addressed_basis}")
 
+        not_supported = (
+            set(config.noise_model.noise_types) - SUPPORTED_NOISES[self.hamiltonian_type]
+        )
+        if not_supported:
+            raise NotImplementedError(
+                f"Interaction mode '{self.hamiltonian_type}' does not support "
+                f"simulation of noise types: {', '.join(not_supported)}."
+            )
+
+        self.lindblad_ops = _get_all_lindblad_noise_operators(config.noise_model)
+        self.has_lindblad_noise: bool = self.lindblad_ops != []
+
         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 "

emu_base/utils.py

@@ -1,9 +1,35 @@
 import torch
 
 
-def dist2(left: torch.Tensor, right: torch.Tensor) -> float:
-    return torch.dist(left, right).item() ** 2
+def deallocate_tensor(t: torch.Tensor) -> None:
+    """
+    Free the memory used by a tensor. This is done regardless of the
+    memory management done by Python: it is a forced deallocation
+    that ignores the current reference count of the Tensor object.
 
+    It is useful when you want to free memory that is no longer used
+    inside a function but that memory is also owned by a variable
+    in the outer scope, making it impossible to free it otherwise.
 
-def dist3(left: torch.Tensor, right: torch.Tensor) -> float:
-    return torch.dist(left, right).item() ** 3
+    After calling that function, the Tensor object
+    should no longer be used.
+
+    To work properly with e.g. tensordot but also user-created views,
+    and since every view of a tensor owns the tensor's storage independently,
+    it has to change the storage of the base AND every view referring to the base.
+    However, it is not possible to access the views from the base, so
+    if there are extra inaccessible views, it will raise an exception.
+    """
+    if (t._base is None and t._use_count() > 1) or (  # type: ignore[attr-defined]
+        t._base is not None and t._base._use_count() > 2  # type: ignore[attr-defined]
+    ):
+        raise RuntimeError("Cannot deallocate tensor")
+
+    replacement_storage = torch.zeros(0, dtype=t.dtype, device=t.device).untyped_storage()
+
+    t.resize_(0)
+    t.set_(source=replacement_storage)
+
+    if t._base is not None:
+        t._base.resize_(0)
+        t._base.set_(source=replacement_storage)

{emu_base-2.1.1.dist-info → emu_base-2.2.1.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: emu-base
-Version: 2.1.1
+Version: 2.2.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
 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>
+Author-email: Kemal Bidzhiev <kemal.bidzhiev@pasqal.com>, Stefano Grava <stefano.grava@pasqal.com>, Pablo Le Henaff <pablo.le-henaff@pasqal.com>, Mauro Mendizabal <mauro.mendizabal-pico@pasqal.com>, Elie Merhej <elie.merhej@pasqal.com>, Anton Quelle <anton.quelle@pasqal.com>
 License: PASQAL OPEN-SOURCE SOFTWARE LICENSE AGREEMENT (MIT-derived)
         
         The author of the License is:
@@ -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.4.*
+Requires-Dist: pulser-core==1.5.*
 Requires-Dist: torch==2.7.0
 Description-Content-Type: text/markdown
 

emu_base-2.2.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+emu_base/__init__.py,sha256=lXgYx3VbA0qNMwDZyV4HpFcr6aUDxhqWjy8Um73JXrs,681
+emu_base/aggregators.py,sha256=bB-rldoDAErxQMpL715K5lpiabGOpkCY0GyxW7mfHuc,5000
+emu_base/constants.py,sha256=41LYkKLUCz-oxPbd-j7nUDZuhIbUrnez6prT0uR0jcE,56
+emu_base/jump_lindblad_operators.py,sha256=Y30f8emVFS4Dazljc_Rh4lX9qU4QQY_AxPNahnzcsfY,2101
+emu_base/pulser_adapter.py,sha256=WJX8y6iBYg8FX--q0Y10haz-35TbmUGoHbMDQEDuZIY,14534
+emu_base/utils.py,sha256=-nIoJuu1pOxkPc2tiJTLjQ0ONsPR43CCB6vOJqdWaUc,1425
+emu_base/math/__init__.py,sha256=6BbIytYV5uC-e5jLMtIErkcUl_PvfSNnhmVFY9Il8uQ,97
+emu_base/math/brents_root_finding.py,sha256=AVx6L1Il6rpPJWrLJ7cn6oNmJyZOPRgEaaZaubC9lsU,3711
+emu_base/math/double_krylov.py,sha256=X16dyCbyzdP7fFK-hmKS03Q-DJtC6TZ8sJrGTJ6akIc,3708
+emu_base/math/krylov_energy_min.py,sha256=hm_B5qtBXHY1hl-r_LgDUKNDsdqVCDBHprQB3D-UFR8,4009
+emu_base/math/krylov_exp.py,sha256=mGFddVQ8mEbwypbZtnlRPFpi4Nf8JZT6OKLHloIwCDQ,3934
+emu_base/math/matmul.py,sha256=lEAnV0b5z_f1xEA-9p-WXxA8bM3QbShiHdXQ3ZkZFcQ,877
+emu_base-2.2.1.dist-info/METADATA,sha256=Rs1xk1Xu4iB3-sWXgq0ASiM2bULwk0DVEfC-AclHIGs,3604
+emu_base-2.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emu_base-2.2.1.dist-info/RECORD,,

emu_base-2.1.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-emu_base/__init__.py,sha256=jwcX-VKAHMt-ZwhwGyFknseHFgZaQk5ZUBraEtrrj9s,493
-emu_base/aggregators.py,sha256=bB-rldoDAErxQMpL715K5lpiabGOpkCY0GyxW7mfHuc,5000
-emu_base/constants.py,sha256=41LYkKLUCz-oxPbd-j7nUDZuhIbUrnez6prT0uR0jcE,56
-emu_base/jump_lindblad_operators.py,sha256=Y30f8emVFS4Dazljc_Rh4lX9qU4QQY_AxPNahnzcsfY,2101
-emu_base/pulser_adapter.py,sha256=jDNUpVDlcxfUgI3q5vGfB34YZI1prT39wf--HOwkOJA,11330
-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/double_krylov.py,sha256=X16dyCbyzdP7fFK-hmKS03Q-DJtC6TZ8sJrGTJ6akIc,3708
-emu_base/math/krylov_exp.py,sha256=MNLxgtiy2djRVtmXmtlBQ6A8rSuw1OK6dTtRQUZvaHs,3854
-emu_base-2.1.1.dist-info/METADATA,sha256=9k7qJ9KPavksjlcUNEcSdnDi1mxHk0FY47NxLBtYE5E,3522
-emu_base-2.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-emu_base-2.1.1.dist-info/RECORD,,