Add entanglement entropy operator

[HaroldErbin]

The entanglement entropy obtained by tracing the partition function over a set of sites is a natural operator to compute. Would it be possible to add it to pulser.backend ?

Here is the Qutip code I have been using:

def vn_entropy(state: Qobj, sites=None) -> float:
    """
    Compute von Neumann entropy by tracing over specified sites.

    By default, this traces over half of the spin sites.
    """

    state = state.unit()

    state.dims = cast(list, state.dims)
    L = len(state.dims[0])

    if sites is None:
        sites = list(range(L // 2))

    return qutip.entropy_vn(state.ptrace(sites))

entropy = np.array([vn_entropy(state) for state in results.states])

It would be great to have an equivalent that could be computed during the time evolution. Would you have a solution based on a callback or something else meanwhile?

[a-quelle-pasqal]

The following code gives an MWE for what you seem to want. You should be fine with copying the EntanglementEntropy class straight from it. You will find that I mostly just took your implementation and put it in the correct mold.

from typing import Any
import pulser
import qutip
import numpy as np
from pulser.backends import QutipBackendV2
from pulser_simulation import QutipConfig
from pulser.backend import StateResult, Observable, State

class EntanglementEntropy(Observable):
    def __init__(
        self,
        *,
        sites: list |  None = None,
        evaluation_times: pulser.Sequence[float] | None = None,
        tag_suffix: str | None = None,
    ):
        super().__init__(evaluation_times=evaluation_times, tag_suffix=tag_suffix)
        self.sites = sites

    @property
    def _base_tag(self) -> str:
        return "entanglement_entropy"

    def _to_abstract_repr(self) -> dict[str, Any]:
        raise NotImplementedError()

    def apply(self, *, state: State, **kwargs: Any) -> float:
        qobj = state._state.unit()
        L = len(qobj.dims[0])
        sites = self.sites or list(range(L // 2))
        return qutip.entropy_vn(qobj.ptrace(sites))
        

seq = pulser.Sequence(
    pulser.Register.square(2,5, prefix="q"), pulser.AnalogDevice
)
seq.declare_channel("rydberg_global", "rydberg_global")
seq.add(pulser.Pulse.ConstantPulse(1000, 1, 0, 0), "rydberg_global")
dt = 0.001
evaluation_times = np.linspace(0.0, 1.0, int(1 / dt + 1))
config = QutipConfig(
    observables=[
        EntanglementEntropy(evaluation_times=evaluation_times)
    ]
)
emu_backend = QutipBackendV2(seq, config=config)
result = emu_backend.run()

[HaroldErbin]

Amazing, thanks! This works like a charm.

Since this depends on Qutip, I guess that it will work only with QutipBackendV2, not emu-sv or emu-mps, right? Note that I don't need an implementation for those backends now since I am moving first from QutipBackend to QutipBackendV2, but at some point I wanted to upgrade further to those newer backends.

[HaroldErbin]

There is a minor typo for the types in __init__ arguments:
evaluation_times: pulser.Sequence[float]
should be
evaluation_times: typing.Sequence[float]

[AurelienNober]

reserving for QAT team hackathon