Observable

Alias for ProjectedFunction. The two were separate structs in earlier versions of the package; the unified type carries both an observable-side (weak_dual_bound) and a projection-side (proj_error) bound, so a single struct serves both roles.

ProjectedFunction{TB,TV,TWDB,TPE}

A function f projected onto a basis B, packaged together with the two bounds needed for rigorous integration against another projected function:

• B — the basis.
• v — the basis-specific discrete coefficient vector.
• weak_dual_bound — upper bound on $\|f\|_{w^*}$ (dual of the weak norm of B). For weak L² (Fourier) this is $\|f\|_{L²}$; for weak L¹ (Ulam) this is $\|f\|_{L^∞}$.
• proj_error — upper bound on the weak-norm projection error $\|f - φ_v\|_w$.

The integration formula

\[\Bigl|\int f\,g\,dx - \langle f_N, g_N\rangle\Bigr| \;\leq\; p_f.\text{proj\_error} \cdot \|p_g.v\|_{w^*} + p_f.\text{weak\_dual\_bound} \cdot p_g.\text{proj\_error}\]

is computed by integral_pairing. For Ulam (cell-wise exactness) the first term is identically zero — see the Ulam method docstring.

Observable is provided as a const alias to ProjectedFunction: prior code using Observable(B, ϕ; …) keeps working. The two roles (observable vs density) are now distinguished only by which arguments the caller emphasizes, not by the type system.

Constructors are provided per basis by extensions:

• ProjectedFunction(B::Ulam, f; tol, var_bound, weak_dual_bound) — TaylorModelsExt (load with using TaylorModels). weak_dual_bound defaults to a Taylor-model bound on $\|f\|_{L^∞}$; var_bound defaults to a VariationBound-computed total variation; proj_error = var_bound / length(B).
• ProjectedFunction(B::FourierAnalytic{W{k,l},…}, f; weak_dual_bound, Wk1_seminorm, M = 4*B.k) and ProjectedFunction(B::FourierAdjoint{W{k,l},…}, …) — FFTWExt (load with using FFTW).

The struct itself has no inherent dependency on either extension; concrete field types are inferred from the constructor.

p1 + p2
p1 - p2

Add or subtract two ProjectedFunctions on the same basis. The coefficient vector is combined componentwise; both bounds combine via the triangle inequality:

weak_dual_bound = p1.weak_dual_bound + p2.weak_dual_bound
proj_error      = p1.proj_error      + p2.proj_error

Subtraction uses the same combine rule for bounds (still triangle inequality on the dual norm and the weak norm). Bounds combine in interval arithmetic; if either input has proj_error == nothing the result inherits nothing for that field.

integral_pairing(ϕ::ProjectedFunction, ρ::ProjectedFunction)
integral_pairing(ϕ::ProjectedFunction, ρ::AbstractVector, ρ_w_error;
                 ρ_dual_weak_bound = weak_dual_norm_bound(ϕ.B, ρ))

Compute a rigorous enclosure of $\int_0^1 ϕ(x)\,ρ(x)\,dx$.

The error decomposes as

\[\Bigl|\int ϕ\,ρ - \langle ϕ_N,\,ρ_N\rangle\Bigr| \;\leq\; \|ϕ - ϕ_N\|_w\,\|ρ_N\|_{w^*} + \|ϕ\|_{w^*}\,\|ρ - ρ_N\|_w\]

so the result is

⟨ϕ.v, ρ.v⟩_basis
    + [-(ϕ.proj_error · ‖ρ.v‖_{w*}
         + ϕ.weak_dual_bound · ρ.proj_error),
       +(…)]

The two-vector form lets callers pass a density that wasn't constructed through this package (e.g. a result of invariant_vector); they supply ρ_w_error and optionally a tighter ρ_dual_weak_bound than what weak_dual_norm_bound(ϕ.B, ρ) would compute.

Methods are provided per basis. For Ulam the cell-wise integration of ϕ is exact against any piecewise-constant ρ_N, so the first term collapses and only ϕ.weak_dual_bound · ρ.proj_error contributes.

integrateobservable(B, ϕ::ProjectedFunction, f, error)

Integrate the discretized observable ϕ against a density coefficient vector f, with an upper bound error on the basis-side density projection error. Legacy two-term bound; prefer integral_pairing. Methods provided by extensions.

weak_dual_norm_bound(B::Basis, v::AbstractVector)

Upper bound on $\|φ_v\|_{w^*}$ where $φ_v$ is the basis-B reconstruction of the coefficient vector v and $w$ is weak_norm(B).