emu-mps 2.6.0__py3-none-any.whl → 2.7.0__py3-none-any.whl

emu_mps/__init__.py

@@ -36,4 +36,4 @@ __all__ = [
     "EntanglementEntropy",
 ]
 
-__version__ = "2.6.0"
+__version__ = "2.7.0"

emu_mps/mpo.py

@@ -17,10 +17,25 @@ class MPO(Operator[complex, torch.Tensor, MPS]):
     """
     Matrix Product Operator.
 
-    Each tensor has 4 dimensions ordered as such: (left bond, output, input, right bond).
+    Each tensor is 4 dimensions with axes ordered as
+    (left_bond, phys_out, phys_in, right_bond). When contracting an MPO with
+    an MPS as H|ψ⟩, phys_in contracts with the MPS physical index, while
+    phys_out becomes the physical index of the resulting MPS.
 
     Args:
-        factors: the tensors making up the MPO
+        factors: List of 4D tensors with shape (Dl, d_out, d_in, Dr).
+            Neighboring tensors must satisfy Dr[i] == Dl[i+1].
+        num_gpus_to_use: Number of GPUs to use for placing MPO factors
+            (implementation-dependent placement). If None, uses all available
+            GPUs.
+
+    Returns:
+        MPO: A matrix product operator constructed from the provided factors.
+
+    Raises:
+        ValueError: If any factor is not 4D or if neighboring bond dimensions
+            do not match.
+        RuntimeError: If requested GPUs are not available.
     """
 
     def __init__(

emu_mps/mps.py

@@ -23,11 +23,35 @@ DEFAULT_MAX_BOND_DIM = 1024
 
 class MPS(State[complex, torch.Tensor]):
     """
-    Matrix Product State, aka tensor train.
-
+    Matrix Product State, a.k.a tensor train.
     Each tensor has 3 dimensions ordered as such: (left bond, site, right bond).
+    Only qubits and qutrits (using the leakage state: 'x') are supported. This
+    constructor creates a MPS directly from a list of tensors.
 
-    Only qubits are supported.
+    Args:
+        factors: the tensors for each site. WARNING: for efficiency, this list
+            of tensors IS NOT DEEP-COPIED. Therefore, the new MPS object is not
+            necessarily the exclusive owner of the list and its tensors.
+            As a consequence, beware of potential external modifications
+            affecting the list or the tensors.
+            You are responsible for deciding whether to pass its own exclusive
+            copy of the data to this constructor, or some shared objects.
+        orthogonality_center: the orthogonality center of the MPS, or None
+            (in which case it will be orthogonalized when needed)
+        precision: the threshold for truncating singular values during SVD
+            operations. Any singular value below this threshold will be
+            discarded, effectively reducing the bond dimension and improving
+            computational efficiency.
+            Check [precision in config](advanced/config.md#precision)
+        max_bond_dim: the maximum bond dimension to allow for this MPS
+        num_gpus_to_use: number of GPUs to use for placing MPS factors.
+            - If set to 0, all factors are placed on CPU.
+            - If set to None, factors retain their current device assignment.
+            - Otherwise, factors are distributed across the specified number of
+            GPUs.
+        eigenstates: the basis states for each qudit (['0','1'] or ['r','g'])
+            or qutrit ['g','r','x'], where 'x' is the leakage state
+            (default: ['0','1'])
     """
 
     def __init__(
@@ -41,25 +65,6 @@ class MPS(State[complex, torch.Tensor]):
         num_gpus_to_use: Optional[int] = DEVICE_COUNT,
         eigenstates: Sequence[Eigenstate] = ("r", "g"),
     ):
-        """
-        This constructor creates a MPS directly from a list of tensors. It is
-        for internal use only.
-
-        Args:
-            factors: the tensors for each site
-                WARNING: for efficiency in a lot of use cases, this list of tensors
-                IS NOT DEEP-COPIED. Therefore, the new MPS object is not necessarily
-                the exclusive owner of the list and its tensors. As a consequence,
-                beware of potential external modifications affecting the list or the tensors.
-                You are responsible for deciding whether to pass its own exclusive copy
-                of the data to this constructor, or some shared objects.
-            orthogonality_center: the orthogonality center of the MPS, or None (in which case
-                it will be orthogonalized when needed)
-            precision: the precision with which to keep this MPS
-            max_bond_dim: the maximum bond dimension to allow for this MPS
-            num_gpus_to_use: distribute the factors over this many GPUs
-                0=all factors to cpu, None=keep the existing device assignment.
-        """
         super().__init__(eigenstates=eigenstates)
         self.precision = precision
         self.max_bond_dim = max_bond_dim
@@ -555,8 +560,8 @@ class MPS(State[complex, torch.Tensor]):
     ) -> torch.Tensor:
         """
         Efficiently compute the symmetric correlation matrix
-            C_ij = <self|operator_i operator_j|self>
-        in basis ("r", "g").
+        $C_{ij} = \\langle \\text{self}|\\text{operator}_i \\text{operator}_j|\\text{self}\\rangle$
+        in basis ("r", "g"), ("0","1"), and ("r","g","x").
 
         Args:
             operator: a 2x2 (or 3x3) Torch tensor to use
@@ -609,13 +614,22 @@ class MPS(State[complex, torch.Tensor]):
 
 def inner(left: MPS, right: MPS) -> torch.Tensor:
     """
-    Wrapper around MPS.inner.
+    Computes the inner product ⟨left|right⟩ between two MPS states
+    (convenience wrapper for MPS.inner). Both MPS must have the same number of
+    sites and the same local (physical) dimension at each site.
 
     Args:
-        left: the anti-linear argument
-        right: the linear argument
+        left: Left state (conjugated in the inner product).
+        right: Right state (not conjugated).
 
     Returns:
-        the inner product
+        A scalar torch.Tensor equal to ⟨left|right⟩ (typically complex-valued).
+            Use result.item() to convert to a Python number.
+
+    Raises:
+        ValueError: If the MPS are incompatible (e.g., different lengths or
+            dimensions).
+        RuntimeError: If tensors are on incompatible
+            devices/dtypes (as raised by PyTorch).
     """
     return left.inner(right)

emu_mps/mps_backend.py

@@ -1,6 +1,6 @@
-from pulser.backend import EmulatorBackend, Results
+from pulser.backend import EmulatorBackend, Results, BitStrings
 from emu_mps.mps_config import MPSConfig
-from emu_base import init_logging
+from emu_base import init_logging, PulserData
 from emu_mps.mps_backend_impl import create_impl, MPSBackendImpl
 import pickle
 import os
@@ -12,9 +12,13 @@ class MPSBackend(EmulatorBackend):
     """
     A backend for emulating Pulser sequences using Matrix Product States (MPS),
     aka tensor trains.
+
+    Args:
+        config (MPSConfig): Configuration for the MPS backend.
+
     """
 
-    default_config = MPSConfig()
+    default_config = MPSConfig(observables=[BitStrings(evaluation_times=[1.0])])
 
     @staticmethod
     def resume(autosave_file: str | pathlib.Path) -> Results:
@@ -34,9 +38,9 @@ class MPSBackend(EmulatorBackend):
 
         impl.autosave_file = autosave_file
         impl.last_save_time = time.time()
-        init_logging(impl.config.log_level, impl.config.log_file)
+        logger = init_logging(impl.config.log_level, impl.config.log_file)
 
-        impl.config.logger.warning(
+        logger.warning(
             f"Resuming simulation from file {autosave_file}\n"
             f"Saving simulation state every {impl.config.autosave_dt} seconds"
         )
@@ -52,15 +56,22 @@ class MPSBackend(EmulatorBackend):
         """
         assert isinstance(self._config, MPSConfig)
 
-        impl = create_impl(self._sequence, self._config)
-        impl.init()  # This is separate from the constructor for testing purposes.
-
-        results = self._run(impl)
-
-        return impl.permute_results(results, self._config.optimize_qubit_ordering)
+        pulser_data = PulserData(
+            sequence=self._sequence, config=self._config, dt=self._config.dt
+        )
+        results = []
+        for sequence_data in pulser_data.get_sequences():
+            impl = create_impl(sequence_data, self._config)
+            impl.init()  # This is separate from the constructor for testing purposes.
+            result = self._run(impl)
+            results.append(
+                impl.permute_results(result, self._config.optimize_qubit_ordering)
+            )
+        return Results.aggregate(results)
 
     @staticmethod
     def _run(impl: MPSBackendImpl) -> Results:
+        impl.fill_results()  # at t == 0 for pulser compatibility
         while not impl.is_finished():
             impl.progress()
 

emu_mps/mps_backend_impl.py

@@ -6,6 +6,7 @@ import random
 import time
 import typing
 import uuid
+import logging
 
 from copy import deepcopy
 from collections import Counter
@@ -14,10 +15,9 @@ from types import MethodType
 from typing import Any, Optional
 
 import torch
-from pulser import Sequence
 from pulser.backend import EmulationConfig, Observable, Results, State
 
-from emu_base import DEVICE_COUNT, PulserData, get_max_rss
+from emu_base import DEVICE_COUNT, SequenceData, get_max_rss
 from emu_base.math.brents_root_finding import BrentsRootFinder
 from emu_base.utils import deallocate_tensor
 
@@ -72,7 +72,7 @@ class Statistics(Observable):
         duration = self.data[-1]
         max_mem = get_max_rss(state.factors[0].is_cuda)
 
-        config.logger.info(
+        logging.getLogger("emulators").info(
             f"step = {len(self.data)}/{self.timestep_count}, "
             + f"χ = {state.get_max_bond_dim()}, "
             + f"|ψ| = {state.get_memory_footprint():.3f} MB, "
@@ -107,7 +107,7 @@ class MPSBackendImpl:
     target_time: float
     results: Results
 
-    def __init__(self, mps_config: MPSConfig, pulser_data: PulserData):
+    def __init__(self, mps_config: MPSConfig, pulser_data: SequenceData):
         self.config = mps_config
         self.target_times = pulser_data.target_times
         self.target_time = self.target_times[1]
@@ -118,7 +118,7 @@ class MPSBackendImpl:
         self.delta = pulser_data.delta
         self.phi = pulser_data.phi
         self.timestep_count: int = self.omega.shape[0]
-        self.has_lindblad_noise = pulser_data.has_lindblad_noise
+        self.has_lindblad_noise = len(pulser_data.lindblad_ops) > 0
         self.eigenstates = pulser_data.eigenstates
         self.dim = pulser_data.dim
         self.lindblad_noise = torch.zeros(self.dim, self.dim, dtype=dtype)
@@ -146,7 +146,7 @@ class MPSBackendImpl:
             atom_order=optimat.permute_tuple(
                 pulser_data.qubit_ids, self.qubit_permutation
             ),
-            total_duration=self.target_times[-1],
+            total_duration=int(self.target_times[-1]),
         )
         self.statistics = Statistics(
             evaluation_times=[t / self.target_times[-1] for t in self.target_times],
@@ -154,7 +154,7 @@ class MPSBackendImpl:
             timestep_count=self.timestep_count,
         )
         self.autosave_file = self._get_autosave_filepath(self.config.autosave_prefix)
-        self.config.logger.debug(
+        logging.getLogger("emulators").debug(
             f"""Will save simulation state to file "{self.autosave_file.name}"
             every {self.config.autosave_dt} seconds.\n"""
             f"""To resume: `MPSBackend().resume("{self.autosave_file}")`"""
@@ -165,7 +165,7 @@ class MPSBackendImpl:
         if requested_num_gpus is None:
             requested_num_gpus = DEVICE_COUNT
         elif requested_num_gpus > DEVICE_COUNT:
-            self.config.logger.warning(
+            logging.getLogger("emulators").warning(
                 f"Requested to use {requested_num_gpus} GPU(s) "
                 f"but only {DEVICE_COUNT if DEVICE_COUNT > 0 else 'cpu'} available"
             )
@@ -193,8 +193,8 @@ class MPSBackendImpl:
 
     def init_dark_qubits(self) -> None:
         # has_state_preparation_error
-        if self.config.noise_model.state_prep_error > 0.0:
-            bad_atoms = self.pulser_data.hamiltonian.bad_atoms
+        if self.pulser_data.noise_model.state_prep_error > 0.0:
+            bad_atoms = self.pulser_data.bad_atoms
             self.well_prepared_qubits_filter = torch.logical_not(
                 torch.tensor(list(bool(x) for x in bad_atoms.values()))
             )
@@ -500,59 +500,80 @@ class MPSBackendImpl:
 
         self.last_save_time = time.time()
 
-        self.config.logger.debug(
+        logging.getLogger("emulators").debug(
             f"Saved simulation state in file {self.autosave_file} ({autosave_filesize}MB)"
         )
 
+    def _is_evaluation_time(
+        self,
+        observable: Observable,
+        t: float,
+        tolerance: float = 1e-10,
+    ) -> bool:
+        """Return True if ``t`` is a genuine sampling time for this observable.
+
+        Filters out nearby points that are close to, but not in, the
+        observable's evaluation times (within ``tolerance``).
+        Prevent false matches by using Pulser's tolerance
+        tol = 0.5 / total_duration. (deep inside pulser Observable class)
+        """
+        times = observable.evaluation_times
+
+        is_observable_eval_time = (
+            times is not None
+            and self.config.is_time_in_evaluation_times(t, times, tol=tolerance)
+        )
+
+        is_default_eval_time = self.config.is_evaluation_time(t, tol=tolerance)
+
+        return is_observable_eval_time or is_default_eval_time
+
     def fill_results(self) -> None:
         normalized_state = 1 / self.state.norm() * self.state
 
-        current_time_int: int = round(self.current_time)
         fractional_time = self.current_time / self.target_times[-1]
-        assert abs(self.current_time - current_time_int) < 1e-10
 
-        if self.well_prepared_qubits_filter is None:
-            for callback in self.config.observables:
-                callback(
-                    self.config,
-                    fractional_time,
-                    normalized_state,
-                    self.hamiltonian,
-                    self.results,
-                )
+        callbacks_for_current_time_step = [
+            callback
+            for callback in self.config.observables
+            if self._is_evaluation_time(callback, fractional_time)
+        ]
+        if not callbacks_for_current_time_step:
             return
 
-        full_mpo, full_state = None, None
-        for callback in self.config.observables:
-            time_tol = 0.5 / self.target_times[-1] + 1e-10
-            if (
-                callback.evaluation_times is not None
-                and self.config.is_time_in_evaluation_times(
-                    fractional_time, callback.evaluation_times, tol=time_tol
+        if self.well_prepared_qubits_filter is None:
+            state = normalized_state
+            hamiltonian = self.hamiltonian
+        else:
+            # Only do this potentially expensive step once and when needed.
+            full_mpo = MPO(
+                extended_mpo_factors(
+                    self.hamiltonian.factors, self.well_prepared_qubits_filter
                 )
-            ) or self.config.is_evaluation_time(fractional_time, tol=time_tol):
-
-                if full_mpo is None or full_state is None:
-                    # Only do this potentially expensive step once and when needed.
-                    full_mpo = MPO(
-                        extended_mpo_factors(
-                            self.hamiltonian.factors, self.well_prepared_qubits_filter
-                        )
-                    )
-                    full_state = MPS(
-                        extended_mps_factors(
-                            normalized_state.factors,
-                            self.well_prepared_qubits_filter,
-                        ),
-                        num_gpus_to_use=None,  # Keep the already assigned devices.
-                        orthogonality_center=get_extended_site_index(
-                            self.well_prepared_qubits_filter,
-                            normalized_state.orthogonality_center,
-                        ),
-                        eigenstates=normalized_state.eigenstates,
-                    )
-
-                callback(self.config, fractional_time, full_state, full_mpo, self.results)
+            )
+            full_state = MPS(
+                extended_mps_factors(
+                    normalized_state.factors,
+                    self.well_prepared_qubits_filter,
+                ),
+                num_gpus_to_use=None,  # Keep the already assigned devices.
+                orthogonality_center=get_extended_site_index(
+                    self.well_prepared_qubits_filter,
+                    normalized_state.orthogonality_center,
+                ),
+                eigenstates=normalized_state.eigenstates,
+            )
+            state = full_state
+            hamiltonian = full_mpo
+
+        for callback in callbacks_for_current_time_step:
+            callback(
+                self.config,
+                fractional_time,
+                state,
+                hamiltonian,
+                self.results,
+            )
 
     def permute_results(self, results: Results, permute: bool) -> Results:
         if permute:
@@ -608,12 +629,12 @@ class NoisyMPSBackendImpl(MPSBackendImpl):
     norm_gap_before_jump: float
     root_finder: Optional[BrentsRootFinder]
 
-    def __init__(self, config: MPSConfig, pulser_data: PulserData):
+    def __init__(self, config: MPSConfig, pulser_data: SequenceData):
         super().__init__(config, pulser_data)
         self.lindblad_ops = pulser_data.lindblad_ops
         self.root_finder = None
 
-        assert self.has_lindblad_noise
+        assert self.lindblad_ops
 
     def init_lindblad_noise(self) -> None:
         stacked = torch.stack(self.lindblad_ops)
@@ -685,7 +706,7 @@ class NoisyMPSBackendImpl(MPSBackendImpl):
         assert math.isclose(norm_after_normalizing, 1, abs_tol=1e-10)
         self.set_jump_threshold(norm_after_normalizing**2)
 
-    def fill_results(self) -> None:
+    def remove_noise_from_hamiltonian(self) -> None:
         # Remove the noise from self.hamiltonian for the callbacks.
         # Since update_H is called at the start of do_time_step this is safe.
         update_H(
@@ -696,22 +717,24 @@ class NoisyMPSBackendImpl(MPSBackendImpl):
             noise=torch.zeros(self.dim, self.dim, dtype=dtype),  # no noise
         )
 
-        super().fill_results()
+    def timestep_complete(self) -> None:
+        self.remove_noise_from_hamiltonian()
+        super().timestep_complete()
 
 
 class DMRGBackendImpl(MPSBackendImpl):
     def __init__(
         self,
         mps_config: MPSConfig,
-        pulser_data: PulserData,
+        pulser_data: SequenceData,
         energy_tolerance: float = 1e-5,
         max_sweeps: int = 2000,
     ):
 
-        if mps_config.noise_model.noise_types != ():
+        if pulser_data.noise_model.noise_types != ():
             raise NotImplementedError(
                 "DMRG solver does not currently support noise types"
-                f"you are using: {mps_config.noise_model.noise_types}"
+                f"you are using: {pulser_data.noise_model.noise_types}"
             )
         super().__init__(mps_config, pulser_data)
         self.previous_energy: Optional[float] = None
@@ -810,11 +833,10 @@ class DMRGBackendImpl(MPSBackendImpl):
         self.current_energy = None
 
 
-def create_impl(sequence: Sequence, config: MPSConfig) -> MPSBackendImpl:
-    pulser_data = PulserData(sequence=sequence, config=config, dt=config.dt)
+def create_impl(data: SequenceData, config: MPSConfig) -> MPSBackendImpl:
 
-    if pulser_data.has_lindblad_noise:
-        return NoisyMPSBackendImpl(config, pulser_data)
+    if data.lindblad_ops:
+        return NoisyMPSBackendImpl(config, data)
     if config.solver == Solver.DMRG:
-        return DMRGBackendImpl(config, pulser_data)
-    return MPSBackendImpl(config, pulser_data)
+        return DMRGBackendImpl(config, data)
+    return MPSBackendImpl(config, data)

emu_mps/mps_config.py

@@ -20,7 +20,6 @@ from pulser.backend import (
     Energy,
     EnergySecondMoment,
     EnergyVariance,
-    BitStrings,
     EmulationConfig,
 )
 import logging
@@ -77,11 +76,13 @@ class MPSConfig(EmulationConfig):
         kwargs: Arguments that are passed to the base class
 
     Examples:
-        >>> num_gpus_to_use = 2 #use 2 gpus if available, otherwise 1 or cpu
-        >>> dt = 1 #this will impact the runtime
-        >>> precision = 1e-6 #smaller dt requires better precision, generally
-        >>> MPSConfig(num_gpus_to_use=num_gpus_to_use, dt=dt, precision=precision,
-        >>>     with_modulation=True) #the last arg is taken from the base class
+        ```python
+        num_gpus_to_use = 2 #use 2 gpus if available, otherwise 1 or cpu
+        dt = 1.0 #this will impact the runtime
+        precision = 1e-6 #smaller dt requires better precision, generally
+        MPSConfig(num_gpus_to_use=num_gpus_to_use, dt=dt, precision=precision,
+            with_modulation=True) #the last arg is taken from the base class
+        ```
     """
 
     # Whether to warn if unexpected kwargs are received
@@ -92,7 +93,7 @@ class MPSConfig(EmulationConfig):
     def __init__(
         self,
         *,
-        dt: int = 10,
+        dt: float = 10.0,
         precision: float = DEFAULT_PRECISION,
         max_bond_dim: int = DEFAULT_MAX_BOND_DIM,
         max_krylov_dim: int = 100,
@@ -103,11 +104,10 @@ class MPSConfig(EmulationConfig):
         log_level: int = logging.INFO,
         log_file: pathlib.Path | None = None,
         autosave_prefix: str = "emu_mps_save_",
-        autosave_dt: int | float = float("inf"),  # disable autosave by default
+        autosave_dt: float = float("inf"),  # disable autosave by default
         solver: Solver = Solver.TDVP,
         **kwargs: Any,
     ):
-        kwargs.setdefault("observables", [BitStrings(evaluation_times=[1.0])])
         super().__init__(
             dt=dt,
             precision=precision,
@@ -124,7 +124,7 @@ class MPSConfig(EmulationConfig):
             solver=solver,
             **kwargs,
         )
-        self.logger = init_logging(log_level, log_file)
+        logger = init_logging(log_level, log_file)
 
         MIN_AUTOSAVE_DT = 10
         assert (
@@ -135,7 +135,7 @@ class MPSConfig(EmulationConfig):
         prod_tol = precision * extra_krylov_tolerance
         if prod_tol < MIN_KRYLOV_TOL:
             new_extra_krylov_tolerance = MIN_KRYLOV_TOL / precision
-            self.logger.warning(
+            logger.warning(
                 f"Requested Lanczos convergence tolerance "
                 f"(precision * extra_krylov_tolerance = {prod_tol:.2e}) "
                 f"is below minimum threshold {MIN_KRYLOV_TOL:.2e}. "
@@ -143,9 +143,9 @@ class MPSConfig(EmulationConfig):
                 f"{extra_krylov_tolerance:.2e} to {new_extra_krylov_tolerance:.2e} "
                 f"to maintain numerical stability."
             )
-            self.extra_krylov_tolerance = new_extra_krylov_tolerance
         else:
-            self.extra_krylov_tolerance = extra_krylov_tolerance
+            new_extra_krylov_tolerance = extra_krylov_tolerance
+        self._backend_options["extra_krylov_tolerance"] = new_extra_krylov_tolerance
 
         self.monkeypatch_observables()
 
@@ -153,7 +153,7 @@ class MPSConfig(EmulationConfig):
             self.noise_model.samples_per_run != 1
             and self.noise_model.samples_per_run is not None
         ):
-            self.logger.warning(
+            logger.warning(
                 "Warning: The runs and samples_per_run values of the NoiseModel are ignored!"
             )
         self._backend_options[
@@ -202,7 +202,7 @@ class MPSConfig(EmulationConfig):
                     energy_mps_impl, obs_copy
                 )
             obs_list.append(obs_copy)
-        self.observables = tuple(obs_list)
+        self._backend_options["observables"] = tuple(obs_list)
 
     def check_permutable_observables(self) -> bool:
         allowed_permutable_obs = set(
@@ -220,7 +220,7 @@ class MPSConfig(EmulationConfig):
         actual_obs = set([obs._base_tag for obs in self.observables])
         not_allowed = actual_obs.difference(allowed_permutable_obs)
         if not_allowed:
-            self.logger.warning(
+            logging.getLogger("emulators").warning(
                 f"emu-mps allows only {allowed_permutable_obs} observables with"
                 " `optimize_qubit_ordering = True`."
                 f" you provided unsupported {not_allowed}"

emu_mps/solver.py

@@ -2,5 +2,16 @@ from enum import Enum
 
 
 class Solver(str, Enum):
+    """Available MPS solvers used by emu-mps. Use these values to
+    select the algorithm for time evolution.
+    By defatult TDVP is used. In order to use DMRG, set the
+    `solver` argument of `MPSConfig` to "dmrg" or `Solver.DMRG`.
+
+    Args:
+
+    - Solver.TDVP: Time-Dependent Variational Principle solver.
+    - Solver.DMRG: Density Matrix Renormalization Group solver.
+    """
+
     TDVP = "tdvp"
     DMRG = "dmrg"

{emu_mps-2.6.0.dist-info → emu_mps-2.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emu-mps
-Version: 2.6.0
+Version: 2.7.0
 Summary: Pasqal MPS based pulse emulator built on PyTorch
 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: emu-base==2.6.0
+Requires-Dist: emu-base==2.7.0
 Description-Content-Type: text/markdown
 
 <div align="center">

{emu_mps-2.6.0.dist-info → emu_mps-2.7.0.dist-info}/RECORD

@@ -1,19 +1,19 @@
-emu_mps/__init__.py,sha256=yICuhGSXq-UppDZXY4h26sZuDtFNFBHn7y0gCsoAN9w,708
+emu_mps/__init__.py,sha256=mJrKjY6IyvYEI0h5KlmMGUwnkWKBa3VphrqFIOJZkiY,708
 emu_mps/algebra.py,sha256=VZ5uaX5PYWGqDCpRKKr819BLMMtT0pKDxc2HrlLCdgU,5423
 emu_mps/custom_callback_implementations.py,sha256=WeczmO6qkvBIipvXLqX45i3D7M4ovOrepusIGs6d2Ts,2420
 emu_mps/hamiltonian.py,sha256=OM0bPNZV7J5Egk6aTUwt4GaWqiUOP68ujZBTuqlBY1k,16289
-emu_mps/mpo.py,sha256=WmGDGkCMhlODmydd0b09YcSRlsk6Bg5xYQ4rXSNJvnY,9703
-emu_mps/mps.py,sha256=aIWbd3s4c2lqhzR1IukxOAmRK7kfUFBPHkOOCS3dcPM,21747
-emu_mps/mps_backend.py,sha256=dXcW5Fa2AAL_WlHUgr30WS2l3qiDJgBVebiVpyYWpPM,2064
-emu_mps/mps_backend_impl.py,sha256=WyB1PpC61rzrnr_c3epVZOhDtXLOdhQLsMgUtZQWCYg,30851
-emu_mps/mps_config.py,sha256=7-Hsio2gt7twVmr_iHbRNV5wi7omqa9n6HuY0Roa0WU,9228
+emu_mps/mpo.py,sha256=ZNwfTXhyBJ7UCSoMbNT2iqelINlHOtQrfzgZGEiz6Vc,10402
+emu_mps/mps.py,sha256=zlke09Lvk2IHJOPYdn2zYAiPWKCDw0mU8t80KwyzIc0,22889
+emu_mps/mps_backend.py,sha256=UZOtHBlpU5VkE8C51VgVEaHVAnLT_TCndLQvApZZeZ4,2566
+emu_mps/mps_backend_impl.py,sha256=cFFQQb4gyLRcv9kDmpQXXXtmKqV_QlLqrfmL0AaP0_k,31227
+emu_mps/mps_config.py,sha256=ZwEXWHUkrUSUIPTWUCPqEMQBzQOufuX_HO9t_Cm93mQ,9182
 emu_mps/observables.py,sha256=4C_ewkd3YkJP0xghTrGUTgXUGvJRCQcetb8cU0SjMl0,1900
-emu_mps/solver.py,sha256=M9xkHhlEouTBvoPw2UYVu6kij7CO4Z1FXw_SiGFtdgo,85
+emu_mps/solver.py,sha256=RpfNZf0ezl8boSWIwSQUJiDkqRLKy3vrlutza8cEcRI,470
 emu_mps/solver_utils.py,sha256=Q1SY8E3Kipe_RfKE8lAMRfD4mSG2VkkkPmk-fU7eAgY,8852
 emu_mps/utils.py,sha256=rL75H55hB5lDMjy8a_O2PpJq51iZKjSx91X4euxB3mY,7293
 emu_mps/optimatrix/__init__.py,sha256=fBXQ7-rgDro4hcaBijCGhx3J69W96qcw5_3mWc7tND4,364
 emu_mps/optimatrix/optimiser.py,sha256=k9suYmKLKlaZ7ozFuIqvXHyCBoCtGgkX1mpen9GOdOo,6977
 emu_mps/optimatrix/permutations.py,sha256=9DDMZtrGGZ01b9F3GkzHR3paX4qNtZiPoI7Z_Kia3Lc,3727
-emu_mps-2.6.0.dist-info/METADATA,sha256=lClIDf0_pzVhzAtoqzTGg3dcn_0qlF7vBN0bEukVXq0,3587
-emu_mps-2.6.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-emu_mps-2.6.0.dist-info/RECORD,,
+emu_mps-2.7.0.dist-info/METADATA,sha256=070Tn1jQRcwee0V3gNfoz49ni9EtL4eFfgBWSG5LyKI,3587
+emu_mps-2.7.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+emu_mps-2.7.0.dist-info/RECORD,,