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

emu_mps/__init__.py

@@ -37,4 +37,4 @@ __all__ = [
     "EntanglementEntropy",
 ]
 
-__version__ = "2.1.1"
+__version__ = "2.2.1"

emu_mps/algebra.py

@@ -106,14 +106,14 @@ def zip_right_step(
     # reshape slider as matrix
     left_inds = (slider.shape[0], *bottom.shape[1:-1])
     right_inds = (top.shape[-1], bottom.shape[-1])
-    slider = slider.reshape(math.prod(left_inds), math.prod(right_inds))
+    slider = slider.contiguous().view(math.prod(left_inds), math.prod(right_inds))
 
     L, slider = torch.linalg.qr(slider)
 
     # reshape slider to its original shape
-    slider = slider.reshape((-1, *right_inds))
+    slider = slider.view((-1, *right_inds))
     # reshape left as MPS/O factor and
-    return L.reshape(*left_inds, -1), slider
+    return L.view(*left_inds, -1), slider
 
 
 def zip_right(

emu_mps/custom_callback_implementations.py

@@ -28,7 +28,7 @@ def qubit_occupation_mps_impl(
     op = torch.tensor(
         [[[0.0, 0.0], [0.0, 1.0]]], dtype=torch.complex128, device=state.factors[0].device
     )
-    return state.expect_batch(op).real.reshape(-1).cpu()
+    return state.expect_batch(op).real.view(-1).cpu()
 
 
 def correlation_matrix_mps_impl(

emu_mps/mpo.py

@@ -1,5 +1,4 @@
 from __future__ import annotations
-import itertools
 from typing import Any, List, Sequence, Optional
 
 import torch
@@ -12,24 +11,6 @@ from emu_mps.mps import MPS
 from emu_mps.utils import new_left_bath, assign_devices
 
 
-def _validate_operator_targets(operations: FullOp, nqubits: int) -> None:
-    for tensorop in operations:
-        target_qids = (factor[1] for factor in tensorop[1])
-        target_qids_list = list(itertools.chain(*target_qids))
-        target_qids_set = set(target_qids_list)
-        if len(target_qids_set) < len(target_qids_list):
-            # Either the qubit id has been defined twice in an operation:
-            for qids in target_qids:
-                if len(set(qids)) < len(qids):
-                    raise ValueError("Duplicate atom ids in argument list.")
-            # Or it was defined in two different operations
-            raise ValueError("Each qubit can be targeted by only one operation.")
-        if max(target_qids_set) >= nqubits:
-            raise ValueError(
-                "The operation targets more qubits than there are in the register."
-            )
-
-
 class MPO(Operator[complex, torch.Tensor, MPS]):
     """
     Matrix Product Operator.
@@ -152,7 +133,7 @@ class MPO(Operator[complex, torch.Tensor, MPS]):
                 state.factors[i + 1].device
             )
         acc = new_left_bath(acc, state.factors[n], self.factors[n])
-        return acc.reshape(1)[0].cpu()
+        return acc.view(1)[0].cpu()
 
     @classmethod
     def _from_operator_repr(
@@ -176,8 +157,6 @@ class MPO(Operator[complex, torch.Tensor, MPS]):
             the operator in MPO form.
         """
 
-        _validate_operator_targets(operations, n_qudits)
-
         basis = set(eigenstates)
 
         operators_with_tensors: dict[str, torch.Tensor | QuditOp]
@@ -185,35 +164,35 @@ class MPO(Operator[complex, torch.Tensor, MPS]):
             # operators_with_tensors will now contain the basis for single qubit ops,
             # and potentially user defined strings in terms of these
             operators_with_tensors = {
-                "gg": torch.tensor(
-                    [[1.0, 0.0], [0.0, 0.0]], dtype=torch.complex128
-                ).reshape(1, 2, 2, 1),
-                "gr": torch.tensor(
-                    [[0.0, 0.0], [1.0, 0.0]], dtype=torch.complex128
-                ).reshape(1, 2, 2, 1),
-                "rg": torch.tensor(
-                    [[0.0, 1.0], [0.0, 0.0]], dtype=torch.complex128
-                ).reshape(1, 2, 2, 1),
-                "rr": torch.tensor(
-                    [[0.0, 0.0], [0.0, 1.0]], dtype=torch.complex128
-                ).reshape(1, 2, 2, 1),
+                "gg": torch.tensor([[1.0, 0.0], [0.0, 0.0]], dtype=torch.complex128).view(
+                    1, 2, 2, 1
+                ),
+                "gr": torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.complex128).view(
+                    1, 2, 2, 1
+                ),
+                "rg": torch.tensor([[0.0, 1.0], [0.0, 0.0]], dtype=torch.complex128).view(
+                    1, 2, 2, 1
+                ),
+                "rr": torch.tensor([[0.0, 0.0], [0.0, 1.0]], dtype=torch.complex128).view(
+                    1, 2, 2, 1
+                ),
             }
         elif basis == {"0", "1"}:
             # operators_with_tensors will now contain the basis for single qubit ops,
             # and potentially user defined strings in terms of these
             operators_with_tensors = {
-                "00": torch.tensor(
-                    [[1.0, 0.0], [0.0, 0.0]], dtype=torch.complex128
-                ).reshape(1, 2, 2, 1),
-                "01": torch.tensor(
-                    [[0.0, 0.0], [1.0, 0.0]], dtype=torch.complex128
-                ).reshape(1, 2, 2, 1),
-                "10": torch.tensor(
-                    [[0.0, 1.0], [0.0, 0.0]], dtype=torch.complex128
-                ).reshape(1, 2, 2, 1),
-                "11": torch.tensor(
-                    [[0.0, 0.0], [0.0, 1.0]], dtype=torch.complex128
-                ).reshape(1, 2, 2, 1),
+                "00": torch.tensor([[1.0, 0.0], [0.0, 0.0]], dtype=torch.complex128).view(
+                    1, 2, 2, 1
+                ),
+                "01": torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.complex128).view(
+                    1, 2, 2, 1
+                ),
+                "10": torch.tensor([[0.0, 1.0], [0.0, 0.0]], dtype=torch.complex128).view(
+                    1, 2, 2, 1
+                ),
+                "11": torch.tensor([[0.0, 0.0], [0.0, 1.0]], dtype=torch.complex128).view(
+                    1, 2, 2, 1
+                ),
             }
         else:
             raise ValueError("Unsupported basis provided")
@@ -235,7 +214,7 @@ class MPO(Operator[complex, torch.Tensor, MPS]):
                 return result
 
             factors = [
-                torch.eye(2, 2, dtype=torch.complex128).reshape(1, 2, 2, 1)
+                torch.eye(2, 2, dtype=torch.complex128).view(1, 2, 2, 1)
             ] * n_qudits
 
             for op in tensorop:

emu_mps/mps.py

@@ -140,8 +140,8 @@ class MPS(State[complex, torch.Tensor]):
         )
 
         for i in range(lr_swipe_start, desired_orthogonality_center):
-            q, r = torch.linalg.qr(self.factors[i].reshape(-1, self.factors[i].shape[2]))
-            self.factors[i] = q.reshape(self.factors[i].shape[0], 2, -1)
+            q, r = torch.linalg.qr(self.factors[i].view(-1, self.factors[i].shape[2]))
+            self.factors[i] = q.view(self.factors[i].shape[0], 2, -1)
             self.factors[i + 1] = torch.tensordot(
                 r.to(self.factors[i + 1].device), self.factors[i + 1], dims=1
             )
@@ -154,9 +154,9 @@ class MPS(State[complex, torch.Tensor]):
 
         for i in range(rl_swipe_start, desired_orthogonality_center, -1):
             q, r = torch.linalg.qr(
-                self.factors[i].reshape(self.factors[i].shape[0], -1).mT,
+                self.factors[i].view(self.factors[i].shape[0], -1).mT,
             )
-            self.factors[i] = q.mT.reshape(-1, 2, self.factors[i].shape[2])
+            self.factors[i] = q.mT.view(-1, 2, self.factors[i].shape[2])
             self.factors[i - 1] = torch.tensordot(
                 self.factors[i - 1], r.to(self.factors[i - 1].device), ([2], [1])
             )
@@ -301,7 +301,7 @@ class MPS(State[complex, torch.Tensor]):
             acc = torch.tensordot(acc, other.factors[i].to(acc.device), dims=1)
             acc = torch.tensordot(self.factors[i].conj(), acc, dims=([0, 1], [0, 1]))
 
-        return acc.reshape(1)[0].cpu()
+        return acc.view(1)[0].cpu()
 
     def overlap(self, other: State, /) -> torch.Tensor:
         """
@@ -399,6 +399,7 @@ class MPS(State[complex, torch.Tensor]):
         cls,
         *,
         eigenstates: Sequence[Eigenstate],
+        n_qudits: int,
         amplitudes: Mapping[str, complex],
     ) -> tuple[MPS, Mapping[str, complex]]:
         """
@@ -420,13 +421,11 @@ class MPS(State[complex, torch.Tensor]):
         else:
             raise ValueError("Unsupported basis provided")
 
-        nqubits = cls._validate_amplitudes(amplitudes, eigenstates)
-
         basis_0 = torch.tensor([[[1.0], [0.0]]], dtype=torch.complex128)  # ground state
         basis_1 = torch.tensor([[[0.0], [1.0]]], dtype=torch.complex128)  # excited state
 
         accum_mps = MPS(
-            [torch.zeros((1, 2, 1), dtype=torch.complex128)] * nqubits,
+            [torch.zeros((1, 2, 1), dtype=torch.complex128)] * n_qudits,
             orthogonality_center=0,
             eigenstates=eigenstates,
         )
@@ -468,7 +467,7 @@ class MPS(State[complex, torch.Tensor]):
             )
 
             if qubit_index < self.num_sites - 1:
-                _, r = torch.linalg.qr(center_factor.reshape(-1, center_factor.shape[2]))
+                _, r = torch.linalg.qr(center_factor.view(-1, center_factor.shape[2]))
                 center_factor = torch.tensordot(
                     r, self.factors[qubit_index + 1].to(r.device), dims=1
                 )
@@ -476,7 +475,7 @@ class MPS(State[complex, torch.Tensor]):
         center_factor = self.factors[orthogonality_center]
         for qubit_index in range(orthogonality_center - 1, -1, -1):
             _, r = torch.linalg.qr(
-                center_factor.reshape(center_factor.shape[0], -1).mT,
+                center_factor.view(center_factor.shape[0], -1).mT,
             )
             center_factor = torch.tensordot(
                 self.factors[qubit_index],
@@ -499,11 +498,10 @@ class MPS(State[complex, torch.Tensor]):
         """
         self.orthogonalize(qubit_index)
 
-        self.factors[qubit_index] = torch.tensordot(
-            self.factors[qubit_index],
-            single_qubit_operator.to(self.factors[qubit_index].device),
-            ([1], [1]),
-        ).transpose(1, 2)
+        self.factors[qubit_index] = (
+            single_qubit_operator.to(self.factors[qubit_index].device)
+            @ self.factors[qubit_index]
+        )
 
     def get_correlation_matrix(
         self, *, operator: torch.Tensor = n_operator

emu_mps/mps_backend_impl.py

@@ -7,6 +7,7 @@ import time
 import typing
 import uuid
 
+from copy import deepcopy
 from collections import Counter
 from enum import Enum, auto
 from resource import RUSAGE_SELF, getrusage
@@ -19,6 +20,7 @@ from pulser.backend import EmulationConfig, Observable, Results, State
 
 from emu_base import DEVICE_COUNT, PulserData
 from emu_base.math.brents_root_finding import BrentsRootFinder
+from emu_base.utils import deallocate_tensor
 
 from emu_mps.hamiltonian import make_H, update_H
 from emu_mps.mpo import MPO
@@ -27,7 +29,7 @@ from emu_mps.mps_config import MPSConfig
 from emu_mps.noise import pick_well_prepared_qubits
 from emu_base.jump_lindblad_operators import compute_noise_from_lindbladians
 import emu_mps.optimatrix as optimat
-from emu_mps.tdvp import (
+from emu_mps.solver_utils import (
     evolve_pair,
     evolve_single,
     new_right_bath,
@@ -168,9 +170,12 @@ class MPSBackendImpl:
             )
 
     def __getstate__(self) -> dict:
-        for obs in self.config.observables:
-            obs.apply = MethodType(type(obs).apply, obs)  # type: ignore[method-assign]
         d = self.__dict__.copy()
+        cp = deepcopy(self.config)
+        d["config"] = cp
+        d["state"].config = cp
+        for obs in cp.observables:
+            obs.apply = MethodType(type(obs).apply, obs)  # type: ignore[method-assign]
         # mypy thinks the method below is an attribute, because of the __getattr__ override
         d["results"] = self.results._to_abstract_repr()  # type: ignore[operator]
         return d
@@ -411,7 +416,7 @@ class MPSBackendImpl:
             )
             if not self.has_lindblad_noise:
                 # Free memory because it won't be used anymore
-                self.right_baths[-2] = torch.zeros(0)
+                deallocate_tensor(self.right_baths[-2])
 
             self._evolve(self.tdvp_index, dt=-delta_time / 2)
             self.left_baths.pop()
@@ -660,7 +665,7 @@ class NoisyMPSBackendImpl(MPSBackendImpl):
                 for qubit in range(self.state.num_sites)
                 for op in self.lindblad_ops
             ],
-            weights=jump_operator_weights.reshape(-1).tolist(),
+            weights=jump_operator_weights.view(-1).tolist(),
         )[0]
 
         self.state.apply(jumped_qubit_index, jump_operator)

emu_mps/mps_config.py

@@ -102,14 +102,6 @@ class MPSConfig(EmulationConfig):
         if self.optimize_qubit_ordering:
             self.check_permutable_observables()
 
-        if "doppler" in self.noise_model.noise_types:
-            raise NotImplementedError("Unsupported noise type: doppler")
-        if (
-            "amplitude" in self.noise_model.noise_types
-            and self.noise_model.amp_sigma != 0.0
-        ):
-            raise NotImplementedError("Unsupported noise type: amp_sigma")
-
         MIN_AUTOSAVE_DT = 10
         assert (
             self.autosave_dt > MIN_AUTOSAVE_DT

emu_mps/{tdvp.py → solver_utils.py}

@@ -1,11 +1,63 @@
 import torch
+from typing import Callable, Sequence
 
 from emu_base import krylov_exp
+from emu_base.math.krylov_energy_min import krylov_energy_minimization
+from emu_base.utils import deallocate_tensor
 from emu_mps import MPS, MPO
 from emu_mps.utils import split_tensor
 from emu_mps.mps_config import MPSConfig
 
 
+def make_op(
+    time_step: float | complex,
+    state_factors: Sequence[torch.Tensor],
+    baths: tuple[torch.Tensor, torch.Tensor],
+    ham_factors: Sequence[torch.Tensor],
+) -> tuple[torch.Tensor, torch.device, Callable[[torch.Tensor], torch.Tensor]]:
+    assert len(state_factors) == 2
+    assert len(baths) == 2
+    assert len(ham_factors) == 2
+
+    left_state_factor, right_state_factor = state_factors
+    left_bath, right_bath = baths
+    left_ham_factor, right_ham_factor = ham_factors
+
+    left_device = left_state_factor.device
+    right_device = right_state_factor.device
+
+    left_bond_dim = left_state_factor.shape[0]
+    right_bond_dim = right_state_factor.shape[-1]
+
+    # Computation is done on left_device (arbitrary)
+
+    right_state_factor = right_state_factor.to(left_device)
+
+    combined_state_factors = torch.tensordot(
+        left_state_factor, right_state_factor, dims=1
+    ).reshape(left_bond_dim, 4, right_bond_dim)
+
+    deallocate_tensor(left_state_factor)
+    deallocate_tensor(right_state_factor)
+
+    left_ham_factor = left_ham_factor.to(left_device)
+    right_ham_factor = right_ham_factor.to(left_device)
+    right_bath = right_bath.to(left_device)
+
+    combined_hamiltonian_factors = (
+        torch.tensordot(left_ham_factor, right_ham_factor, dims=1)
+        .transpose(2, 3)
+        .contiguous()
+        .view(left_ham_factor.shape[0], 4, 4, -1)
+    )
+
+    op = lambda x: time_step * apply_effective_Hamiltonian(
+        x, combined_hamiltonian_factors, left_bath, right_bath
+    )
+
+    return combined_state_factors, right_device, op
+
+
 def new_right_bath(
     bath: torch.Tensor, state: torch.Tensor, op: torch.Tensor
 ) -> torch.Tensor:
@@ -75,13 +127,13 @@ def apply_effective_Hamiltonian(
     state = torch.tensordot(left_bath, state, 1)
     state = state.permute(0, 3, 1, 2)
     ham = ham.permute(0, 2, 1, 3)
-    state = state.reshape(state.shape[0], state.shape[1], -1).contiguous()
-    ham = ham.reshape(-1, ham.shape[2], ham.shape[3]).contiguous()
+    state = state.view(state.shape[0], state.shape[1], -1).contiguous()
+    ham = ham.contiguous().view(-1, ham.shape[2], ham.shape[3])
     state = torch.tensordot(state, ham, 1)
     state = state.permute(0, 2, 1, 3)
-    state = state.reshape(state.shape[0], state.shape[1], -1).contiguous()
+    state = state.contiguous().view(state.shape[0], state.shape[1], -1)
     right_bath = right_bath.permute(2, 1, 0)
-    right_bath = right_bath.reshape(-1, right_bath.shape[2]).contiguous()
+    right_bath = right_bath.contiguous().view(-1, right_bath.shape[2])
     state = torch.tensordot(state, right_bath, 1)
     return state
 
@@ -102,45 +154,19 @@ def evolve_pair(
     """
     Time evolution of a pair of tensors of a tensor train using baths and truncated SVD.
     Returned state tensors are kept on their respective devices.
-    """
-    assert len(state_factors) == 2
-    assert len(baths) == 2
-    assert len(ham_factors) == 2
-
-    left_state_factor, right_state_factor = state_factors
-    left_bath, right_bath = baths
-    left_ham_factor, right_ham_factor = ham_factors
-
-    left_device = left_state_factor.device
-    right_device = right_state_factor.device
-
-    left_bond_dim = left_state_factor.shape[0]
-    right_bond_dim = right_state_factor.shape[-1]
-
-    # Computation is done on left_device (arbitrary)
-
-    combined_state_factors = torch.tensordot(
-        left_state_factor, right_state_factor.to(left_device), dims=1
-    ).reshape(left_bond_dim, 4, right_bond_dim)
 
-    left_ham_factor = left_ham_factor.to(left_device)
-    right_ham_factor = right_ham_factor.to(left_device)
-    right_bath = right_bath.to(left_device)
-
-    combined_hamiltonian_factors = (
-        torch.tensordot(left_ham_factor, right_ham_factor, dims=1)
-        .transpose(2, 3)
-        .reshape(left_ham_factor.shape[0], 4, 4, -1)
-    )
+    The input state tensor objects become invalid after calling that function.
+    """
 
-    op = (
-        lambda x: -_TIME_CONVERSION_COEFF
-        * 1j
-        * dt
-        * apply_effective_Hamiltonian(
-            x, combined_hamiltonian_factors, left_bath, right_bath
-        )
+    time_step = -1j * _TIME_CONVERSION_COEFF * dt
+    combined_state_factors, right_device, op = make_op(
+        time_step=time_step,
+        state_factors=state_factors,
+        baths=baths,
+        ham_factors=ham_factors,
     )
+    left_bond_dim = combined_state_factors.shape[0]
+    right_bond_dim = combined_state_factors.shape[-1]
 
     evol = krylov_exp(
         op,
@@ -149,7 +175,7 @@ def evolve_pair(
         norm_tolerance=config.precision * config.extra_krylov_tolerance,
         max_krylov_dim=config.max_krylov_dim,
         is_hermitian=is_hermitian,
-    ).reshape(left_bond_dim * 2, 2 * right_bond_dim)
+    ).view(left_bond_dim * 2, 2 * right_bond_dim)
 
     l, r = split_tensor(
         evol,
@@ -158,9 +184,7 @@ def evolve_pair(
         orth_center_right=orth_center_right,
     )
 
-    return l.reshape(left_bond_dim, 2, -1), r.reshape(-1, 2, right_bond_dim).to(
-        right_device
-    )
+    return l.view(left_bond_dim, 2, -1), r.view(-1, 2, right_bond_dim).to(right_device)
 
 
 def evolve_single(
@@ -174,6 +198,8 @@ def evolve_single(
 ) -> torch.Tensor:
     """
     Time evolution of a single tensor of a tensor train using baths.
+
+    The input state tensor object becomes invalid after calling that function.
     """
     assert len(baths) == 2
 
@@ -199,3 +225,50 @@ def evolve_single(
         max_krylov_dim=config.max_krylov_dim,
         is_hermitian=is_hermitian,
     )
+
+
+def minimize_energy_pair(
+    *,
+    state_factors: tuple[torch.Tensor],
+    baths: tuple[torch.Tensor, torch.Tensor],
+    ham_factors: tuple[torch.Tensor],
+    orth_center_right: bool,
+    config: MPSConfig,
+    residual_tolerance: float,
+) -> tuple[torch.Tensor, torch.Tensor, float]:
+    """
+    Minimizes the state factors (ψ_i, ψ_{i+1}) using the Lanczos/Arnoldi method
+    """
+
+    time_step = 1.0
+    combined_state_factors, right_device, op = make_op(
+        time_step=time_step,
+        state_factors=state_factors,
+        baths=baths,
+        ham_factors=ham_factors,
+    )
+
+    left_bond_dim = combined_state_factors.shape[0]
+    right_bond_dim = combined_state_factors.shape[-1]
+
+    updated_state, updated_energy = krylov_energy_minimization(
+        op,
+        combined_state_factors,
+        norm_tolerance=config.precision * config.extra_krylov_tolerance,
+        residual_tolerance=residual_tolerance,
+        max_krylov_dim=config.max_krylov_dim,
+    )
+    updated_state = updated_state.view(left_bond_dim * 2, 2 * right_bond_dim)
+
+    l, r = split_tensor(
+        updated_state,
+        max_error=config.precision,
+        max_rank=config.max_bond_dim,
+        orth_center_right=orth_center_right,
+    )
+
+    return (
+        l.view(left_bond_dim, 2, -1),
+        r.view(-1, 2, right_bond_dim).to(right_device),
+        updated_energy,
+    )

emu_mps/utils.py

@@ -53,7 +53,7 @@ def split_tensor(
             _determine_cutoff_index(d, max_error),
             d.shape[0] - max_rank,
         )
-        right = q.T.conj()[max_bond:, :]
+        right = q[:, max_bond:].T.conj_physical()
         left = m @ q
         left = left[:, max_bond:]
 
@@ -77,13 +77,13 @@ def truncate_impl(
         factor_shape = factors[i].shape
 
         l, r = split_tensor(
-            factors[i].reshape(factor_shape[0], -1),
+            factors[i].view(factor_shape[0], -1),
             max_error=config.precision,
             max_rank=config.max_bond_dim,
             orth_center_right=False,
         )
 
-        factors[i] = r.reshape(-1, *factor_shape[1:])
+        factors[i] = r.view(-1, *factor_shape[1:])
         factors[i - 1] = torch.tensordot(
             factors[i - 1], l.to(factors[i - 1].device), dims=1
         )

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

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: emu-mps
-Version: 2.1.1
+Version: 2.2.1
 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
 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: emu-base==2.1.1
+Requires-Dist: emu-base==2.2.1
 Description-Content-Type: text/markdown
 
 <div align="center">

emu_mps-2.2.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+emu_mps/__init__.py,sha256=iXV15aC4QkDT-W_pEv2vLF1vcZAUtb7GP6D4kBEYxYk,734
+emu_mps/algebra.py,sha256=78XP9HEbV3wGNUzIulcLU5HizW4XAYmcFdkCe1T1x-k,5489
+emu_mps/custom_callback_implementations.py,sha256=SZGKVyS8U5hy07L-3SqpWlCAqGGKFTlSlWexZwSmjrM,2408
+emu_mps/hamiltonian.py,sha256=gOPxNOBmk6jRPPjevERuCP_scGv0EKYeAJ0uxooihes,15622
+emu_mps/mpo.py,sha256=aWSVuEzZM-_7ZD5Rz3-tSJWX22ARP0tMIl3gUu-_4V4,7834
+emu_mps/mps.py,sha256=8i3Yz5C_cqHWeAJILOm7cz8P8cHDuNl6aBcLXtaO314,19964
+emu_mps/mps_backend.py,sha256=bS83qFxvdoK-c12_1WaPw6O7xUc7vdWifZNHUzNP5sM,2091
+emu_mps/mps_backend_impl.py,sha256=SGqL2KiICE1fLviycrRdVlw3LOYRjpF5B0XgQlElSBs,26047
+emu_mps/mps_config.py,sha256=PoSKZxJMhG6zfzgEjj4tIvyiyYRQywxkRgidh8MRBsA,8222
+emu_mps/noise.py,sha256=5BXthepWLKnuSTJfIFuPl2AcYPxUeTJdRc2b28ekkhg,208
+emu_mps/observables.py,sha256=7GQDH5kyaVNrwckk2f8ZJRV9Ca4jKhWWDsOCqYWsoEk,1349
+emu_mps/solver_utils.py,sha256=NWwg6AeCCOrx8a5_ysSojdAOmg73W1202FtYx2JEHH0,8544
+emu_mps/utils.py,sha256=PRPIe9B8n-6caVcUYn3uTFSvb3jAMkXX-63f8KtX5-U,8196
+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.2.1.dist-info/METADATA,sha256=FLJwfRKhNCuaThXQ39P92HcV4Fpz5KxPqyJMddrV-K8,3587
+emu_mps-2.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emu_mps-2.2.1.dist-info/RECORD,,

emu_mps-2.1.1.dist-info/RECORD

@@ -1,19 +0,0 @@
-emu_mps/__init__.py,sha256=8GuHi09MFuRHfvIoaIJ_S9wMOgLPw9_I52OO7Eosols,734
-emu_mps/algebra.py,sha256=ngPtTH-j2ZCBWoaJZXlkUyIlug7dY7Q92gzfnRlpPMA,5485
-emu_mps/custom_callback_implementations.py,sha256=CUs0kW3HRaPE7UeFNQOFbeWJMsz4hS2q4rgS57BBp-A,2411
-emu_mps/hamiltonian.py,sha256=gOPxNOBmk6jRPPjevERuCP_scGv0EKYeAJ0uxooihes,15622
-emu_mps/mpo.py,sha256=1ogQ25GZCwMzZ_m449oGHcYyDKrofBCr1eyzzrIPMhQ,8824
-emu_mps/mps.py,sha256=GIiWxctNmHARgf-PgQc6IHKNCe5HYSnbtlXI6Hc-0wI,20085
-emu_mps/mps_backend.py,sha256=bS83qFxvdoK-c12_1WaPw6O7xUc7vdWifZNHUzNP5sM,2091
-emu_mps/mps_backend_impl.py,sha256=U-fNHVkmQFwi_Hfun0OdJ0vmqi9ncjyJ4gIbEM1mN0Y,25887
-emu_mps/mps_config.py,sha256=WA64iI4SxxKRM8-49mjvXUzrUv4miYolVYOhR0mVmtk,8555
-emu_mps/noise.py,sha256=5BXthepWLKnuSTJfIFuPl2AcYPxUeTJdRc2b28ekkhg,208
-emu_mps/observables.py,sha256=7GQDH5kyaVNrwckk2f8ZJRV9Ca4jKhWWDsOCqYWsoEk,1349
-emu_mps/tdvp.py,sha256=0qTw9qhg0WbaAyBgeTpULHrNL0ytj80ZUb1P6GKD7Ww,6172
-emu_mps/utils.py,sha256=BqRJYAcXqprtZVJ0V_j954ON2bhTdtZiaTojsYyrWrg,8193
-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.1.1.dist-info/METADATA,sha256=45NpjZK-7fd4dqVbo4Q76XqoMecHm_J2jiqX7oPUSKA,3505
-emu_mps-2.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-emu_mps-2.1.1.dist-info/RECORD,,