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

emu_mps/__init__.py

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

emu_mps/mps.py

@@ -7,11 +7,10 @@ from typing import List, Optional, Sequence, TypeVar, Mapping
 import torch
 
 from pulser.backend.state import State, Eigenstate
-from emu_base import DEVICE_COUNT
+from emu_base import DEVICE_COUNT, apply_measurement_errors
 from emu_mps import MPSConfig
 from emu_mps.algebra import add_factors, scale_factors
 from emu_mps.utils import (
-    apply_measurement_errors,
     assign_devices,
     truncate_impl,
     tensor_trace,

emu_mps/mps_backend_impl.py

@@ -26,12 +26,13 @@ from emu_mps.hamiltonian import make_H, update_H
 from emu_mps.mpo import MPO
 from emu_mps.mps import MPS
 from emu_mps.mps_config import MPSConfig
-from emu_mps.noise import pick_well_prepared_qubits
+from emu_base.noise import pick_dark_qubits
 from emu_base.jump_lindblad_operators import compute_noise_from_lindbladians
 import emu_mps.optimatrix as optimat
 from emu_mps.solver_utils import (
     evolve_pair,
     evolve_single,
+    minimize_energy_pair,
     new_right_bath,
     right_baths,
 )
@@ -102,11 +103,11 @@ class MPSBackendImpl:
     current_time: float = (
         0.0  # While dt is an integer, noisy collapse can happen at non-integer times.
     )
-    well_prepared_qubits_filter: Optional[list[bool]]
+    well_prepared_qubits_filter: Optional[torch.Tensor]
     hamiltonian: MPO
     state: MPS
     right_baths: list[torch.Tensor]
-    tdvp_index: int
+    sweep_index: int
     swipe_direction: SwipeDirection
     timestep_index: int
     target_time: float
@@ -142,7 +143,7 @@ class MPSBackendImpl:
         self.left_baths: list[torch.Tensor]
         self.time = time.time()
         self.swipe_direction = SwipeDirection.LEFT_TO_RIGHT
-        self.tdvp_index = 0
+        self.sweep_index = 0
         self.timestep_index = 0
         self.results = Results(
             atom_order=optimat.permute_tuple(
@@ -192,8 +193,10 @@ class MPSBackendImpl:
     def init_dark_qubits(self) -> None:
         # has_state_preparation_error
         if self.config.noise_model.state_prep_error > 0.0:
-            self.well_prepared_qubits_filter = pick_well_prepared_qubits(
-                self.config.noise_model.state_prep_error, self.qubit_count
+            self.well_prepared_qubits_filter = torch.logical_not(
+                pick_dark_qubits(
+                    self.config.noise_model.state_prep_error, self.qubit_count
+                )
             )
         else:
             self.well_prepared_qubits_filter = None
@@ -241,7 +244,7 @@ class MPSBackendImpl:
 
         initial_state = MPS(
             # Deep copy of every tensor of the initial state.
-            [f.clone().detach() for f in initial_state.factors],
+            [f.detach().clone() for f in initial_state.factors],
             config=self.config,
             num_gpus_to_use=self.config.num_gpus_to_use,
             eigenstates=initial_state.eigenstates,
@@ -347,7 +350,7 @@ class MPSBackendImpl:
         """
         Do one unit of simulation work given the current state.
         Update the state accordingly.
-        The state of the simulation is stored in self.tdvp_index and self.swipe_direction.
+        The state of the simulation is stored in self.sweep_index and self.swipe_direction.
         """
         if self.is_finished():
             return
@@ -358,79 +361,79 @@ class MPSBackendImpl:
         if 1 <= self.qubit_count <= 2:
             # Corner case: only 1 or 2 qubits
             assert self.swipe_direction == SwipeDirection.LEFT_TO_RIGHT
-            assert self.tdvp_index == 0
+            assert self.sweep_index == 0
 
             if self.qubit_count == 1:
                 self._evolve(0, dt=delta_time)
             else:
                 self._evolve(0, 1, dt=delta_time, orth_center_right=False)
 
-            self.tdvp_complete()
+            self.sweep_complete()
 
         elif (
-            self.tdvp_index < self.qubit_count - 2
+            self.sweep_index < self.qubit_count - 2
             and self.swipe_direction == SwipeDirection.LEFT_TO_RIGHT
         ):
             # Left-to-right swipe of TDVP
             self._evolve(
-                self.tdvp_index,
-                self.tdvp_index + 1,
+                self.sweep_index,
+                self.sweep_index + 1,
                 dt=delta_time / 2,
                 orth_center_right=True,
             )
             self.left_baths.append(
                 new_left_bath(
                     self.get_current_left_bath(),
-                    self.state.factors[self.tdvp_index],
-                    self.hamiltonian.factors[self.tdvp_index],
-                ).to(self.state.factors[self.tdvp_index + 1].device)
+                    self.state.factors[self.sweep_index],
+                    self.hamiltonian.factors[self.sweep_index],
+                ).to(self.state.factors[self.sweep_index + 1].device)
             )
-            self._evolve(self.tdvp_index + 1, dt=-delta_time / 2)
+            self._evolve(self.sweep_index + 1, dt=-delta_time / 2)
             self.right_baths.pop()
-            self.tdvp_index += 1
+            self.sweep_index += 1
 
         elif (
-            self.tdvp_index == self.qubit_count - 2
+            self.sweep_index == self.qubit_count - 2
             and self.swipe_direction == SwipeDirection.LEFT_TO_RIGHT
         ):
             # Time-evolution of the rightmost 2 tensors
             self._evolve(
-                self.tdvp_index,
-                self.tdvp_index + 1,
+                self.sweep_index,
+                self.sweep_index + 1,
                 dt=delta_time,
                 orth_center_right=False,
             )
             self.swipe_direction = SwipeDirection.RIGHT_TO_LEFT
 
         elif (
-            1 <= self.tdvp_index and self.swipe_direction == SwipeDirection.RIGHT_TO_LEFT
+            1 <= self.sweep_index and self.swipe_direction == SwipeDirection.RIGHT_TO_LEFT
         ):
             # Right-to-left swipe of TDVP
-            assert self.tdvp_index <= self.qubit_count - 2
+            assert self.sweep_index <= self.qubit_count - 2
             self.right_baths.append(
                 new_right_bath(
                     self.get_current_right_bath(),
-                    self.state.factors[self.tdvp_index + 1],
-                    self.hamiltonian.factors[self.tdvp_index + 1],
-                ).to(self.state.factors[self.tdvp_index].device)
+                    self.state.factors[self.sweep_index + 1],
+                    self.hamiltonian.factors[self.sweep_index + 1],
+                ).to(self.state.factors[self.sweep_index].device)
             )
             if not self.has_lindblad_noise:
                 # Free memory because it won't be used anymore
                 deallocate_tensor(self.right_baths[-2])
 
-            self._evolve(self.tdvp_index, dt=-delta_time / 2)
+            self._evolve(self.sweep_index, dt=-delta_time / 2)
             self.left_baths.pop()
 
             self._evolve(
-                self.tdvp_index - 1,
-                self.tdvp_index,
+                self.sweep_index - 1,
+                self.sweep_index,
                 dt=delta_time / 2,
                 orth_center_right=False,
             )
-            self.tdvp_index -= 1
+            self.sweep_index -= 1
 
-            if self.tdvp_index == 0:
-                self.tdvp_complete()
+            if self.sweep_index == 0:
+                self.sweep_complete()
                 self.swipe_direction = SwipeDirection.LEFT_TO_RIGHT
 
         else:
@@ -438,7 +441,7 @@ class MPSBackendImpl:
 
         self.save_simulation()
 
-    def tdvp_complete(self) -> None:
+    def sweep_complete(self) -> None:
         self.current_time = self.target_time
         self.timestep_complete()
 
@@ -623,7 +626,7 @@ class NoisyMPSBackendImpl(MPSBackendImpl):
         super().init()
         self.set_jump_threshold(1.0)
 
-    def tdvp_complete(self) -> None:
+    def sweep_complete(self) -> None:
         previous_time = self.current_time
         self.current_time = self.target_time
         previous_norm_gap_before_jump = self.norm_gap_before_jump
@@ -690,6 +693,106 @@ class NoisyMPSBackendImpl(MPSBackendImpl):
         super().fill_results()
 
 
+class DMRGBackendImpl(MPSBackendImpl):
+    def __init__(
+        self,
+        mps_config: MPSConfig,
+        pulser_data: PulserData,
+        energy_tolerance: float = 1e-5,
+        max_sweeps: int = 999,
+        residual_tolerance: float = 1e-7,
+    ):
+        super().__init__(mps_config, pulser_data)
+        self.init()
+        self.state.orthogonalize(0)
+        self.previous_energy: Optional[float] = None
+        self.current_energy: Optional[float] = None
+        self.sweep_count: int = 0
+        self.energy_tolerance: float = energy_tolerance
+        self.max_sweeps: int = max_sweeps
+        self.residual_tolerance: float = residual_tolerance
+
+    def convergence_check(self, energy_tolerance: float) -> bool:
+        if self.previous_energy is None or self.current_energy is None:
+            return False
+        return abs(self.current_energy - self.previous_energy) < energy_tolerance
+
+    def progress(self) -> None:
+        if self.is_finished():
+            return
+
+        # perform one two-site energy minimization and update
+        idx = self.sweep_index
+        assert self.swipe_direction in (
+            SwipeDirection.LEFT_TO_RIGHT,
+            SwipeDirection.RIGHT_TO_LEFT,
+        ), "Unknown Swipe direction"
+
+        if self.swipe_direction == SwipeDirection.LEFT_TO_RIGHT:
+            left_idx, right_idx = idx, idx + 1
+        elif self.swipe_direction == SwipeDirection.RIGHT_TO_LEFT:
+            left_idx, right_idx = idx - 1, idx
+
+        orth_center_right = self.swipe_direction == SwipeDirection.LEFT_TO_RIGHT
+        new_L, new_R, energy = minimize_energy_pair(
+            state_factors=self.state.factors[left_idx : right_idx + 1],
+            ham_factors=self.hamiltonian.factors[left_idx : right_idx + 1],
+            baths=(self.left_baths[-1], self.right_baths[-1]),
+            orth_center_right=orth_center_right,
+            config=self.config,
+            residual_tolerance=self.residual_tolerance,
+        )
+        self.state.factors[left_idx], self.state.factors[right_idx] = new_L, new_R
+        self.state.orthogonality_center = right_idx if orth_center_right else left_idx
+        self.current_energy = energy
+
+        # updating baths and orthogonality center
+        if self.swipe_direction == SwipeDirection.LEFT_TO_RIGHT:
+            self.left_baths.append(
+                new_left_bath(
+                    self.get_current_left_bath(),
+                    self.state.factors[left_idx],
+                    self.hamiltonian.factors[right_idx],
+                ).to(self.state.factors[right_idx].device)
+            )
+            self.right_baths.pop()
+            self.sweep_index += 1
+
+            if self.sweep_index == self.qubit_count - 1:
+                self.swipe_direction = SwipeDirection.RIGHT_TO_LEFT
+
+        elif self.swipe_direction == SwipeDirection.RIGHT_TO_LEFT:
+            self.right_baths.append(
+                new_right_bath(
+                    self.get_current_right_bath(),
+                    self.state.factors[right_idx],
+                    self.hamiltonian.factors[right_idx],
+                ).to(self.state.factors[left_idx].device)
+            )
+            self.left_baths.pop()
+            self.sweep_index -= 1
+
+            if self.sweep_index == 0:
+                self.swipe_direction = SwipeDirection.LEFT_TO_RIGHT
+                self.sweep_count += 1
+                self.sweep_complete()
+
+    def sweep_complete(self) -> None:
+        # This marks the end of one full sweep: checking convergence
+        if self.convergence_check(self.energy_tolerance):
+            self.timestep_complete()
+        elif self.sweep_count + 1 > self.max_sweeps:
+            # not converged: restart a new sweep
+            raise RuntimeError(f"DMRG did not converge after {self.max_sweeps} sweeps")
+        else:
+            self.previous_energy = self.current_energy
+
+        assert self.sweep_index == 0
+        assert self.state.orthogonality_center == 0
+        assert self.swipe_direction == SwipeDirection.LEFT_TO_RIGHT
+        self.current_energy = None
+
+
 def create_impl(sequence: Sequence, config: MPSConfig) -> MPSBackendImpl:
     pulser_data = PulserData(sequence=sequence, config=config, dt=config.dt)
 

emu_mps/solver_utils.py

@@ -229,9 +229,9 @@ def evolve_single(
 
 def minimize_energy_pair(
     *,
-    state_factors: tuple[torch.Tensor],
+    state_factors: Sequence[torch.Tensor],
     baths: tuple[torch.Tensor, torch.Tensor],
-    ham_factors: tuple[torch.Tensor],
+    ham_factors: Sequence[torch.Tensor],
     orth_center_right: bool,
     config: MPSConfig,
     residual_tolerance: float,

emu_mps/utils.py

@@ -1,7 +1,5 @@
 from typing import List, Optional
 import torch
-import random
-from collections import Counter
 
 from emu_mps import MPSConfig
 
@@ -111,7 +109,7 @@ def assign_devices(tensors: List[torch.Tensor], num_gpus_to_use: int) -> None:
 
 
 def extended_mps_factors(
-    mps_factors: list[torch.Tensor], where: list[bool]
+    mps_factors: list[torch.Tensor], where: torch.Tensor
 ) -> list[torch.Tensor]:
     """
     Given a valid list of MPS factors, accounting for qubits marked as `True` in `where`,
@@ -149,7 +147,7 @@ def extended_mps_factors(
 
 
 def extended_mpo_factors(
-    mpo_factors: list[torch.Tensor], where: list[bool]
+    mpo_factors: list[torch.Tensor], where: torch.Tensor
 ) -> list[torch.Tensor]:
     """
     Given a valid list of MPO factors, accounting for qubits marked as `True` in `where`,
@@ -184,7 +182,7 @@ def extended_mpo_factors(
 
 
 def get_extended_site_index(
-    where: list[bool], desired_index: Optional[int]
+    where: torch.Tensor, desired_index: Optional[int]
 ) -> Optional[int]:
     """
     Returns the index in `where` that has `desired_index` preceding True elements.
@@ -210,42 +208,6 @@ def get_extended_site_index(
     raise ValueError(f"Index {desired_index} does not exist")
 
 
-def readout_with_error(c: str, *, p_false_pos: float, p_false_neg: float) -> str:
-    # p_false_pos = false positive, p_false_neg = false negative
-    r = random.random()
-    if c == "0" and r < p_false_pos:
-        return "1"
-
-    if c == "1" and r < p_false_neg:
-        return "0"
-
-    return c
-
-
-def apply_measurement_errors(
-    bitstrings: Counter[str], *, p_false_pos: float, p_false_neg: float
-) -> Counter[str]:
-    """
-    Given a bag of sampled bitstrings, returns another bag of bitstrings
-    sampled with readout/measurement errors.
-
-        p_false_pos: probability of false positive
-        p_false_neg: probability of false negative
-    """
-
-    result: Counter[str] = Counter()
-    for bitstring, count in bitstrings.items():
-        for _ in range(count):
-            bitstring_with_error = "".join(
-                readout_with_error(c, p_false_pos=p_false_pos, p_false_neg=p_false_neg)
-                for c in bitstring
-            )
-
-            result[bitstring_with_error] += 1
-
-    return result
-
-
 n_operator: torch.Tensor = torch.tensor(
     [
         [0, 0],

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

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

{emu_mps-2.2.1.dist-info → emu_mps-2.3.0.dist-info}/RECORD

@@ -1,19 +1,18 @@
-emu_mps/__init__.py,sha256=iXV15aC4QkDT-W_pEv2vLF1vcZAUtb7GP6D4kBEYxYk,734
+emu_mps/__init__.py,sha256=vvVRxFPudsVALA-_YyqWf8rlIRhtI1WzBWakYk2vfB8,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.py,sha256=n5KPuWr2qCNW4Q1OKpUGrSuhu4IbVp1v1BPLvLILbGg,19960
 emu_mps/mps_backend.py,sha256=bS83qFxvdoK-c12_1WaPw6O7xUc7vdWifZNHUzNP5sM,2091
-emu_mps/mps_backend_impl.py,sha256=SGqL2KiICE1fLviycrRdVlw3LOYRjpF5B0XgQlElSBs,26047
+emu_mps/mps_backend_impl.py,sha256=O3vbjw3jlgyj0hOYv3nMmAP0lINqxbt96mQPgwPZN5w,30198
 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/solver_utils.py,sha256=VQ02_RxvPcjyXippuIY4Swpx4EdqtoJTt8Ie70GgdqU,8550
+emu_mps/utils.py,sha256=hgtaRUtBAzk76ab-S_wTVkvqfVOmaUks38zWame9GRQ,7132
 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.3.0.dist-info/METADATA,sha256=WLLpx31eshWCwR95aB_B4yoM8BRAKT81UR2mjVR3998,3587
+emu_mps-2.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emu_mps-2.3.0.dist-info/RECORD,,

emu_mps/noise.py

@@ -1,9 +0,0 @@
-import random
-
-
-def pick_well_prepared_qubits(eta: float, n: int) -> list[bool]:
-    """
-    Randomly pick n booleans such that ℙ(False) = eta.
-    """
-
-    return [random.random() > eta for _ in range(n)]