emu-sv 2.2.0__py3-none-any.whl → 2.3.0__py3-none-any.whl

emu_sv/__init__.py

@@ -38,4 +38,4 @@ __all__ = [
     "DensityMatrix",
 ]
 
-__version__ = "2.2.0"
+__version__ = "2.3.0"

emu_sv/custom_callback_implementations.py

@@ -6,12 +6,12 @@ from pulser.backend import (
     EnergySecondMoment,
     EnergyVariance,
     Occupation,
-    Energy,
 )
 from emu_sv.density_matrix_state import DensityMatrix
 from emu_sv.state_vector import StateVector
 from emu_sv.dense_operator import DenseOperator
 from emu_sv.hamiltonian import RydbergHamiltonian
+from emu_sv.lindblad_operator import RydbergLindbladian
 
 dtype = torch.float64
 
@@ -134,6 +134,26 @@ def energy_variance_sv_impl(
     return en_var.cpu()
 
 
+def energy_variance_sv_den_mat_impl(
+    self: EnergyVariance,
+    *,
+    config: EmulationConfig,
+    state: DensityMatrix,
+    hamiltonian: RydbergLindbladian,
+) -> torch.Tensor:
+    """
+    Custom implementation of the energy variance tr(ρH²)-tr(ρH)² for the
+    lindblad equation solver.
+    """
+    h_dense_matrix = hamiltonian.h_eff(state.matrix)  # Hρ
+    gpu = state.matrix.is_cuda
+    h_squared_dense_mat = hamiltonian.expect(
+        DensityMatrix(h_dense_matrix, gpu=gpu)
+    )  # tr(ρH²)
+    en_var: torch.Tensor = h_squared_dense_mat - hamiltonian.expect(state) ** 2  # tr(ρH)²
+    return en_var.cpu()
+
+
 def energy_second_moment_sv_impl(
     self: EnergySecondMoment,
     *,
@@ -150,15 +170,20 @@ def energy_second_moment_sv_impl(
     return en_2_mom.cpu()
 
 
-def energy_sv_impl(
-    self: Energy,
+def energy_second_moment_den_mat_impl(
+    self: EnergyVariance,
     *,
     config: EmulationConfig,
-    state: StateVector,
-    hamiltonian: RydbergHamiltonian,
+    state: DensityMatrix,
+    hamiltonian: RydbergLindbladian,
 ) -> torch.Tensor:
     """
-    Custom implementation of the energy ❬ψ|H|ψ❭ for the state vector solver.
+    Custom implementation of the second moment of energy tr(ρH²) for the
+    lindblad equation solver.
     """
-    en: torch.Tensor = hamiltonian.expect(state)
-    return en
+    h_dense_matrix = hamiltonian.h_eff(state.matrix)  # Hρ
+    gpu = state.matrix.is_cuda
+
+    return hamiltonian.expect(
+        DensityMatrix(h_dense_matrix, gpu=gpu)
+    ).cpu()  # tr(ρH²) = tr(ρ H H)

emu_sv/dense_operator.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import itertools
 from functools import reduce
 
 import torch
@@ -20,25 +19,6 @@ from pulser.backend.state import Eigenstate
 dtype = torch.complex128
 
 
-def _validate_operator_targets(operations: FullOp, nqubits: int) -> None:
-    """Check for `operator_for_string` method"""
-    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 DenseOperator(Operator[complex, torch.Tensor, StateVector]):
     """DenseOperator in EMU-SV use dense matrices"""
 
@@ -149,7 +129,6 @@ class DenseOperator(Operator[complex, torch.Tensor, StateVector]):
             A DenseOperator instance corresponding to the given representation.
         """
 
-        _validate_operator_targets(operations, n_qudits)
         assert len(set(eigenstates)) == 2, "Only qubits are supported in EMU-SV."
 
         operators_with_tensors: dict[str, torch.Tensor | QuditOp] = dict()

emu_sv/density_matrix_state.py

@@ -4,7 +4,7 @@ import math
 from typing import Mapping, TypeVar, Type, Sequence
 import torch
 from pulser.backend import State
-from emu_base import DEVICE_COUNT
+from emu_base import DEVICE_COUNT, apply_measurement_errors
 from emu_sv.state_vector import StateVector
 from emu_sv.utils import index_to_bitstring
 from pulser.backend.state import Eigenstate
@@ -176,8 +176,6 @@ class DensityMatrix(State[complex, torch.Tensor]):
          Counter({'00': 517, '11': 483})
         """
 
-        assert p_false_neg == p_false_pos == 0.0, "Error rates must be 0.0"
-
         probabilities = torch.abs(self.matrix.diagonal())
 
         outcomes = torch.multinomial(probabilities, num_shots, replacement=True)
@@ -187,6 +185,12 @@ class DensityMatrix(State[complex, torch.Tensor]):
             [index_to_bitstring(self.n_qudits, outcome) for outcome in outcomes]
         )
 
+        if p_false_neg > 0 or p_false_pos > 0:
+            counts = apply_measurement_errors(
+                counts,
+                p_false_pos=p_false_pos,
+                p_false_neg=p_false_neg,
+            )
         return counts
 
 

emu_sv/lindblad_operator.py

@@ -1,6 +1,6 @@
 import torch
 from emu_base import compute_noise_from_lindbladians, matmul_2x2_with_batched
-
+from emu_sv.density_matrix_state import DensityMatrix
 
 dtype = torch.complex128
 sigmax = torch.tensor([[0.0, 1.0], [1.0, 0.0]], dtype=dtype)
@@ -129,6 +129,52 @@ class RydbergLindbladian:
 
         return density_matrix.view(orignal_shape)
 
+    def h_eff(
+        self,
+        density_matrix: torch.Tensor,
+        lindblad_ops: torch.Tensor = torch.zeros(2, 2, dtype=dtype),
+    ) -> torch.Tensor:
+        """Compute the effective Hamiltonian, Heff = Hρ  -0.5i ∑ₖ Lₖ† Lₖ ρ, applied
+        to a density matrix ρ.
+        - libdlad_ops by default are 2x2 zero matrix"""
+        H_den_matrix = torch.zeros_like(density_matrix, dtype=dtype, device=self.device)
+
+        for qubit in range(len(self.omegas)):
+            H_q = self._local_terms_hamiltonian(qubit, lindblad_ops.to(self.device))
+            H_den_matrix += self.apply_local_op_to_density_matrix(
+                density_matrix, H_q, qubit
+            )
+
+        H_den_matrix += self._apply_interaction_terms(density_matrix)
+        return H_den_matrix
+
+    def _local_terms_hamiltonian(
+        self, qubit: int, lindblad_ops: torch.Tensor
+    ) -> torch.Tensor:
+        """Construct the Hamiltonian for single qubit terms:
+        ∑ᵢ 𝛺ᵢ /2 𝜎ₓ^ i − 𝛿ⁱ nᵢ + jump operators terms , including the sum
+        of  Lindblad terms, when 𝜙ᵢ equals to 0.0.
+        When 𝜙ᵢ not equals to 0.0:
+        ∑ᵢ 𝛺ᵢ /2 (cos (𝜙ᵢ) 𝜎ₓ^ i + sin(𝜙ᵢ)𝜎_yⁱ) − 𝛿ⁱ nᵢ + jump operators terms
+        """
+        omega = self.omegas[qubit]
+        delta = self.deltas[qubit]
+
+        sigma_x = sigmax.to(device=self.device)
+        n = n_op.to(device=self.device)
+
+        if not self.complex:
+            return omega * sigma_x - delta * n + lindblad_ops.to(self.device)
+
+        phi = self.phis[qubit]
+        sigma_y = sigmay.to(device=self.device)
+        complex_part = torch.cos(phi) * sigma_x + torch.sin(phi) * sigma_y
+        return omega * complex_part - delta * n + lindblad_ops.to(self.device)
+
+    def _apply_interaction_terms(self, density_matrix: torch.Tensor) -> torch.Tensor:
+        """Apply the interaction terms ∑ᵢⱼ Uᵢⱼ nᵢ nⱼ to the density matrix."""
+        return self.diag.view(-1, 1) * density_matrix
+
     def __matmul__(self, density_matrix: torch.Tensor) -> torch.Tensor:
         """Apply the i*RydbergLindbladian operator to the density matrix ρ
         in the following way:
@@ -142,41 +188,8 @@ class RydbergLindbladian:
         sum_lindblad_local = compute_noise_from_lindbladians(self.pulser_linblads).to(
             self.device
         )
-
-        # apply all local terms:  Ωⱼ σₓ - δⱼ n - 0.5i (∑ₖ Lₖ† Lₖ) to each qubit
-        H_den_matrix = torch.zeros_like(density_matrix, dtype=dtype, device=self.device)
-
-        if not self.complex:
-            for qubit, (omega, delta) in enumerate(zip(self.omegas, self.deltas)):
-                H_q = (
-                    omega * sigmax.to(device=self.device)
-                    - delta * n_op.to(device=self.device)
-                    + sum_lindblad_local
-                )
-                H_den_matrix += self.apply_local_op_to_density_matrix(
-                    density_matrix, H_q, qubit
-                )
-        else:
-            for qubit, (omega, delta, phi) in enumerate(
-                zip(self.omegas, self.deltas, self.phis)
-            ):
-                H_q = (
-                    omega
-                    * (
-                        (
-                            torch.cos(phi) * sigmax.to(device=self.device)
-                            + torch.sin(phi) * sigmay.to(device=self.device)
-                        )
-                    )
-                    - delta * n_op.to(device=self.device)
-                    + sum_lindblad_local
-                )
-                H_den_matrix += self.apply_local_op_to_density_matrix(
-                    density_matrix, H_q, qubit
-                )
-
-        # apply the interaction terms  ∑ᵢⱼ Uᵢⱼ nᵢ nⱼ
-        H_den_matrix += self.diag.view(-1, 1) * density_matrix
+        # Heff = Hρ  -0.5i ∑ₖ Lₖ† Lₖ ρ
+        H_den_matrix = self.h_eff(density_matrix, sum_lindblad_local)
 
         # Heff - Heff^†=  [H, ρ] - 0.5i ∑ₖ Lₖ† Lₖρ - ρ 0.5i ∑ₖ Lₖ† Lₖρ
         H_den_matrix = H_den_matrix - H_den_matrix.conj().T
@@ -195,3 +208,10 @@ class RydbergLindbladian:
         )
 
         return H_den_matrix + 1.0j * L_den_matrix_Ldag
+
+    def expect(self, state: DensityMatrix) -> torch.Tensor:
+        """Return the energy expectation value E=tr(H𝜌)"""
+        en = (self.h_eff(state.matrix)).trace()
+
+        assert torch.allclose(en.imag, torch.zeros_like(en.imag), atol=1e-8)
+        return en.real

emu_sv/state_vector.py

@@ -8,7 +8,7 @@ import torch
 
 from emu_sv.utils import index_to_bitstring
 
-from emu_base import DEVICE_COUNT
+from emu_base import DEVICE_COUNT, apply_measurement_errors
 from pulser.backend import State
 from pulser.backend.state import Eigenstate
 
@@ -155,7 +155,6 @@ class StateVector(State[complex, torch.Tensor]):
         Returns:
             the measured bitstrings, by count
         """
-        assert p_false_neg == p_false_pos == 0.0, "Error rates must be 0.0"
 
         probabilities = torch.abs(self.vector) ** 2
 
@@ -166,7 +165,12 @@ class StateVector(State[complex, torch.Tensor]):
             [index_to_bitstring(self.n_qudits, outcome) for outcome in outcomes]
         )
 
-        # NOTE: false positives and negatives
+        if p_false_neg > 0 or p_false_pos > 0:
+            counts = apply_measurement_errors(
+                counts,
+                p_false_pos=p_false_pos,
+                p_false_neg=p_false_neg,
+            )
         return counts
 
     def __add__(self, other: State) -> StateVector:

emu_sv/sv_backend_impl.py

@@ -10,6 +10,7 @@ from resource import RUSAGE_SELF, getrusage
 
 from pulser.backend import Results, Observable, State, EmulationConfig
 from emu_base import PulserData
+from emu_base.noise import pick_dark_qubits
 
 from emu_sv.state_vector import StateVector
 from emu_sv.density_matrix_state import DensityMatrix
@@ -77,6 +78,8 @@ class BaseSVBackendImpl:
     This class is used to handle the state vector and density matrix evolution.
     """
 
+    well_prepared_qubits_filter: typing.Optional[torch.Tensor]
+
     def __init__(self, config: SVConfig, pulser_data: PulserData):
         self._config = config
         self._pulser_data = pulser_data
@@ -86,6 +89,7 @@ class BaseSVBackendImpl:
         self.phi = pulser_data.phi
         self.nsteps = pulser_data.omega.shape[0]
         self.nqubits = pulser_data.omega.shape[1]
+        self.full_interaction_matrix = pulser_data.full_interaction_matrix
         self.state: State
         self.time = time.time()
         self.results = Results(atom_order=(), total_duration=self.target_times[-1])
@@ -95,7 +99,6 @@ class BaseSVBackendImpl:
             timestep_count=self.nsteps,
         )
         self._current_H: None | RydbergLindbladian | RydbergHamiltonian = None
-
         if self._config.initial_state is not None and (
             self._config.initial_state.n_qudits != self.nqubits
         ):
@@ -103,6 +106,31 @@ class BaseSVBackendImpl:
                 "Mismatch in number of atoms: initial state has "
                 f"{self._config.initial_state.n_qudits} and the sequence has {self.nqubits}"
             )
+        self.init_dark_qubits()
+
+        if (
+            self._config.initial_state is not None
+            and self._config.noise_model.state_prep_error > 0.0
+        ):
+            raise NotImplementedError(
+                "Initial state and state preparation error can not be together."
+            )
+
+    def init_dark_qubits(self) -> None:
+        if self._config.noise_model.state_prep_error > 0.0:
+            self.well_prepared_qubits_filter = pick_dark_qubits(
+                self._config.noise_model.state_prep_error, self.nqubits
+            )
+        else:
+            self.well_prepared_qubits_filter = None
+
+        if self.well_prepared_qubits_filter is not None:
+
+            self.full_interaction_matrix[self.well_prepared_qubits_filter, :] = 0.0
+            self.full_interaction_matrix[:, self.well_prepared_qubits_filter] = 0.0
+            self.omega[:, self.well_prepared_qubits_filter] = 0.0
+            self.delta[:, self.well_prepared_qubits_filter] = 0.0
+            self.phi[:, self.well_prepared_qubits_filter] = 0.0
 
     def step(self, step_idx: int) -> None:
         """One step of the evolution"""
@@ -153,7 +181,7 @@ class SVBackendImpl(BaseSVBackendImpl):
 
     def __init__(self, config: SVConfig, pulser_data: PulserData):
         """
-        For running sequences without noise. The state will evolve accoring
+        For running sequences without noise. The state will evolve according
         to e^(-iH t)
 
         Args:
@@ -179,7 +207,7 @@ class SVBackendImpl(BaseSVBackendImpl):
             self.omega[step_idx],
             self.delta[step_idx],
             self.phi[step_idx],
-            self._pulser_data.full_interaction_matrix,
+            self.full_interaction_matrix,
             self.state.vector,
             self._config.krylov_tolerance,
         )
@@ -216,7 +244,7 @@ class NoisySVBackendImpl(BaseSVBackendImpl):
             self.omega[step_idx],
             self.delta[step_idx],
             self.phi[step_idx],
-            self._pulser_data.full_interaction_matrix,
+            self.full_interaction_matrix,
             self.state.matrix,
             self._config.krylov_tolerance,
             self.pulser_lindblads,

emu_sv/sv_config.py

@@ -5,13 +5,17 @@ import sys
 from types import MethodType
 from typing import Any, ClassVar
 
+from emu_sv.utils import choose
+
 from emu_sv.custom_callback_implementations import (
+    qubit_occupation_sv_impl,
+    qubit_occupation_sv_den_mat_impl,
     correlation_matrix_sv_impl,
     correlation_matrix_sv_den_mat_impl,
     energy_second_moment_sv_impl,
+    energy_second_moment_den_mat_impl,
     energy_variance_sv_impl,
-    qubit_occupation_sv_impl,
-    qubit_occupation_sv_den_mat_impl,
+    energy_variance_sv_den_mat_impl,
 )
 
 from pulser.backend import (
@@ -103,10 +107,6 @@ class SVConfig(EmulationConfig):
                 "Warning: The runs and samples_per_run "
                 "values of the NoiseModel are ignored!"
             )
-        if "SPAM" in self.noise_model.noise_types:
-            raise NotImplementedError(
-                "SPAM errors are currently not supported in emu-sv."
-            )
 
     def _expected_kwargs(self) -> set[str]:
         return super()._expected_kwargs() | {
@@ -127,34 +127,27 @@ class SVConfig(EmulationConfig):
 
             if isinstance(obs, Occupation):
                 obs_copy.apply = MethodType(  # type: ignore[method-assign]
-                    (
-                        qubit_occupation_sv_impl
-                        if self.noise_model.noise_types == ()
-                        else qubit_occupation_sv_den_mat_impl
-                    ),
+                    choose(qubit_occupation_sv_impl, qubit_occupation_sv_den_mat_impl),
                     obs_copy,
                 )
             if isinstance(obs, CorrelationMatrix):
                 obs_copy.apply = MethodType(  # type: ignore[method-assign]
-                    (
-                        correlation_matrix_sv_impl
-                        if self.noise_model.noise_types == ()
-                        else correlation_matrix_sv_den_mat_impl
+                    choose(
+                        correlation_matrix_sv_impl, correlation_matrix_sv_den_mat_impl
                     ),
                     obs_copy,
                 )
             if isinstance(obs, EnergyVariance):
-                if self.noise_model.noise_types != ():
-                    raise Exception("Not implemented for density matrix")
                 obs_copy.apply = MethodType(  # type: ignore[method-assign]
-                    energy_variance_sv_impl, obs_copy
+                    choose(energy_variance_sv_impl, energy_variance_sv_den_mat_impl),
+                    obs_copy,
                 )
             elif isinstance(obs, EnergySecondMoment):
-                if self.noise_model.noise_types != ():
-                    raise Exception("Not implemented for density matrix")
-
                 obs_copy.apply = MethodType(  # type: ignore[method-assign]
-                    energy_second_moment_sv_impl, obs_copy
+                    choose(
+                        energy_second_moment_sv_impl, energy_second_moment_den_mat_impl
+                    ),
+                    obs_copy,
                 )
             obs_list.append(obs_copy)
         self.observables = tuple(obs_list)

emu_sv/utils.py

@@ -1,3 +1,8 @@
+from typing import Callable
+
+from pyparsing import Any
+
+
 def index_to_bitstring(nqubits: int, index: int) -> str:
     """
     Convert an integer index into its corresponding bitstring representation.
@@ -6,3 +11,24 @@ def index_to_bitstring(nqubits: int, index: int) -> str:
     msg = f"index {index} can not exceed Hilbert space size d**{nqubits}"
     assert index < 2**nqubits, msg
     return format(index, f"0{nqubits}b")
+
+
+def choose(
+    state_vector_version: Callable,
+    density_matrix_version: Callable,
+) -> Callable:
+    """Returns the observable result function that chooses the correct
+    implementation based on the type of state (StateVector or DensityMatrix).
+    """
+    from emu_sv.state_vector import StateVector
+    from emu_sv.density_matrix_state import DensityMatrix
+
+    def result(self: Any, *, state: StateVector | DensityMatrix, **kwargs: Any) -> Any:
+        if isinstance(state, StateVector):
+            return state_vector_version(self, state=state, **kwargs)
+        elif isinstance(state, DensityMatrix):
+            return density_matrix_version(self, state=state, **kwargs)
+        else:
+            raise TypeError(f"Unsupported state: {type(state).__name__}")
+
+    return result

{emu_sv-2.2.0.dist-info → emu_sv-2.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emu-sv
-Version: 2.2.0
+Version: 2.3.0
 Summary: Pasqal State Vector 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.0
+Requires-Dist: emu-base==2.3.0
 Description-Content-Type: text/markdown
 
 <div align="center">

emu_sv-2.3.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+emu_sv/__init__.py,sha256=BWI-O-rXdn7xncmWEUdxtx7gFbWflcPD2lKcsll6t9w,771
+emu_sv/custom_callback_implementations.py,sha256=_7XLIDzJ-p3DVqz-Jyv0eYbl8nih2x2p-pM4cBCLumA,6367
+emu_sv/dense_operator.py,sha256=AvgntJNwwtf3Wl66CIWSwUezVYV3vignCL24SQQQwQg,5901
+emu_sv/density_matrix_state.py,sha256=BJpFzxjgWQOb_D6dehdA6dRUUQKP1iVccTDrZKicwRE,7198
+emu_sv/hamiltonian.py,sha256=CqNGuWJlO2ZljK47wt130s-5uKiOldQUsC3tjwk1mKA,6106
+emu_sv/lindblad_operator.py,sha256=pgjRNLBcvEM2-qxM8uy9wL74OtrD4A8trQeERi_AXH8,8892
+emu_sv/state_vector.py,sha256=oZeTr44Wt1zYEmPc3yN-Zz8aKxIBTjKA0XM23T8MQkU,9871
+emu_sv/sv_backend.py,sha256=-soOkSEzEBK1dCKnYnbtvYjmNZtZra1_4jP3H1ROOtM,737
+emu_sv/sv_backend_impl.py,sha256=ISls8DGZNHrH3Z7kmrzk3oQU3J8lgBg2V4KG09Zt3jA,9263
+emu_sv/sv_config.py,sha256=J4yb9-Na5hAbShDySzPfbt0WXvL8JpfrTEikTK8nH9s,5943
+emu_sv/time_evolution.py,sha256=_VH4f2RF6lGKzO08WxTYJ5Aw8_pTTMRKcyMnIuxH03I,13382
+emu_sv/utils.py,sha256=t0nMDVo6DF5bQW-vbsyRMCmvkyNxCU-v0Enmns9aOAU,1151
+emu_sv-2.3.0.dist-info/METADATA,sha256=yc7Z-DlF125zrnUeErZ24WrRnFKjbyPxeNAfz6RwjDI,3595
+emu_sv-2.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emu_sv-2.3.0.dist-info/RECORD,,

emu_sv-2.2.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-emu_sv/__init__.py,sha256=vVU7zIUsHPgFXUBWMn1lUtkWUg-avdFRqLUrtbmPvDI,771
-emu_sv/custom_callback_implementations.py,sha256=j_G5x-xSnFSyKE81QN_DKoiTaF9JvNWaM1N6k2_t0Oo,5501
-emu_sv/dense_operator.py,sha256=NfgzVpnNitc5ZSM4RlfpAc5Ls2wFPNsTxdeFdhJSg1o,6909
-emu_sv/density_matrix_state.py,sha256=5W_UKIAYHb0k3ryRLQ2dbFUgrb5ju5jceDGAekM2gNE,7035
-emu_sv/hamiltonian.py,sha256=CqNGuWJlO2ZljK47wt130s-5uKiOldQUsC3tjwk1mKA,6106
-emu_sv/lindblad_operator.py,sha256=Rlxh24dXVUAutSrSacNO2ilNVlxKix8pfFt7h2CfVOg,7893
-emu_sv/state_vector.py,sha256=zKHCdgl_eRIOPE4qVKO53ig9UyYTQ7a_guNFXgynU7g,9753
-emu_sv/sv_backend.py,sha256=-soOkSEzEBK1dCKnYnbtvYjmNZtZra1_4jP3H1ROOtM,737
-emu_sv/sv_backend_impl.py,sha256=mdPWBLDwH0q7EEwQTmLNLLx5tycMmsCQbUifIHvciMk,8059
-emu_sv/sv_config.py,sha256=ixMTgDXKll4bXsYtAe4a_9Gng0bhwCgS42KKMwZCFHI,6308
-emu_sv/time_evolution.py,sha256=_VH4f2RF6lGKzO08WxTYJ5Aw8_pTTMRKcyMnIuxH03I,13382
-emu_sv/utils.py,sha256=-axfQ2tqw0C7I9yw-28g7lytyk373DNBjDALh4kLBrM,302
-emu_sv-2.2.0.dist-info/METADATA,sha256=aw71GDNhy2P9-zjXjXszkLyaOY95qCpPkOmG2lAmYZg,3595
-emu_sv-2.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-emu_sv-2.2.0.dist-info/RECORD,,