emu-sv 2.0.3__py3-none-any.whl → 2.0.4__py3-none-any.whl

emu_sv/__init__.py

@@ -16,6 +16,7 @@ from .dense_operator import DenseOperator
 from .sv_backend import SVBackend, SVConfig
 from .state_vector import StateVector, inner
 
+
 __all__ = [
     "__version__",
     "BitStrings",
@@ -35,4 +36,4 @@ __all__ = [
     "inner",
 ]
 
-__version__ = "2.0.3"
+__version__ = "2.0.4"

emu_sv/hamiltonian.py

@@ -3,34 +3,36 @@ from emu_sv.state_vector import StateVector
 
 
 class RydbergHamiltonian:
-    """
-    Representation of the Rydberg Hamiltonian with light-matter interaction:
+    """Represents the Rydberg Hamiltonian for a system of interacting qubits
+    driven by laser fields, including detuning, phase, and interaction terms.
+
+    The Hamiltonian is defined as:
 
-        H = ∑ⱼΩⱼ/2[cos(ϕⱼ)σˣⱼ + sin(ϕⱼ)σʸⱼ] - ∑ⱼΔⱼnⱼ + ∑ᵢ﹥ⱼUᵢⱼnᵢnⱼ
+        H = ∑ⱼ (Ωⱼ/2)[cos(ϕⱼ) σˣⱼ + sin(ϕⱼ) σʸⱼ] - ∑ⱼ Δⱼ nⱼ + ∑_{i>j} Uᵢⱼ nᵢ nⱼ
 
-    The Hamiltonian is parameterized by driving strengths or amplitudes Ωⱼ (`omegas`), detuning
-    values Δⱼ (`deltas`), phases ϕⱼ (`phis`) and interaction terms Uᵢⱼ (`interaction_matrix`).
-    Implements an efficient H*|ψ❭ as custom sparse matrix-vector multiplication.
+    where:
+        - Ωⱼ is the Rabi frequency on qubit j,
+        - Δⱼ is the detuning on qubit j,
+        - ϕⱼ is the laser phase on qubit j,
+        - Uᵢⱼ is the interaction strength between qubits i and j,
+        - nⱼ = |1⟩⟨1| is the number operator on qubit j.
 
     Attributes:
-        omegas (torch.Tensor): driving strength Ωⱼ for each qubit, scaled by a factor 1/2.
-        deltas (torch.Tensor): detuning values Δⱼ for each qubit.
-        phis (torch.Tensor): phase values ϕⱼ for each qubit.
-        interaction_matrix (torch.Tensor): matrix Uᵢⱼ representing pairwise Rydberg
-            interaction strengths between qubits.
+        omegas (torch.Tensor): vector of Rabi frequencies Ωⱼ / 2 for each qubit.
+        deltas (torch.Tensor): vector of detunings Δⱼ for each qubit.
+        phis (torch.Tensor): vector of phases ϕⱼ for each qubit.
+        interaction_matrix (torch.Tensor): matrix Uᵢⱼ for pairwise interactions.
+        device (torch.device): device on which all tensors are allocated.
+        diag (torch.Tensor): diagonal contribution to the Hamiltonian (detuning + interactions).
+        inds (torch.Tensor): index mapping for σˣ operations.
         nqubits (int): number of qubits in the system.
-        diag (torch.Tensor): diagonal elements of the Hamiltonian,
-            calculated based on `deltas` and `interaction_matrix`.
-        inds (torch.Tensor): index tensor used for vector manipulations
-            in matrix-vector multiplications.
 
     Methods:
-        __mul__(vec): implements matrix-vector multiplication with a state vector.
-        _create_diagonal(): constructs the diagonal elements of the Hamiltonian
-            based on `deltas` and `interaction_matrix`.
-        _apply_sigma_operators_complex(): apply all driving sigma operators,
-             with driving strenght `omegas` and phases `phis`.
-        _apply_sigma_operators_real(): only applies ∑ⱼ(Ωⱼ/2)σˣⱼ when all phases are zero (ϕⱼ=0).
+        __mul__(vec): Applies the Hamiltonian H to a state vector |ψ⟩.
+        _apply_sigma_operators_real(): Applies only σˣ terms (ϕⱼ = 0).
+        _apply_sigma_operators_complex(): Applies generalized σˣ/σʸ terms (ϕⱼ ≠ 0).
+        _create_diagonal(): Computes the diagonal part of H from Δⱼ and Uᵢⱼ.
+        expect(state): Computes ⟨ψ|H|ψ⟩ for a given StateVector.
     """
 
     def __init__(
@@ -107,7 +109,7 @@ class RydbergHamiltonian:
         Returns:
             the resulting state vector.
         """
-        c_omegas = self.omegas * torch.exp(1j * self.phis)
+        c_omegas = self.omegas * torch.exp(1.0j * self.phis)
 
         dim_to_act = 1
         for n, c_omega_n in enumerate(c_omegas):

emu_sv/lindblad_operator.py

@@ -0,0 +1,188 @@
+import torch
+from emu_base.jump_lindblad_operators import compute_noise_from_lindbladians
+
+
+dtype = torch.complex128
+sigmax = torch.tensor([[0.0, 1.0], [1.0, 0.0]], dtype=dtype)
+sigmay = torch.tensor([[0.0, -1.0j], [1.0j, 0.0]], dtype=dtype)
+n_op = torch.tensor([[0.0, 0.0], [0.0, 1.0]], dtype=dtype)
+
+
+class RydbergLindbladian:
+    """
+    Apply the Lindblad superoperator ℒ to a density matrix 𝜌,  ℒ(𝜌).
+
+    This class implements
+    H @𝜌- H @ 𝜌 + i ∑ₖ − 1/2 Aₖ† Aₖ 𝜌 − 1/2 𝜌 Aₖ^† Aₖ + Aₖ 𝜌 Aₖ^†,
+    where A_k is a jump operator and H is the Rydberg Hamiltonian.
+    The complex -𝑖, will be multiplied in the evolution.
+
+    Attributes:
+        nqubits (int): number of qubits in the system.
+        omegas (torch.Tensor): amplited frequencies  Ωⱼ for each qubit, divided by 2.
+        deltas (torch.Tensor): detunings 𝛿ᵢ for each qubit.
+        phis (torch.Tensor): phases 𝜙ᵢ for each qubit.
+        interaction_matrix (torch.Tensor): interaction_matrix (torch.Tensor): matrix Uᵢⱼ
+            representing pairwise Rydberg interaction strengths between qubits.
+        pulser_linblads (list[torch.Tensor]): List of 2x2 local Lindblad (jump)
+            operators acting on each qubit.
+        device (torch.device): device on which tensors are allocated. cpu or gpu: cuda.
+        complex (bool): flag indicating whether any drive phase is nonzero
+            (i.e., complex Hamiltonian terms).
+        diag (torch.Tensor): precomputed diagonal interaction term for the density matrix evolution.
+
+    Methods:
+        apply_local_op_to_density_matrix(density_matrix, local_op, target_qubit):
+            Applies a local operator to the density matrix from the left: L @ ρ.
+
+        apply_density_matrix_to_local_op_T(density_matrix, local_op, target_qubit):
+            Applies a daggered local operator to the density matrix from the right: ρ @ L†.
+
+        __matmul__(density_matrix):
+            Applies the full Lindbladian superoperator to the input density matrix,
+            including coherent evolution and all dissipation channels.
+    """
+
+    def __init__(
+        self,
+        omegas: torch.Tensor,
+        deltas: torch.Tensor,
+        phis: torch.Tensor,
+        pulser_linblads: list[torch.Tensor],
+        interaction_matrix: torch.Tensor,
+        device: torch.device,
+    ):
+        self.nqubits: int = len(omegas)
+        self.omegas: torch.Tensor = omegas / 2.0
+        self.deltas: torch.Tensor = deltas
+        self.phis: torch.Tensor = phis
+        self.interaction_matrix: torch.Tensor = interaction_matrix
+        self.pulser_linblads: list[torch.Tensor] = pulser_linblads
+        self.device: torch.device = device
+        self.complex = self.phis.any()
+
+        self.diag: torch.Tensor = self._create_diagonal()
+
+    def _create_diagonal(self) -> torch.Tensor:
+        """
+        Return the diagonal elements of the Rydberg Hamiltonian matrix
+        concerning only the interaction
+
+            H.diag =  ∑ᵢ﹥ⱼUᵢⱼnᵢnⱼ
+        """
+        diag = torch.zeros(2**self.nqubits, dtype=dtype, device=self.device)
+
+        for i in range(self.nqubits):
+            diag = diag.view(2**i, 2, -1)
+            i_fixed = diag[:, 1, :]
+            for j in range(i + 1, self.nqubits):
+                i_fixed = i_fixed.view(2**i, 2 ** (j - i - 1), 2, -1)
+                # replacing i_j_fixed by i_fixed breaks the code :)
+                i_j_fixed = i_fixed[:, :, 1, :]
+                i_j_fixed += self.interaction_matrix[i, j]
+        return diag.view(-1)
+
+    def apply_local_op_to_density_matrix(
+        self,
+        density_matrix: torch.Tensor,
+        local_op: torch.Tensor,
+        target_qubit: int,
+    ) -> torch.Tensor:
+        """
+        Calculate a local operator (2x2) L being multiplied by a density matrix ρ
+        from the left
+        Return L @ ρ
+        """
+
+        orignal_shape = density_matrix.shape
+        density_matrix = density_matrix.view(2**target_qubit, 2, -1)
+        density_matrix = local_op @ density_matrix
+
+        return density_matrix.view(orignal_shape)
+
+    def apply_density_matrix_to_local_op_T(
+        self,
+        density_matrix: torch.Tensor,
+        local_op: torch.Tensor,
+        target_qubit: int,
+    ) -> torch.Tensor:
+        """
+        Calculates a density matrix ρ being multiplied by a daggered local (2x2)
+          operator L† from the right,
+
+        return:  ρ @L†
+        """
+
+        orignal_shape = density_matrix.shape
+
+        density_matrix = density_matrix.view(2 ** (target_qubit + self.nqubits), 2, -1)
+        density_matrix = local_op.conj() @ density_matrix
+
+        return density_matrix.view(orignal_shape)
+
+    def __matmul__(self, density_matrix: torch.Tensor) -> torch.Tensor:
+        """Apply the i*RydbergLindbladian operator to the density matrix ρ
+        in the following way:
+        Define and effective Hamiltonian
+        Heff = Hρ  -0.5i ∑ₖ Lₖ† Lₖ ρ
+        Then, the Lindblad operator applying to ρ is giving by
+         ℒ(𝜌) = Heff - Heff^†+i*∑ₖ Lₖ ρ Lₖ†
+        """
+
+        # compute -0.5i ∑ₖ Lₖ† Lₖ
+        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 - Heff^†=  [H, ρ] - 0.5i ∑ₖ Lₖ† Lₖρ - ρ 0.5i ∑ₖ Lₖ† Lₖρ
+        H_den_matrix = H_den_matrix - H_den_matrix.conj().T
+
+        # compute ∑ₖ Lₖ ρ Lₖ†, last part of the Lindblad operator
+        L_den_matrix_Ldag = sum(
+            self.apply_density_matrix_to_local_op_T(
+                self.apply_local_op_to_density_matrix(
+                    density_matrix, L.to(self.device), qubit
+                ),
+                L.to(self.device),
+                qubit,
+            )
+            for qubit in range(self.nqubits)
+            for L in self.pulser_linblads
+        )
+
+        return H_den_matrix + 1.0j * L_den_matrix_Ldag

emu_sv/time_evolution.py

@@ -21,6 +21,7 @@ def do_time_step(
         device=state_vector.device,
     )
     op = lambda x: -1j * dt * (ham * x)
+
     return (
         krylov_exp(
             op,

{emu_sv-2.0.3.dist-info → emu_sv-2.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emu-sv
-Version: 2.0.3
+Version: 2.0.4
 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.0.3
+Requires-Dist: emu-base==2.0.4
 Description-Content-Type: text/markdown
 
 <div align="center">

{emu_sv-2.0.3.dist-info → emu_sv-2.0.4.dist-info}/RECORD

@@ -1,13 +1,14 @@
-emu_sv/__init__.py,sha256=6ijDylrpDM3KZkI1hvmsh_uUAOKowLmjvxaE7wrAmOY,701
+emu_sv/__init__.py,sha256=Tzc6RlABZ1ZVKt1mPUes9djq0eiK6FTgPagEHuFhF6Q,702
 emu_sv/custom_callback_implementations.py,sha256=zvsSiDIc56gwybKq87VFZyKsniTDye6-oFd2-R0shpg,3447
 emu_sv/dense_operator.py,sha256=NfgzVpnNitc5ZSM4RlfpAc5Ls2wFPNsTxdeFdhJSg1o,6909
 emu_sv/density_matrix_state.py,sha256=6UBLUXaJaUdzOhflrKolcnH8737JszX7sry1WmbyakI,6993
-emu_sv/hamiltonian.py,sha256=veJlJh_Q2_Fgc0IIfKPSWb6n_oem5WWGQUGDeepl924,6138
+emu_sv/hamiltonian.py,sha256=CqNGuWJlO2ZljK47wt130s-5uKiOldQUsC3tjwk1mKA,6106
+emu_sv/lindblad_operator.py,sha256=KmaNCahpAi8SIXh-TrFD-ggmGpa1zklp8DMWVK9Y_J4,7433
 emu_sv/state_vector.py,sha256=lqSbv4BMtDtgY0YUPuhIUNJxrlVa7vUWuN_XqwpG5sQ,9823
 emu_sv/sv_backend.py,sha256=AkEtI6-SY20D0ORro3Kv8tHDRUc8gxejSiRa6d--vBE,4452
 emu_sv/sv_config.py,sha256=QRy0VbCugmY6TQZ48nD6RxPJbpu0wzN7-E1Sud7YxLQ,5106
-emu_sv/time_evolution.py,sha256=48C0DL_SOu7Jdjk2QKBNPsevOpQlgsPYUHE7cScY-ZM,796
+emu_sv/time_evolution.py,sha256=obV7DcHot0jtnEmjR1ilYiSyDcJ5rTvThRB8hFjP-2s,797
 emu_sv/utils.py,sha256=-axfQ2tqw0C7I9yw-28g7lytyk373DNBjDALh4kLBrM,302
-emu_sv-2.0.3.dist-info/METADATA,sha256=BYetdN_TW7rMls-VeLMSObauvcKONqh8an0FZqouJfw,3513
-emu_sv-2.0.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-emu_sv-2.0.3.dist-info/RECORD,,
+emu_sv-2.0.4.dist-info/METADATA,sha256=paHoVgW22OONoxvlwaypB-UF01zi0giZqUtvAz7fhmw,3513
+emu_sv-2.0.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emu_sv-2.0.4.dist-info/RECORD,,