eft4py 0.0.2__tar.gz → 0.0.4__tar.gz

{eft4py-0.0.2 → eft4py-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: eft4py
-Version: 0.0.2
+Version: 0.0.4
 Summary: An Effective Field Theory toolbox for Python
 Author: Rodrigo Calderon
 Author-email: Rodrigo Calderon <calderon.cosmology@gmail.com>
@@ -11,12 +11,19 @@ Requires-Dist: pytest>=7.4 ; extra == 'dev'
 Requires-Dist: pytest-cov>=4.1 ; extra == 'dev'
 Requires-Dist: mypy>=1.10 ; extra == 'dev'
 Requires-Dist: ruff>=0.5 ; extra == 'dev'
+Requires-Dist: mkdocs-material>=9.5 ; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.26 ; extra == 'docs'
+Requires-Dist: mkdocs-marimo>=0.2.1 ; extra == 'docs'
+Requires-Dist: mkdocs-jupyter>=0.25 ; extra == 'docs'
 Requires-Dist: jax>=0.4.0 ; extra == 'jax'
 Requires-Dist: jaxlib>=0.4.0 ; extra == 'jax'
+Requires-Dist: diffrax>=0.5.0 ; extra == 'jax'
+Requires-Dist: optimistix>=0.0.10 ; extra == 'jax'
 Requires-Dist: matplotlib>=3.7 ; extra == 'notebooks'
 Requires-Dist: jupyter>=1.0 ; extra == 'notebooks'
 Requires-Python: >=3.12
 Provides-Extra: dev
+Provides-Extra: docs
 Provides-Extra: jax
 Provides-Extra: notebooks
 Description-Content-Type: text/markdown

{eft4py-0.0.2 → eft4py-0.0.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "eft4py"
-version = "0.0.2"
+version = "0.0.4"
 description = "An Effective Field Theory toolbox for Python"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -28,6 +28,14 @@ notebooks = [
 jax = [
     "jax>=0.4.0",
     "jaxlib>=0.4.0",
+    "diffrax>=0.5.0",
+    "optimistix>=0.0.10",
+]
+docs = [
+    "mkdocs-material>=9.5",
+    "mkdocstrings[python]>=0.26",
+    "mkdocs-marimo>=0.2.1",
+    "mkdocs-jupyter>=0.25",
 ]
 
 [project.scripts]

{eft4py-0.0.2 → eft4py-0.0.4}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "eft4py"
-version = "0.0.2"
+version = "0.0.4"
 description = "An Effective Field Theory toolbox for Python"
 readme = "README.md"
 authors = [
@@ -27,6 +27,14 @@ notebooks = [
 jax = [
     "jax>=0.4.0",
     "jaxlib>=0.4.0",
+    "diffrax>=0.5.0",
+    "optimistix>=0.0.10",
+]
+docs = [
+    "mkdocs-material>=9.5",
+    "mkdocstrings[python]>=0.26",
+    "mkdocs-marimo>=0.2.1",
+    "mkdocs-jupyter>=0.25",
 ]
 
 [project.scripts]

eft4py-0.0.4/src/eft4py/__init__.py

@@ -0,0 +1,94 @@
+r"""eft4py: Horndeski dark-energy backgrounds in Python, validated against hi_class.
+
+Define a scalar-tensor theory through its Lagrangian functions
+$G_2, G_3, G_4, G_5$ of $\phi$ and $X$, then evolve the cosmological
+background in conformal time $\tau$ following the hi_class conventions.
+
+The essentials are available at the top level:
+
+- [`HorndeskiModel`][eft4py.HorndeskiModel]: the theory.
+- [`Cosmology`][eft4py.Cosmology]: the fluid content ($h$, $\Omega_m$,
+  $\Omega_r$) the scalar field evolves in.
+- [`ScipyBackground`][eft4py.ScipyBackground] and
+  [`JaxBackground`][eft4py.JaxBackground]: background solutions from a model
+  and a cosmology (initial conditions, a solve on a grid in $\ln a$, and
+  shooting a coupling so that $H(a=1) = H_0$), with
+  [`frozen_field`][eft4py.frozen_field] for a field initially at rest.
+  `JaxBackground` needs the `jax` extra, imported only when it is created.
+- [`HorndeskiODE`][eft4py.HorndeskiODE]: the background equations, for
+  lower-level control.
+- [`HiClassState`][eft4py.HiClassState]: a background state (initial
+  conditions and solutions).
+- [`ScipySolver`][eft4py.ScipySolver] and, with the `jax` extra,
+  `JAXSolver`: integrators.
+- [`get_symbols`][eft4py.get_symbols] and
+  [`SymbolTable`][eft4py.SymbolTable]: the symbols $\phi$, $X$,
+  $M_{\rm pl}$ used to write models.
+- [`SingularSystemError`][eft4py.SingularSystemError]: raised when the
+  scalar's kinetic structure degenerates.
+
+Advanced functionality lives in the subpackages: `eft4py.physics` (symbolic
+and compiled coefficients, dark energy, $\alpha$-functions), `eft4py.models`,
+`eft4py.solvers`, `eft4py.backend` and `eft4py.utils`.
+
+Examples:
+    >>> from eft4py import HorndeskiModel, get_symbols
+    >>> s = get_symbols()
+    >>> model = HorndeskiModel(G2=s.X - 0.5 * s.phi**2, G4=s.Mpl**2 / 2, symbols=s)
+"""
+
+from importlib import metadata as _metadata
+
+from .core.types import HiClassState
+from .models.horndeski import HorndeskiModel
+from .physics.cosmology import Cosmology
+from .physics.errors import SingularSystemError
+from .solvers.background import JaxBackground, ScipyBackground, frozen_field
+from .solvers.ode_systems.horndeski import HorndeskiODE
+from .solvers.strategies.scipy import ScipySolver
+from .utils.symbols import SymbolTable, get_symbols
+
+try:
+    __version__ = _metadata.version("eft4py")
+except _metadata.PackageNotFoundError:  # pragma: no cover - uninstalled source tree
+    __version__ = "0.0.0+unknown"
+
+DOCS_URL = "https://rcalderonb6.github.io/eft4py/"
+"""Address of the documentation website."""
+
+__all__ = [
+    "__version__",
+    "HorndeskiModel",
+    "Cosmology",
+    "ScipyBackground",
+    "JaxBackground",
+    "frozen_field",
+    "HorndeskiODE",
+    "HiClassState",
+    "ScipySolver",
+    "JAXSolver",
+    "get_symbols",
+    "SymbolTable",
+    "SingularSystemError",
+]
+
+
+def __getattr__(name: str):
+    """Load `JAXSolver` on first access (PEP 562), so `import eft4py` never imports JAX."""
+    if name == "JAXSolver":
+        from .solvers.strategies.jax import JAXSolver
+
+        return JAXSolver
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    """List the public names, including the lazily loaded `JAXSolver`."""
+    return sorted({*__all__, "DOCS_URL", "main"})
+
+
+def main() -> None:
+    """Entry point of the `eft4py` command: print the version and where to find the docs."""
+    print(f"eft4py {__version__}")
+    print("Horndeski dark-energy backgrounds in Python, validated against hi_class.")
+    print(f"Documentation: {DOCS_URL}")

eft4py-0.0.4/src/eft4py/backend/__init__.py

@@ -0,0 +1,138 @@
+r"""Numerical backends: how compiled expressions are evaluated.
+
+eft4py compiles its symbolic equations with SymPy's `lambdify`, and the same
+expressions can be evaluated in three ways:
+
+- `"math"`: plain Python floats. Fastest for one state at a time, which is
+  what SciPy's integration loop needs.
+- `"numpy"`: element-wise on NumPy arrays, e.g. a whole trajectory at once.
+- `"jax"`: `jax.numpy`, traceable by `jax.jit`, `vmap` and `grad`.
+
+A [`Backend`][eft4py.backend.Backend] bundles everything that differs between
+them. Most users only pass the backend *name* (e.g.
+`HorndeskiODE(model, backend="jax")`); the class matters when writing new
+compiled components.
+"""
+
+from dataclasses import dataclass
+from functools import lru_cache
+from typing import Any, Literal, Sequence
+
+import numpy as np
+
+BackendName = Literal["math", "numpy", "jax"]
+"""Names of the available numerical backends."""
+
+
+@dataclass(frozen=True)
+class Backend:
+    """A numerical backend for compiled expressions.
+
+    Attributes:
+        name: Backend name.
+        lambdify_modules: The `modules` argument passed to `sympy.lambdify`.
+        traceable: Whether values may be abstract tracers (JAX under `jit`),
+            so that Python control flow on them is not allowed.
+        xp: Array namespace (`numpy` or `jax.numpy`); `None` for `"math"`.
+    """
+
+    name: BackendName
+    lambdify_modules: Any
+    traceable: bool
+    xp: Any
+
+    def where(self, cond: Any, x: Any, y: Any) -> Any:
+        """Element-wise `x if cond else y`, valid for this backend's values."""
+        if self.xp is None:
+            return x if cond else y
+        return self.xp.where(cond, x, y)
+
+    def broadcast(self, values: Sequence[Any], inputs: Sequence[Any]) -> list:
+        r"""Give every output the broadcast shape of the inputs.
+
+        `lambdify` returns a plain scalar for an expression that simplifies
+        to a constant (e.g. $\alpha_T = 0$ for quintessence), even when the
+        inputs are arrays. On the `"math"` backend the values are returned
+        unchanged.
+
+        Args:
+            values: Outputs of a compiled function.
+            inputs: The arguments it was called with.
+
+        Returns:
+            The outputs as arrays of the inputs' broadcast shape.
+        """
+        if self.xp is None:
+            return list(values)
+        shape = np.broadcast_shapes(*(np.shape(x) for x in inputs))
+        zeros = self.xp.zeros(shape)
+        return [zeros + v for v in values]
+
+
+@lru_cache(maxsize=None)
+def _build(name: str) -> Backend:
+    if name == "math":
+        return Backend(name="math", lambdify_modules="math", traceable=False, xp=None)
+    if name == "numpy":
+        return Backend(name="numpy", lambdify_modules="numpy", traceable=False, xp=np)
+    if name == "jax":
+        import jax.numpy as jnp
+
+        modules = [
+            {
+                "exp": jnp.exp, "log": jnp.log, "sqrt": jnp.sqrt,
+                "Abs": jnp.abs, "sign": jnp.sign,
+                "sin": jnp.sin, "cos": jnp.cos, "tan": jnp.tan,
+            },
+            jnp,
+        ]
+        return Backend(name="jax", lambdify_modules=modules, traceable=True, xp=jnp)
+    raise ValueError(f"Unknown backend {name!r}; expected 'math', 'numpy' or 'jax'.")
+
+
+def get_backend(backend: "BackendName | Backend") -> Backend:
+    """Resolve a backend name (or pass a `Backend` through).
+
+    JAX is imported only when the `"jax"` backend is requested. Backends are
+    built once and cached.
+
+    Args:
+        backend: `"math"`, `"numpy"`, `"jax"`, or a `Backend` instance.
+
+    Returns:
+        The corresponding `Backend`.
+
+    Raises:
+        ValueError: If the name is unknown.
+        ImportError: If `"jax"` is requested but JAX is not installed.
+    """
+    if isinstance(backend, Backend):
+        return backend
+    return _build(backend)
+
+
+def namespace_of(array: Any) -> Backend:
+    """The backend that an array belongs to: `"numpy"` or `"jax"`.
+
+    Lets a function accept NumPy or JAX data without a `backend` argument.
+    JAX is imported only when the array is not a NumPy array.
+
+    Args:
+        array: A computed array, e.g. a field of a solved background.
+
+    Returns:
+        The `"numpy"` backend for NumPy arrays and scalars and Python
+        numbers, the `"jax"` backend otherwise (JAX arrays and tracers inside
+        `jit`, `vmap` or `grad`).
+
+    Warning:
+        Pass a *computed* field (such as `H`), not an input passed through
+        unchanged (such as `ln_a`): `jax.jit` forwards an input it returns
+        unchanged, so a NumPy grid given to a jitted solve comes back as NumPy
+        even though everything computed from it is JAX.
+    """
+    is_numpy = isinstance(array, (np.ndarray, np.generic, float, int))
+    return _build("numpy" if is_numpy else "jax")
+
+
+__all__ = ["Backend", "BackendName", "get_backend", "namespace_of"]

eft4py-0.0.4/src/eft4py/core/__init__.py

@@ -0,0 +1,30 @@
+"""Core types and protocols for eft4py.
+
+- Types: the background state `HiClassState` (with the kinetic term $X$
+  always derived from it), `HiClassDerivatives`, and the generic
+  `ParamPoint`.
+- Protocols: the structural contracts `StateVector`, `ODESystem` and
+  `IntegrationStrategy` for extending eft4py.
+"""
+
+from .protocols import (
+    StateVector,
+    ODESystem,
+    IntegrationStrategy,
+)
+from .types import (
+    ParamPoint,
+    HiClassState,
+    HiClassDerivatives,
+)
+
+__all__ = [
+    # Protocols
+    "StateVector",
+    "ODESystem",
+    "IntegrationStrategy",
+    # Types
+    "ParamPoint",
+    "HiClassState",
+    "HiClassDerivatives",
+]

eft4py-0.0.4/src/eft4py/core/protocols.py

@@ -0,0 +1,167 @@
+"""Protocol definitions for abstract interfaces in eft4py.
+
+Protocols define the structural contracts for extending eft4py: a state
+(`StateVector`), an ODE system (`ODESystem`) and an integration strategy
+(`IntegrationStrategy`). The base classes `ODESystemBase` and
+`IntegrationStrategyBase` implement them.
+"""
+
+from typing import Protocol, Any, Mapping
+
+
+class StateVector(Protocol):
+    r"""Protocol for any point in configuration space.
+
+    A StateVector represents a point in the system's phase space. It can be:
+
+    - A cosmological background state ($\tau$, $a$, $H$, $\phi$, $\phi'$)
+    - A parameter evaluation point ($\phi$, $X$, $H$, $M_{\rm pl}$)
+    - Any other collection of named variables
+
+    Key properties:
+
+    - All values are float (can be wrapped in arrays for batch operations)
+    - Keys are canonical symbol names (strings)
+    - Used for both symbolic and numerical contexts
+    """
+
+    @property
+    def values(self) -> Mapping[str, float]:
+        """Return dict-like mapping of all symbol values.
+
+        Returns:
+            Mapping where keys are symbol names (e.g., 'phi', 'X', 'H')
+            and values are float numbers.
+        """
+        ...
+
+    def __getitem__(self, key: str) -> float:
+        """Get value by symbol name (convenience method).
+
+        Args:
+            key: Symbol name as string
+
+        Returns:
+            Numerical value
+        """
+        ...
+
+
+class ODESystem(Protocol):
+    r"""Protocol for ODE systems of form $dy/d\tau = f(y, \tau)$.
+
+    An ODESystem encapsulates a complete system of differential equations.
+    It handles:
+
+    - Computing derivatives at any state point
+    - Describing the state space dimension
+    - Validating initial conditions
+
+    In eft4py, `HorndeskiODE` implements this protocol for Horndeski
+    background evolution in conformal time $\tau$; the protocol itself is
+    general.
+
+    State for Horndeski background: $[a, H, \phi, \phi']$
+    Integration variable: $\tau$ (conformal time)
+    """
+
+    def state_dimension(self) -> int:
+        r"""Dimension of state vector.
+
+        Returns:
+            Integer number of state variables
+
+        Example:
+            Horndeski background in conformal time has 4 variables:
+            $a, H, \phi, \phi'$
+        """
+        ...
+
+    def compute_derivatives(self, state: StateVector, tau: float) -> list[float]:
+        r"""Compute $dy/d\tau$ at given state.
+
+        Args:
+            state: Current state with all required variables
+            tau: Current conformal time (for reference/diagnostics)
+
+        Returns:
+            List of derivatives $[da/d\tau, dH/d\tau, d\phi/d\tau, d\phi'/d\tau]$
+            in correct order
+
+        Raises:
+            ValueError: If state is invalid or computation fails
+        """
+        ...
+
+    def validate_state(self, state: StateVector) -> bool:
+        r"""Check if state is physically valid.
+
+        Args:
+            state: State to validate
+
+        Returns:
+            True if valid, False otherwise
+
+        Example:
+            For background evolution, might check $a > 0$, $M_*^2 > 0$
+        """
+        ...
+
+
+class IntegrationStrategy(Protocol):
+    """Protocol for strategies that integrate ODE systems.
+
+    An IntegrationStrategy is a backend for solving ODE initial value problems.
+    Different strategies can use different algorithms:
+
+    - SciPy's RK45 (robust, variable step)
+    - JAX's diffrax (differentiable)
+    - Custom RK4 (simple, predictable)
+
+    All strategies present the same interface for pluggability.
+    """
+
+    def integrate(
+        self,
+        system: ODESystem,
+        initial_state: StateVector,
+        tau_span: tuple[float, float],
+        tau_eval: list[float] | None = None,
+        **kwargs: Any
+    ) -> list[StateVector]:
+        r"""Integrate ODE system over conformal time interval.
+
+        Args:
+            system: ODESystem to integrate
+            initial_state: Initial condition at $\tau_{\rm start}$
+            tau_span: $(\tau_{\rm start}, \tau_{\rm end})$ conformal time interval
+            tau_eval: Optional list of $\tau$ values to evaluate solution at.
+                      If None, solver chooses sampling.
+            **kwargs: Backend-specific options (rtol, atol, max_steps, etc.)
+
+        Returns:
+            List of StateVector at requested times (or solver-chosen times)
+
+        Raises:
+            RuntimeError: If integration fails (NaN, divergence, etc.)
+            ValueError: If invalid parameters
+
+        Note:
+            Results should be in increasing order of $\tau$ (or conformal time).
+        """
+        ...
+
+    def name(self) -> str:
+        """Return strategy identifier.
+
+        Returns:
+            String like 'scipy', 'jax', 'rk4'
+        """
+        ...
+
+
+__all__ = [
+    "StateVector",
+    "ODESystem",
+    "IntegrationStrategy",
+]

eft4py-0.0.4/src/eft4py/core/types.py

@@ -0,0 +1,175 @@
+r"""Type definitions following hi_class conventions.
+
+This module defines the core data types used throughout eft4py:
+
+- ParamPoint: Evaluation point in parameter space ($\phi$, $X$, $H$, etc.)
+- HiClassState: Point in background evolution following hi_class conventions
+- HiClassDerivatives: Derivatives at a state point
+
+$X = \tfrac{1}{2}\dot\phi^2$ is always derived from the state on
+HiClassState, never stored or set independently, so it is guaranteed to
+stay consistent with $\phi'$ and $a$.
+"""
+
+from dataclasses import dataclass
+from typing import Mapping
+
+
+@dataclass(frozen=True)
+class ParamPoint:
+    """Evaluation point in parameter space.
+
+    A ParamPoint represents values of symbols at a specific location,
+    used for evaluating arbitrary symbolic functions.
+
+    Examples:
+        >>> ParamPoint(values={"phi": 1.5, "X": 0.2, "H": 0.1, "Mpl": 1.0})
+    """
+
+    values: dict[str, float]
+
+    def __getitem__(self, key: str) -> float:
+        """Get value by symbol name."""
+        return self.values[key]
+
+    def __contains__(self, key: str) -> bool:
+        """Check if symbol is present."""
+        return key in self.values
+
+    @property
+    def symbols(self) -> Mapping[str, float]:
+        """Satisfy StateVector protocol."""
+        return self.values
+
+    def get(self, key: str, default: float | None = None) -> float | None:
+        """Get value with optional default."""
+        return self.values.get(key, default)
+
+
+@dataclass(frozen=True)
+class HiClassState:
+    r"""Background evolution state following hi_class conventions.
+
+    Integration variable: $\tau$ (conformal time)
+    State variables: $[a, H, \phi, \phi']$
+
+    Relationships:
+
+    - $a$: scale factor
+    - $H = a'/a^2$ (conformal Hubble parameter, where $' = d/d\tau$)
+    - $\phi$: scalar field
+    - $\phi' = d\phi/d\tau$ (conformal time derivative of scalar field)
+
+    DERIVED (not independent):
+
+    - $\dot\phi = \phi'/a$ (physical time derivative)
+    - $X = \tfrac{1}{2}\dot\phi^2 = \tfrac{1}{2}(\phi'/a)^2$ (kinetic term)
+
+    $X$ and $\dot\phi$ are always computed from $\phi'$ and $a$, so they can
+    never be set independently or become inconsistent with each other.
+    """
+
+    tau: float  # Current conformal time
+    a: float  # Scale factor
+    H: float  # Conformal Hubble parameter H = a'/a²
+    phi: float  # Scalar field value
+    phi_prime: float  # Conformal time derivative dφ/dτ
+    rho_m: float = 0.0  # Matter energy density ρ_m (pressureless dust)
+    rho_r: float = 0.0  # Radiation energy density ρ_r (p_r = ρ_r/3)
+
+    @property
+    def phidot(self) -> float:
+        r"""Physical time derivative: $\dot\phi = \phi'/a$.
+
+        Returns:
+            Physical scalar field velocity.
+
+        Note:
+            This is derived from state variables (not independent),
+            ensuring consistency with X.
+        """
+        return self.phi_prime / self.a
+
+    @property
+    def X(self) -> float:
+        r"""Kinetic term $X = \tfrac{1}{2}\dot\phi^2$ (ENFORCED - never independent!).
+
+        Returns:
+            $X = \tfrac{1}{2}\dot\phi^2 = \tfrac{1}{2}(\phi'/a)^2$.
+
+        Warning:
+            This property is always computed from state variables. There
+            is no way to set X independently, which keeps X and
+            $\dot\phi$ consistent by construction.
+        """
+        return 0.5 * self.phidot**2
+
+    @property
+    def z(self) -> float:
+        """Redshift z = 1/a - 1 (derived for convenience).
+
+        Returns:
+            Redshift parameter.
+        """
+        return 1.0 / self.a - 1.0
+
+    @property
+    def values(self) -> Mapping[str, float]:
+        """Satisfy StateVector protocol.
+
+        Returns a mapping of all state variables by canonical names.
+        Note: X is computed dynamically (not stored).
+        """
+        return {
+            "tau": self.tau,
+            "a": self.a,
+            "H": self.H,
+            "phi": self.phi,
+            "phi_prime": self.phi_prime,
+            "phidot": self.phidot,
+            "X": self.X,
+            "z": self.z,
+            "rho_m": self.rho_m,
+            "rho_r": self.rho_r,
+        }
+
+    def __getitem__(self, key: str) -> float:
+        """Get value by symbol name (StateVector protocol)."""
+        return self.values[key]
+
+
+@dataclass(frozen=True)
+class HiClassDerivatives:
+    r"""Derivatives of state variables with respect to conformal time $\tau$.
+
+    Contains: $[da/d\tau, dH/d\tau, d\phi/d\tau, d\phi'/d\tau, d\rho_m/d\tau, d\rho_r/d\tau]$
+
+    This is the output of ODESystem.compute_derivatives().
+
+    Note:
+        All derivatives are with respect to conformal time $\tau$, using
+        hi_class notation (prime = $d/d\tau$).
+    """
+
+    da_dtau: float  # da/dτ (scale factor derivative)
+    dH_dtau: float  # dH/dτ (Hubble derivative)
+    dphi_dtau: float  # dφ/dτ (scalar field derivative)
+    dphi_prime_dtau: float  # dφ'/dτ (acceleration in conformal time)
+    drho_m_dtau: float = 0.0  # dρ_m/dτ (dust continuity: -3aH·ρ_m)
+    drho_r_dtau: float = 0.0  # dρ_r/dτ (radiation continuity: -4aH·ρ_r)
+
+    def to_list(self) -> list[float]:
+        r"""Convert to ordered list for ODE solver.
+
+        Returns:
+            $[da/d\tau, dH/d\tau, d\phi/d\tau, d\phi'/d\tau, d\rho_m/d\tau, d\rho_r/d\tau]$.
+        """
+        return [self.da_dtau, self.dH_dtau, self.dphi_dtau, self.dphi_prime_dtau,
+                self.drho_m_dtau, self.drho_r_dtau]
+
+
+__all__ = [
+    "ParamPoint",
+    "HiClassState",
+    "HiClassDerivatives",
+]

eft4py-0.0.4/src/eft4py/models/__init__.py

@@ -0,0 +1,5 @@
+"""EFT model interfaces and implementations."""
+
+from .horndeski import EFTModel, HorndeskiModel, HorndeskiFunction
+
+__all__ = ["EFTModel", "HorndeskiModel", "HorndeskiFunction"]