tnfr 4.5.2__py3-none-any.whl → 8.5.0__py3-none-any.whl

tnfr/mathematics/epi.py

@@ -0,0 +1,391 @@
+"""EPI elements and algebraic helpers for the TNFR Banach space."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Callable, Mapping, Sequence
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from .spaces import BanachSpaceEPI
+
+__all__ = [
+    "BEPIElement",
+    "CoherenceEvaluation",
+    "evaluate_coherence_transform",
+]
+
+
+class _EPIValidators:
+    """Shared validation helpers for EPI Banach constructions."""
+
+    _complex_dtype = np.complex128
+
+    @staticmethod
+    def _as_array(
+        values: Sequence[complex] | np.ndarray, *, dtype: np.dtype
+    ) -> np.ndarray:
+        array = np.asarray(values, dtype=dtype)
+        if array.ndim != 1:
+            raise ValueError("Inputs must be one-dimensional arrays.")
+        if not np.all(np.isfinite(array)):
+            raise ValueError("Inputs must not contain NaNs or infinities.")
+        return array
+
+    @classmethod
+    def _validate_grid(
+        cls, grid: Sequence[float] | np.ndarray, expected_size: int
+    ) -> np.ndarray:
+        array = np.asarray(grid, dtype=float)
+        if array.ndim != 1:
+            raise ValueError("x_grid must be one-dimensional.")
+        if array.size != expected_size:
+            raise ValueError("x_grid length must match continuous component.")
+        if array.size < 2:
+            raise ValueError("x_grid must contain at least two points.")
+        if not np.all(np.isfinite(array)):
+            raise ValueError("x_grid must not contain NaNs or infinities.")
+
+        spacings = np.diff(array)
+        if np.any(spacings <= 0):
+            raise ValueError("x_grid must be strictly increasing.")
+        if not np.allclose(spacings, spacings[0], rtol=1e-9, atol=1e-12):
+            raise ValueError("x_grid must be uniform for finite-difference stability.")
+        return array
+
+    @classmethod
+    def validate_domain(
+        cls,
+        f_continuous: Sequence[complex] | np.ndarray,
+        a_discrete: Sequence[complex] | np.ndarray,
+        x_grid: Sequence[float] | np.ndarray | None = None,
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray | None]:
+        """Validate dimensionality and sampling grid compatibility."""
+
+        f_array = cls._as_array(f_continuous, dtype=cls._complex_dtype)
+        a_array = cls._as_array(a_discrete, dtype=cls._complex_dtype)
+
+        if x_grid is None:
+            return f_array, a_array, None
+
+        grid_array = cls._validate_grid(x_grid, f_array.size)
+        return f_array, a_array, grid_array
+
+
+@dataclass(frozen=True)
+class BEPIElement(_EPIValidators):
+    r"""Concrete :math:`C^0([0,1]) \oplus \ell^2` element with TNFR operations."""
+
+    f_continuous: Sequence[complex] | np.ndarray
+    a_discrete: Sequence[complex] | np.ndarray
+    x_grid: Sequence[float] | np.ndarray
+
+    def __post_init__(self) -> None:
+        f_array, a_array, grid = self.validate_domain(
+            self.f_continuous, self.a_discrete, self.x_grid
+        )
+        if grid is None:
+            raise ValueError("x_grid is mandatory for BEPIElement instances.")
+        object.__setattr__(self, "f_continuous", f_array)
+        object.__setattr__(self, "a_discrete", a_array)
+        object.__setattr__(self, "x_grid", grid)
+
+    def _assert_compatible(self, other: BEPIElement) -> None:
+        if self.f_continuous.shape != other.f_continuous.shape:
+            raise ValueError("Continuous components must share shape for direct sums.")
+        if self.a_discrete.shape != other.a_discrete.shape:
+            raise ValueError("Discrete tails must share shape for direct sums.")
+        if not np.allclose(self.x_grid, other.x_grid, rtol=1e-12, atol=1e-12):
+            raise ValueError("x_grid must match to combine EPI elements.")
+
+    def direct_sum(self, other: BEPIElement) -> BEPIElement:
+        """Return the algebraic direct sum ``self ⊕ other``."""
+
+        self._assert_compatible(other)
+        return BEPIElement(
+            self.f_continuous + other.f_continuous,
+            self.a_discrete + other.a_discrete,
+            self.x_grid,
+        )
+
+    def tensor(self, vector: Sequence[complex] | np.ndarray) -> np.ndarray:
+        """Return the tensor product between the discrete tail and a Hilbert vector."""
+
+        hilbert_vector = self._as_array(vector, dtype=self._complex_dtype)
+        return np.outer(self.a_discrete, hilbert_vector)
+
+    def adjoint(self) -> BEPIElement:
+        """Return the conjugate element representing the ``*`` operation."""
+
+        return BEPIElement(
+            np.conjugate(self.f_continuous), np.conjugate(self.a_discrete), self.x_grid
+        )
+
+    @staticmethod
+    def _apply_transform(
+        transform: Callable[[np.ndarray], np.ndarray], values: np.ndarray
+    ) -> np.ndarray:
+        result = np.asarray(transform(values), dtype=np.complex128)
+        if result.shape != values.shape:
+            raise ValueError("Transforms must preserve the element shape.")
+        if not np.all(np.isfinite(result)):
+            raise ValueError("Transforms must return finite values.")
+        return result
+
+    def compose(
+        self,
+        transform: Callable[[np.ndarray], np.ndarray],
+        *,
+        spectral_transform: Callable[[np.ndarray], np.ndarray] | None = None,
+    ) -> BEPIElement:
+        """Compose the element with linear transforms on both components."""
+
+        new_f = self._apply_transform(transform, self.f_continuous)
+        spectral_fn = spectral_transform or transform
+        new_a = self._apply_transform(spectral_fn, self.a_discrete)
+        return BEPIElement(new_f, new_a, self.x_grid)
+
+    def _max_magnitude(self) -> float:
+        mags = []
+        if self.f_continuous.size:
+            mags.append(float(np.max(np.abs(self.f_continuous))))
+        if self.a_discrete.size:
+            mags.append(float(np.max(np.abs(self.a_discrete))))
+        return float(max(mags)) if mags else 0.0
+
+    def __float__(self) -> float:
+        return self._max_magnitude()
+
+    def __abs__(self) -> float:
+        return self._max_magnitude()
+
+    def __getstate__(self) -> dict[str, tuple[complex, ...] | tuple[float, ...]]:
+        """Serialize BEPIElement to a JSON-compatible dict with real/imag pairs.
+
+        This method enables pickle, JSON, and YAML serialization while preserving
+        TNFR invariant #1 (EPI as coherent form) and #7 (operational fractality).
+        """
+        # Convert numpy arrays to lists for serialization
+        continuous = self.f_continuous.tolist()
+        discrete = self.a_discrete.tolist()
+        grid = self.x_grid.tolist()
+
+        return {
+            "continuous": tuple(continuous),
+            "discrete": tuple(discrete),
+            "grid": tuple(grid),
+        }
+
+    def __setstate__(
+        self, state: dict[str, tuple[complex, ...] | tuple[float, ...]]
+    ) -> None:
+        """Deserialize BEPIElement from a dict representation.
+
+        Restores the structural integrity by validating and converting back to numpy arrays.
+        """
+        f_array, a_array, grid = self.validate_domain(
+            state["continuous"], state["discrete"], state["grid"]
+        )
+        if grid is None:
+            raise ValueError("x_grid is mandatory for BEPIElement instances.")
+        object.__setattr__(self, "f_continuous", f_array)
+        object.__setattr__(self, "a_discrete", a_array)
+        object.__setattr__(self, "x_grid", grid)
+
+    def __add__(self, other: BEPIElement | float | int) -> BEPIElement:
+        """Add a scalar or another BEPIElement to this element."""
+        if isinstance(other, (int, float)):
+            # Scalar addition: broadcast to all components
+            scalar = complex(other)
+            return BEPIElement(
+                self.f_continuous + scalar, self.a_discrete + scalar, self.x_grid
+            )
+        elif isinstance(other, BEPIElement):
+            # Element addition: use direct_sum
+            return self.direct_sum(other)
+        return NotImplemented
+
+    def __radd__(self, other: float | int) -> BEPIElement:
+        """Support reversed addition (scalar + BEPIElement)."""
+        return self.__add__(other)
+
+    def __sub__(self, other: BEPIElement | float | int) -> BEPIElement:
+        """Subtract a scalar or another BEPIElement from this element."""
+        if isinstance(other, (int, float)):
+            scalar = complex(other)
+            return BEPIElement(
+                self.f_continuous - scalar, self.a_discrete - scalar, self.x_grid
+            )
+        elif isinstance(other, BEPIElement):
+            self._assert_compatible(other)
+            return BEPIElement(
+                self.f_continuous - other.f_continuous,
+                self.a_discrete - other.a_discrete,
+                self.x_grid,
+            )
+        return NotImplemented
+
+    def __rsub__(self, other: float | int) -> BEPIElement:
+        """Support reversed subtraction (scalar - BEPIElement)."""
+        if isinstance(other, (int, float)):
+            scalar = complex(other)
+            return BEPIElement(
+                scalar - self.f_continuous, scalar - self.a_discrete, self.x_grid
+            )
+        return NotImplemented
+
+    def __mul__(self, other: float | int) -> BEPIElement:
+        """Multiply this element by a scalar."""
+        if isinstance(other, (int, float)):
+            scalar = complex(other)
+            return BEPIElement(
+                self.f_continuous * scalar, self.a_discrete * scalar, self.x_grid
+            )
+        return NotImplemented
+
+    def __rmul__(self, other: float | int) -> BEPIElement:
+        """Support reversed multiplication (scalar * BEPIElement)."""
+        return self.__mul__(other)
+
+    def __truediv__(self, other: float | int) -> BEPIElement:
+        """Divide this element by a scalar."""
+        if isinstance(other, (int, float)):
+            scalar = complex(other)
+            if scalar == 0:
+                raise ZeroDivisionError("Cannot divide BEPIElement by zero")
+            return BEPIElement(
+                self.f_continuous / scalar, self.a_discrete / scalar, self.x_grid
+            )
+        return NotImplemented
+
+    def __eq__(self, other: object) -> bool:
+        """Check equality with another BEPIElement or numeric value.
+
+        When comparing to a numeric value, compares with the maximum magnitude.
+        """
+        if isinstance(other, BEPIElement):
+            return (
+                np.allclose(
+                    self.f_continuous, other.f_continuous, rtol=1e-12, atol=1e-12
+                )
+                and np.allclose(
+                    self.a_discrete, other.a_discrete, rtol=1e-12, atol=1e-12
+                )
+                and np.allclose(self.x_grid, other.x_grid, rtol=1e-12, atol=1e-12)
+            )
+        elif isinstance(other, (int, float)):
+            # Compare with maximum magnitude for numeric comparisons
+            # Use consistent tolerance with element comparisons
+            return abs(self._max_magnitude() - float(other)) < 1e-12
+        return NotImplemented
+
+
+@dataclass(frozen=True)
+class CoherenceEvaluation:
+    """Container describing the outcome of a coherence transform evaluation."""
+
+    element: BEPIElement
+    transformed: BEPIElement
+    coherence_before: float
+    coherence_after: float
+    kappa: float
+    tolerance: float
+    satisfied: bool
+    required: float
+    deficit: float
+    ratio: float
+
+
+def evaluate_coherence_transform(
+    element: BEPIElement,
+    transform: Callable[[BEPIElement], BEPIElement],
+    *,
+    kappa: float = 1.0,
+    tolerance: float = 1e-9,
+    space: "BanachSpaceEPI" | None = None,
+    norm_kwargs: Mapping[str, float] | None = None,
+) -> CoherenceEvaluation:
+    """Apply ``transform`` to ``element`` and verify a coherence inequality.
+
+    Parameters
+    ----------
+    element:
+        The :class:`BEPIElement` subject to the transformation.
+    transform:
+        Callable receiving ``element`` and returning the transformed
+        :class:`BEPIElement`.  The callable is expected to preserve the
+        structural sampling grid and dimensionality of the element.
+    kappa:
+        Factor on the right-hand side of the inequality ``C(T(EPI)) ≥ κ·C(EPI)``.
+    tolerance:
+        Non-negative slack applied to the inequality.  When
+        ``C(T(EPI)) + tolerance`` exceeds ``κ·C(EPI)`` the check succeeds.
+    space:
+        Optional :class:`~tnfr.mathematics.spaces.BanachSpaceEPI` instance used
+        to compute the coherence norm.  When omitted, a local instance is
+        constructed to avoid circular imports at module import time.
+    norm_kwargs:
+        Optional keyword arguments forwarded to
+        :meth:`BanachSpaceEPI.coherence_norm`.
+
+    Returns
+    -------
+    CoherenceEvaluation
+        Dataclass capturing the before/after coherence values together with the
+        inequality verdict.
+    """
+
+    if kappa < 0:
+        raise ValueError("kappa must be non-negative.")
+    if tolerance < 0:
+        raise ValueError("tolerance must be non-negative.")
+
+    if norm_kwargs is None:
+        norm_kwargs = {}
+
+    from .spaces import BanachSpaceEPI  # Local import to avoid circular dependency
+
+    working_space = space if space is not None else BanachSpaceEPI()
+
+    coherence_before = working_space.coherence_norm(
+        element.f_continuous,
+        element.a_discrete,
+        x_grid=element.x_grid,
+        **norm_kwargs,
+    )
+
+    transformed = transform(element)
+    if not isinstance(transformed, BEPIElement):
+        raise TypeError("transform must return a BEPIElement instance.")
+
+    coherence_after = working_space.coherence_norm(
+        transformed.f_continuous,
+        transformed.a_discrete,
+        x_grid=transformed.x_grid,
+        **norm_kwargs,
+    )
+
+    required = kappa * coherence_before
+    satisfied = coherence_after + tolerance >= required
+    deficit = max(0.0, required - coherence_after)
+
+    if coherence_before > 0:
+        ratio = coherence_after / coherence_before
+    elif coherence_after > tolerance:
+        ratio = float("inf")
+    else:
+        ratio = 1.0
+
+    return CoherenceEvaluation(
+        element=element,
+        transformed=transformed,
+        coherence_before=coherence_before,
+        coherence_after=coherence_after,
+        kappa=kappa,
+        tolerance=tolerance,
+        satisfied=satisfied,
+        required=required,
+        deficit=deficit,
+        ratio=ratio,
+    )

tnfr/mathematics/epi.pyi

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import numpy as np
+from dataclasses import dataclass
+from typing import Callable, Mapping, Sequence
+
+__all__ = ["BEPIElement", "CoherenceEvaluation", "evaluate_coherence_transform"]
+
+class _EPIValidators:
+    @classmethod
+    def validate_domain(
+        cls,
+        f_continuous: Sequence[complex] | np.ndarray,
+        a_discrete: Sequence[complex] | np.ndarray,
+        x_grid: Sequence[float] | np.ndarray | None = None,
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray | None]: ...
+
+@dataclass(frozen=True)
+class BEPIElement(_EPIValidators):
+    f_continuous: Sequence[complex] | np.ndarray
+    a_discrete: Sequence[complex] | np.ndarray
+    x_grid: Sequence[float] | np.ndarray
+    def __post_init__(self) -> None: ...
+    def direct_sum(self, other: BEPIElement) -> BEPIElement: ...
+    def tensor(self, vector: Sequence[complex] | np.ndarray) -> np.ndarray: ...
+    def adjoint(self) -> BEPIElement: ...
+    def compose(
+        self,
+        transform: Callable[[np.ndarray], np.ndarray],
+        *,
+        spectral_transform: Callable[[np.ndarray], np.ndarray] | None = None,
+    ) -> BEPIElement: ...
+    def __float__(self) -> float: ...
+    def __abs__(self) -> float: ...
+    def __add__(self, other: BEPIElement | float | int) -> BEPIElement: ...
+    def __radd__(self, other: float | int) -> BEPIElement: ...
+    def __sub__(self, other: BEPIElement | float | int) -> BEPIElement: ...
+    def __rsub__(self, other: float | int) -> BEPIElement: ...
+    def __mul__(self, other: float | int) -> BEPIElement: ...
+    def __rmul__(self, other: float | int) -> BEPIElement: ...
+    def __truediv__(self, other: float | int) -> BEPIElement: ...
+    def __eq__(self, other: object) -> bool: ...
+
+@dataclass(frozen=True)
+class CoherenceEvaluation:
+    element: BEPIElement
+    transformed: BEPIElement
+    coherence_before: float
+    coherence_after: float
+    kappa: float
+    tolerance: float
+    satisfied: bool
+    required: float
+    deficit: float
+    ratio: float
+
+def evaluate_coherence_transform(
+    element: BEPIElement,
+    transform: Callable[[BEPIElement], BEPIElement],
+    *,
+    kappa: float = 1.0,
+    tolerance: float = 1e-09,
+    space: BanachSpaceEPI | None = None,
+    norm_kwargs: Mapping[str, float] | None = None,
+) -> CoherenceEvaluation: ...

tnfr/mathematics/generators.py

@@ -0,0 +1,242 @@
+"""ΔNFR generator construction utilities."""
+
+from __future__ import annotations
+
+from typing import Final, Sequence
+
+import numpy as np
+from numpy.random import Generator
+
+from .backend import ensure_array, ensure_numpy, get_backend
+
+__all__ = ["build_delta_nfr", "build_lindblad_delta_nfr"]
+
+_TOPOLOGIES: Final[set[str]] = {"laplacian", "adjacency"}
+
+
+def _ring_adjacency(dim: int) -> np.ndarray:
+    """Return the adjacency matrix for a coherent ring topology."""
+
+    adjacency: np.ndarray = np.zeros((dim, dim), dtype=float)
+    if dim == 1:
+        return adjacency
+
+    indices = np.arange(dim)
+    adjacency[indices, (indices + 1) % dim] = 1.0
+    adjacency[(indices + 1) % dim, indices] = 1.0
+    return adjacency
+
+
+def _laplacian_from_adjacency(adjacency: np.ndarray) -> np.ndarray:
+    """Construct a Laplacian operator from an adjacency matrix."""
+
+    degrees = adjacency.sum(axis=1)
+    laplacian = np.diag(degrees) - adjacency
+    return laplacian
+
+
+def _hermitian_noise(dim: int, rng: Generator) -> np.ndarray:
+    """Generate a Hermitian noise matrix with reproducible statistics."""
+
+    real = rng.standard_normal((dim, dim))
+    imag = rng.standard_normal((dim, dim))
+    noise = real + 1j * imag
+    return 0.5 * (noise + noise.conj().T)
+
+
+def _as_square_matrix(
+    matrix: Sequence[Sequence[complex]] | np.ndarray,
+    *,
+    expected_dim: int | None = None,
+    label: str = "matrix",
+) -> np.ndarray:
+    """Return ``matrix`` as a square :class:`numpy.ndarray` with validation."""
+
+    array = np.asarray(matrix, dtype=np.complex128)
+    if array.ndim != 2 or array.shape[0] != array.shape[1]:
+        raise ValueError(f"{label} must be a square matrix.")
+    if expected_dim is not None and array.shape[0] != expected_dim:
+        raise ValueError(
+            f"{label} dimension mismatch: expected {expected_dim}, received {array.shape[0]}."
+        )
+    return array
+
+
+def build_delta_nfr(
+    dim: int,
+    *,
+    topology: str = "laplacian",
+    nu_f: float = 1.0,
+    scale: float = 1.0,
+    rng: Generator | None = None,
+) -> np.ndarray:
+    """Construct a Hermitian ΔNFR generator using canonical TNFR topologies.
+
+    Parameters
+    ----------
+    dim:
+        Dimensionality of the Hilbert space supporting the ΔNFR operator.
+    topology:
+        Requested canonical topology. Supported values are ``"laplacian"``
+        and ``"adjacency"``.
+    nu_f:
+        Structural frequency scaling applied to the resulting operator.
+    scale:
+        Additional scaling applied uniformly to the operator amplitude.
+    rng:
+        Optional NumPy :class:`~numpy.random.Generator` used to inject
+        reproducible Hermitian noise.
+    """
+
+    if dim <= 0:
+        raise ValueError("ΔNFR generators require a positive dimensionality.")
+
+    if topology not in _TOPOLOGIES:
+        allowed = ", ".join(sorted(_TOPOLOGIES))
+        raise ValueError(
+            f"Unknown ΔNFR topology: {topology}. Expected one of: {allowed}."
+        )
+
+    adjacency = _ring_adjacency(dim)
+    if topology == "laplacian":
+        base = _laplacian_from_adjacency(adjacency)
+    else:
+        base = adjacency
+
+    matrix: np.ndarray = base.astype(np.complex128, copy=False)
+
+    if rng is not None:
+        noise = _hermitian_noise(dim, rng)
+        matrix = matrix + (1.0 / np.sqrt(dim)) * noise
+
+    matrix *= nu_f * scale
+    hermitian = 0.5 * (matrix + matrix.conj().T)
+    backend = get_backend()
+    return np.asarray(
+        ensure_numpy(ensure_array(hermitian, backend=backend), backend=backend),
+        dtype=np.complex128,
+    )
+
+
+def build_lindblad_delta_nfr(
+    *,
+    hamiltonian: Sequence[Sequence[complex]] | np.ndarray | None = None,
+    collapse_operators: (
+        Sequence[Sequence[Sequence[complex]] | np.ndarray] | None
+    ) = None,
+    dim: int | None = None,
+    nu_f: float = 1.0,
+    scale: float = 1.0,
+    ensure_trace_preserving: bool = True,
+    ensure_contractive: bool = True,
+    atol: float = 1e-9,
+) -> np.ndarray:
+    """Construct a Lindblad ΔNFR generator in Liouville space.
+
+    The resulting matrix acts on vectorised density operators using the
+    canonical column-major flattening.  The construction follows the standard
+    Gorini–Kossakowski–Sudarshan–Lindblad prescription while exposing TNFR
+    semantics through ``ν_f`` and ``scale``.
+
+    Parameters
+    ----------
+    hamiltonian:
+        Optional coherent component.  When ``None`` a null Hamiltonian is
+        assumed.
+    collapse_operators:
+        Iterable with the dissipative operators driving the contractive
+        semigroup.  Each entry must be square with the same dimension as the
+        Hamiltonian.  When ``None`` the generator reduces to the coherent part.
+    dim:
+        Explicit Hilbert-space dimension.  Only required if neither
+        ``hamiltonian`` nor ``collapse_operators`` are provided.  When supplied,
+        it must match the dimension inferred from the Hamiltonian and collapse
+        operators.
+    nu_f, scale:
+        Structural frequency scaling applied uniformly to the final generator.
+    ensure_trace_preserving:
+        When ``True`` (default) the resulting superoperator is validated to
+        leave the identity invariant.
+    ensure_contractive:
+        When ``True`` (default) the spectrum is required to have non-positive
+        real parts within ``atol``.
+    atol:
+        Absolute tolerance used for Hermiticity, trace and spectral checks.
+    """
+
+    operators = list(collapse_operators or [])
+
+    inferred_dim: int | None = dim
+    if hamiltonian is not None:
+        hermitian = _as_square_matrix(hamiltonian, label="hamiltonian")
+        inferred_dim = hermitian.shape[0]
+    elif operators:
+        inferred_dim = _as_square_matrix(
+            operators[0], label="collapse operator[0]"
+        ).shape[0]
+
+    if inferred_dim is None:
+        raise ValueError("dim must be supplied when no operators are provided.")
+
+    if inferred_dim <= 0:
+        raise ValueError("ΔNFR generators require a positive dimension.")
+
+    dimension = inferred_dim
+
+    if dim is not None and dim != dimension:
+        raise ValueError(
+            "Provided dim is inconsistent with the supplied operators: "
+            f"expected {dimension}, received {dim}."
+        )
+
+    if hamiltonian is None:
+        hermitian = np.zeros((dimension, dimension), dtype=np.complex128)
+    else:
+        hermitian = _as_square_matrix(
+            hamiltonian, expected_dim=dimension, label="hamiltonian"
+        )
+        if not np.allclose(hermitian, hermitian.conj().T, atol=atol):
+            raise ValueError(
+                "Hamiltonian component must be Hermitian within tolerance."
+            )
+
+    dissipators = [
+        _as_square_matrix(
+            operator, expected_dim=dimension, label=f"collapse operator[{index}]"
+        )
+        for index, operator in enumerate(operators)
+    ]
+
+    identity = np.eye(dimension, dtype=np.complex128)
+    liouvillian = -1j * (np.kron(identity, hermitian) - np.kron(hermitian.T, identity))
+
+    for operator in dissipators:
+        adjoint_product = operator.conj().T @ operator
+        liouvillian += np.kron(operator.conj(), operator)
+        liouvillian -= 0.5 * np.kron(identity, adjoint_product)
+        liouvillian -= 0.5 * np.kron(adjoint_product.T, identity)
+
+    liouvillian *= nu_f * scale
+
+    if ensure_trace_preserving:
+        identity_vec = identity.reshape(dimension * dimension, order="F")
+        left_residual = identity_vec.conj().T @ liouvillian
+        if not np.allclose(left_residual, np.zeros_like(left_residual), atol=10 * atol):
+            raise ValueError(
+                "Lindblad generator must preserve the trace of density operators."
+            )
+
+    backend = get_backend()
+    liouvillian_backend = ensure_array(liouvillian, backend=backend)
+
+    if ensure_contractive:
+        eigenvalues_backend, _ = backend.eig(liouvillian_backend)
+        eigenvalues = ensure_numpy(eigenvalues_backend, backend=backend)
+        if np.max(eigenvalues.real) > atol:
+            raise ValueError(
+                "Lindblad generator is not contractive: spectrum has positive real components."
+            )
+
+    return np.asarray(
+        ensure_numpy(liouvillian_backend, backend=backend), dtype=np.complex128
+    )