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

emu_mps/__init__.py

@@ -9,12 +9,11 @@ from pulser.backend import (
     StateResult,
     EnergySecondMoment,
 )
-from .mps_config import MPSConfig
+from .mps_config import MPSConfig, Solver
 from .mpo import MPO
 from .mps import MPS, inner
 from .mps_backend import MPSBackend
 from .observables import EntanglementEntropy
-from emu_base import aggregate
 
 
 __all__ = [
@@ -23,6 +22,7 @@ __all__ = [
     "MPS",
     "inner",
     "MPSConfig",
+    "Solver",
     "MPSBackend",
     "StateResult",
     "BitStrings",
@@ -33,8 +33,7 @@ __all__ = [
     "Energy",
     "EnergyVariance",
     "EnergySecondMoment",
-    "aggregate",
     "EntanglementEntropy",
 ]
 
-__version__ = "2.2.1"
+__version__ = "2.4.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,
@@ -154,7 +153,7 @@ 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].view(self.factors[i].shape[0], -1).mT,
+                self.factors[i].contiguous().view(self.factors[i].shape[0], -1).mT,
             )
             self.factors[i] = q.mT.view(-1, 2, self.factors[i].shape[2])
             self.factors[i - 1] = torch.tensordot(

emu_mps/mps_backend_impl.py

@@ -10,7 +10,6 @@ import uuid
 from copy import deepcopy
 from collections import Counter
 from enum import Enum, auto
-from resource import RUSAGE_SELF, getrusage
 from types import MethodType
 from typing import Any, Optional
 
@@ -18,7 +17,7 @@ import torch
 from pulser import Sequence
 from pulser.backend import EmulationConfig, Observable, Results, State
 
-from emu_base import DEVICE_COUNT, PulserData
+from emu_base import DEVICE_COUNT, PulserData, get_max_rss
 from emu_base.math.brents_root_finding import BrentsRootFinder
 from emu_base.utils import deallocate_tensor
 
@@ -26,12 +25,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.jump_lindblad_operators import compute_noise_from_lindbladians
 import emu_mps.optimatrix as optimat
+from emu_mps.solver import Solver
 from emu_mps.solver_utils import (
     evolve_pair,
     evolve_single,
+    minimize_energy_pair,
     new_right_bath,
     right_baths,
 )
@@ -68,14 +68,7 @@ class Statistics(Observable):
         """Calculates the observable to store in the Results."""
         assert isinstance(state, MPS)
         duration = self.data[-1]
-        if state.factors[0].is_cuda:
-            max_mem_per_device = (
-                torch.cuda.max_memory_allocated(device) * 1e-6
-                for device in range(torch.cuda.device_count())
-            )
-            max_mem = max(max_mem_per_device)
-        else:
-            max_mem = getrusage(RUSAGE_SELF).ru_maxrss * 1e-3
+        max_mem = get_max_rss(state.factors[0].is_cuda)
 
         config.logger.info(
             f"step = {len(self.data)}/{self.timestep_count}, "
@@ -102,11 +95,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 +135,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 +185,9 @@ 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
+            bad_atoms = self.pulser_data.hamiltonian.bad_atoms
+            self.well_prepared_qubits_filter = torch.logical_not(
+                torch.tensor(list(bool(x) for x in bad_atoms.values()))
             )
         else:
             self.well_prepared_qubits_filter = None
@@ -241,7 +235,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,
@@ -249,6 +243,7 @@ class MPSBackendImpl:
         initial_state.truncate()
         initial_state *= 1 / initial_state.norm()
         self.state = initial_state
+        self.state.orthogonalize(0)
 
     def init_hamiltonian(self) -> None:
         """
@@ -347,7 +342,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 +353,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 +433,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 +618,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,10 +685,122 @@ 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 = 2000,
+    ):
+
+        if mps_config.noise_model.noise_types != ():
+            raise NotImplementedError(
+                "DMRG solver does not currently support noise types"
+                f"you are using: {mps_config.noise_model.noise_types}"
+            )
+        super().__init__(mps_config, pulser_data)
+        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
+
+    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"
+
+        orth_center_right = self.swipe_direction == SwipeDirection.LEFT_TO_RIGHT
+        new_L, new_R, energy = minimize_energy_pair(
+            state_factors=self.state.factors[idx : idx + 2],
+            ham_factors=self.hamiltonian.factors[idx : idx + 2],
+            baths=(self.left_baths[-1], self.right_baths[-1]),
+            orth_center_right=orth_center_right,
+            config=self.config,
+            residual_tolerance=self.config.precision,
+        )
+        self.state.factors[idx], self.state.factors[idx + 1] = new_L, new_R
+        self.state.orthogonality_center = idx + 1 if orth_center_right else idx
+        self.current_energy = energy
+
+        # updating baths and orthogonality center
+        if self.swipe_direction == SwipeDirection.LEFT_TO_RIGHT:
+            self._left_to_right_update(idx)
+        elif self.swipe_direction == SwipeDirection.RIGHT_TO_LEFT:
+            self._right_to_left_update(idx)
+        else:
+            raise Exception("Did not expect this")
+
+        self.save_simulation()
+
+    def _left_to_right_update(self, idx: int) -> None:
+        if idx < self.qubit_count - 2:
+            self.left_baths.append(
+                new_left_bath(
+                    self.get_current_left_bath(),
+                    self.state.factors[idx],
+                    self.hamiltonian.factors[idx],
+                ).to(self.state.factors[idx + 1].device)
+            )
+            self.right_baths.pop()
+            self.sweep_index += 1
+
+        if self.sweep_index == self.qubit_count - 2:
+            self.swipe_direction = SwipeDirection.RIGHT_TO_LEFT
+
+    def _right_to_left_update(self, idx: int) -> None:
+        if idx > 0:
+            self.right_baths.append(
+                new_right_bath(
+                    self.get_current_right_bath(),
+                    self.state.factors[idx + 1],
+                    self.hamiltonian.factors[idx + 1],
+                ).to(self.state.factors[idx].device)
+            )
+            self.left_baths.pop()
+            self.sweep_index -= 1
+
+        if self.sweep_index == 0:
+            self.state.orthogonalize(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.current_time = self.target_time
+            self.timestep_complete()
+        elif self.sweep_count + 1 > self.max_sweeps:
+            # not converged
+            raise RuntimeError(f"DMRG did not converge after {self.max_sweeps} sweeps")
+        else:
+            # not converged for the current sweep. restart
+            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)
 
     if pulser_data.has_lindblad_noise:
         return NoisyMPSBackendImpl(config, pulser_data)
-
+    if config.solver == Solver.DMRG:
+        return DMRGBackendImpl(config, pulser_data)
     return MPSBackendImpl(config, pulser_data)

emu_mps/mps_config.py

@@ -4,6 +4,7 @@ from types import MethodType
 import copy
 
 from emu_base import DEVICE_COUNT
+from emu_mps.solver import Solver
 from emu_mps.custom_callback_implementations import (
     energy_mps_impl,
     energy_second_moment_mps_impl,
@@ -53,6 +54,11 @@ class MPSConfig(EmulationConfig):
         autosave_dt: minimum time interval in seconds between two autosaves.
             Saving the simulation state is only possible at specific times,
             therefore this interval is only a lower bound.
+        solver: chooses the solver algorithm to run a sequence.
+            Two options are currently available:
+            ``TDVP``, which performs ordinary time evolution,
+            and ``DMRG``, which adiabatically follows the ground state
+            of a given adiabatic pulse.
         kwargs: arguments that are passed to the base class
 
     Examples:
@@ -81,6 +87,7 @@ class MPSConfig(EmulationConfig):
         log_file: pathlib.Path | None = None,
         autosave_prefix: str = "emu_mps_save_",
         autosave_dt: int = 600,  # 10 minutes
+        solver: Solver = Solver.TDVP,
         **kwargs: Any,
     ):
         kwargs.setdefault("observables", [BitStrings(evaluation_times=[1.0])])
@@ -97,6 +104,7 @@ class MPSConfig(EmulationConfig):
             log_file=log_file,
             autosave_prefix=autosave_prefix,
             autosave_dt=autosave_dt,
+            solver=solver,
             **kwargs,
         )
         if self.optimize_qubit_ordering:
@@ -144,6 +152,7 @@ class MPSConfig(EmulationConfig):
             "log_file",
             "autosave_prefix",
             "autosave_dt",
+            "solver",
         }
 
     def monkeypatch_observables(self) -> None:

emu_mps/solver.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class Solver(str, Enum):
+    TDVP = "tdvp"
+    DMRG = "dmrg"

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.4.0.dist-info}/METADATA

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

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

@@ -1,19 +1,19 @@
-emu_mps/__init__.py,sha256=iXV15aC4QkDT-W_pEv2vLF1vcZAUtb7GP6D4kBEYxYk,734
+emu_mps/__init__.py,sha256=ySFn8SLcpsp1ndtvv38qg_gTlO9jt_jmwZVZd21hsg0,708
 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=I7LAxoOPKr4me5ZFdL5AZMerg7go9I1fu-MAI0ZBMgU,19973
 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/mps_backend_impl.py,sha256=JG4MlEsImc9izF-iwpgyw1t8q4M_20DxbbD4HDObSz0,30268
+emu_mps/mps_config.py,sha256=58Y9HEExeHm8p7Zm5CVwku7Y1pQmkaBV7M_hKv4PQcA,8629
 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.py,sha256=M9xkHhlEouTBvoPw2UYVu6kij7CO4Z1FXw_SiGFtdgo,85
+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.4.0.dist-info/METADATA,sha256=6eUzR_h7HcAVtC9Sy3umvCIw-w_bICX98VD-uXjRnxM,3587
+emu_mps-2.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emu_mps-2.4.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)]