FastLSQ 0.2.6__tar.gz → 0.4.0__tar.gz

{fastlsq-0.2.6 → fastlsq-0.4.0}/CHANGELOG.md

@@ -2,6 +2,101 @@
 
 All notable changes to FastLSQ will be documented in this file.
 
+## [0.4.0] - 2026-06-22
+
+### Added
+
+- **Closed-form projection (Radon) operator for windowed bases.** The integral
+  operator class now covers the *projection / Radon* (line/hyperplane-integral)
+  family, not just the single-axis integrals of 0.3.0. A tomographic measurement is
+  a projection onto a generally **non-axis-aligned** hyperplane,
+  `p(u) = ∫ f(z) δ(c·z − u) dz` (a Fredholm equation of the first kind) — beam
+  phase-space tomography, CT, Abel inversion — which the single-axis `IntegralOperator`
+  cannot express.
+- **`GaussianWindowedBasis`** — the windowed-Fourier (Gabor) member of the basis
+  family, `ψ_j(z) = exp(−‖ζ‖²/2)·sin(W_j·ζ + b_j)` with `ζ = T⁻¹(z − mean)`. The
+  Gaussian window is a **fixed prior** (set once from the data's second moments via
+  `GaussianWindowedBasis.from_data`, *not* trained): the projection of a bare unbounded
+  sinusoid over an infinite hyperplane diverges, and the window makes the hyperplane
+  integral integrable and analytic. Coefficients stay linear, so a fit is still one
+  linear least squares. The Gaussian envelope changes the derivative algebra, so this
+  class is deliberately scoped to **value** (`evaluate`) and **projection** — it does
+  not claim the full `DiffOperator` calculus of the bare `SinusoidalBasis`.
+- **`ProjectionOperator`** — assembles the `(M, N)` projection design matrix in
+  **closed form, with no quadrature**: in the whitened frame, with `q = Tᵀc`,
+  `σ_u² = ‖q‖²`, `u₀ = c·mean`, `jac = |det T|/‖q‖`,
+  `(P ψ_j)(u) = jac·(2π)^((d−1)/2)·exp(−‖ω_j‖²/2)·exp(−(u−u₀)²/(2σ_u²))·sin(α_j u + φ_j)`,
+  with `α_j = (W_j·q)/‖q‖²`, `‖ω_j‖² = ‖W_j‖² − (W_j·q̂)²`, `φ_j = b_j − α_j u₀`. The
+  rows are **differentiable in the direction `c` (the optics)**, for differentiable
+  experiment design (autodiff `d(posterior)/d(optics)`): the across-slice energy uses
+  the rotation-invariant `‖W‖²−(W·q̂)²` (no QR complement) and every quantity stays a
+  tensor (no `float()`/`.item()` casts), so autograd flows to `c` (verified
+  `autodiff == finite-difference` to ~5e-9). `from_transport(M, e)` builds the
+  tomography convention `c = Mᵀe` (transport by optics `M`, read on axis `e`). The
+  operator mirrors the `apply(basis, x, cache)` signature but is standalone (it needs
+  the windowed basis, so it does not compose into `IntegroDifferentialOperator`). Both
+  classes are exported from `fastlsq`.
+- **Tests / example.** `tests/test_projection.py` asserts the closed form equals a
+  Gauss--Hermite quadrature of the slice integral to machine precision in d = 2, 3, 4
+  (≤4e-13 observed), that autodiff of the rows wrt `c` matches finite differences, and
+  that a windowed field is recovered from its projections at several directions in one
+  LSQ. `examples/inverse/tomography_projection.py` demonstrates the full reconstruction
+  plus the differentiable-optics gradient.
+
+### Scope (honest)
+
+- The closed-form projection assembly works **only** for the Gaussian-windowed basis
+  (the Gaussian × plane-wave hyperplane integral is analytic); other windows
+  (compact / polynomial) generally are **not** closed form. Scope = *Gaussian-windowed*
+  tomographic / line-integral operators, not "any projection".
+- The window is a *fixed prior* (set from data moments), required for convergence — not
+  a tuned hyperparameter.
+- This is a **different** analytic-kernel mechanism from the Fourier-symbol
+  (convolution / fractional) class — it is the projection / Radon (line/hyperplane
+  integral) class.
+- No novelty is claimed over ELM / RBF-for-integral-equations prior art; the distinctive
+  parts are quadrature-free closed-form projection rows, differentiability in the optics,
+  and the unified operator algebra.
+
+## [0.3.0] - 2026-06-21
+
+### Added
+
+- **Exact closed-form integral & integro-differential operators.** The cyclic
+  derivative identity `D^α sin(W·x+b) = (∏ W^{α_k}) Φ_{|α| mod 4}` runs *backwards* --
+  integration is differentiation of *negative* order, `∫ sin(wx+b) dx = −(1/w)cos(wx+b)`.
+  `SinusoidalBasis.derivative` now accepts **signed** multi-indices (negative entries =
+  indefinite integration), with a DC guard (`dc_eps`) that zeros features whose frequency
+  along an integrated axis is ~0 (their primitive is a ramp that leaves the sinusoidal
+  family). `DiffOperator.antiderivative(dim, order, d)` exposes this as a factory, so
+  `Op.partial(0,1,1) - k*Op.antiderivative(0,1,1)` composes integro-differential operators.
+- **`IntegralOperator`** -- definite and running (Volterra) integrals with limits,
+  via the new `SinusoidalBasis.definite_integral`. Evaluated with a numerically stable
+  `sinc` identity (no `1/w` division), so the running integral of a near-DC feature is
+  exact rather than singular. Factories `IntegralOperator.volterra(...)` /
+  `IntegralOperator.definite(...)`.
+- **`IntegroDifferentialOperator`** -- the common roof under which differential and
+  integral terms compose (`+`, `−`, scalar/`nn.Parameter` `*`) into one `(M, N)`
+  linear-least-squares design matrix; coefficients stay differentiable so learnable
+  integral-term coefficients train through the solve. All three exported from `fastlsq`.
+- **Examples** `examples/integro_differential_demo.py` (one-shot forward solve of
+  `u'(x) + ∫_0^x u ds = f`, rel-L2 ~3e-11) and
+  `examples/inverse/inverse_memory_kernel.py` (recover an unknown memory strength λ from
+  noisy data via AdamW through the differentiable solve). New `tests/test_integral.py`
+  asserts ∫-then-∂ round-trips to identity, Volterra/definite match quadrature, the DC
+  guard stays finite, and gradients flow to learnable coefficients.
+
+## [0.2.6] - 2026-06-09
+
+### Changed
+
+- **Faster `_auto_solve` fallback for ill-conditioned systems.** When the
+  Cholesky path fails on CPU with no ridge (`mu = 0`), `_auto_solve` now goes
+  straight to the rank-deficient-safe SVD solve (LAPACK `gelsd`) instead of
+  first attempting Householder QR with the blow-up guard -- on CPU `gelsd` is
+  faster than QR, so the detour only added a full extra factorization. The
+  QR-then-SVD path is unchanged for ridge solves and non-CPU devices.
+
 ## [0.2.5] - 2026-06-04
 
 ### Fixed

{fastlsq-0.2.6 → fastlsq-0.4.0}/FastLSQ.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FastLSQ
-Version: 0.2.6
+Version: 0.4.0
 Summary: One-shot PDE solving via Fourier features with exact analytical derivatives; rank-revealing solvers, learnable anisotropic bandwidth, and CPU/CUDA/MPS support
 Author: Antonin Sulc
 License-Expression: MIT
@@ -278,6 +278,8 @@ derivative engine:
 | `SinusoidalBasis` | Evaluates basis functions and arbitrary-order derivatives in O(1) via the cyclic identity |
 | `BasisCache` | Pre-computes sin(Z)/cos(Z) once, reuses across multiple derivative evaluations |
 | `DiffOperator` / `Op` | Symbolic linear differential operators that compose via +, -, scalar *; coefficients can be `nn.Parameter` for learnable PDEs |
+| `IntegralOperator` / `IntegroDifferentialOperator` | Closed-form **single-axis** definite / running (Volterra) integrals; compose with `Op` into one integro-differential design matrix |
+| `GaussianWindowedBasis` / `ProjectionOperator` | Windowed-Fourier (Gabor) basis + closed-form **projection (Radon)** operator `∫ f δ(c·z−u) dz` for tomographic / line-integral inverse problems; quadrature-free and differentiable in the optics `c` |
 | `FeatureBasis` | Adapter for non-sinusoidal solvers (e.g. PIELM with tanh) |
 | `FastLSQSolver` | Manages feature blocks; exposes `.basis` for all derivative computations |
 | `LearnableFastLSQ` | Differentiable solver with learnable bandwidth via reparameterisation trick |
@@ -367,6 +369,7 @@ See `examples/add_your_own_pde.py` for the complete tutorial.
 
 - **Analytical derivative engine**: `SinusoidalBasis` computes arbitrary-order derivatives exactly in O(1) -- the foundation of the entire framework
 - **Symbolic PDE operators**: Compose differential operators with `Op` (Laplacian, wave, Helmholtz, biharmonic, custom) via intuitive arithmetic; coefficients can be `nn.Parameter` for AdamW optimisation
+- **Closed-form integral operators**: `IntegralOperator` (single-axis definite / Volterra integrals) composes with `Op` into one integro-differential least-squares block. The integral class now also includes the **projection (Radon) operator** (`ProjectionOperator` on a `GaussianWindowedBasis`) -- quadrature-free `∫ f δ(c·z−u) dz` line/hyperplane integrals for tomographic inverse problems, differentiable in the optics `c` for experiment design
 - **Vector-valued solutions**: First-class support for **u**: ℝᵈ → ℝᵏ (elasticity, Stokes, Maxwell). Problems declare `n_outputs = k`; `block_concat` assembles coupled block systems; `solver.predict(x)` returns shape `(M, k)`. Scalar problems are the `k=1` case
 - **High-level API**: Solve PDEs in one line with `solve_linear()` and `solve_nonlinear()`
 - **Robust linear solver**: Pluggable least-squares back-ends; the default `auto` routes Cholesky -> QR -> SVD, and backward-stable QR delivers SVD-grade accuracy at QR cost on the rank-deficient random-feature system

{fastlsq-0.2.6 → fastlsq-0.4.0}/FastLSQ.egg-info/SOURCES.txt

@@ -18,14 +18,17 @@ examples/grid_rl_control.py
 examples/grid_swing.py
 examples/gs_inverse.py
 examples/gs_rl_control.py
+examples/integro_differential_demo.py
 examples/inverse_heat_source.py
 examples/inverse_magnetostatics.py
 examples/inverse_source_position.py
 examples/learnable_helmholtz.py
+examples/memory_diffusion.py
 examples/orbit_hill.py
 examples/orbit_inverse.py
 examples/orbit_rl.py
 examples/pde_discovery.py
+examples/rlc_integro_differential.py
 examples/run_all_extensions.py
 examples/run_linear.py
 examples/run_nonlinear.py
@@ -88,9 +91,13 @@ examples/inverse/aero_.py
 examples/inverse/denoising_parameter_estimation.py
 examples/inverse/elastic_wave_animation.py
 examples/inverse/heat_from_video.py
+examples/inverse/inverse_memory_kernel.py
+examples/inverse/inverse_source_integral_sensors.py
 examples/inverse/inverse_turbulence.py
+examples/inverse/rlc_system_id.py
 examples/inverse/shape_ns.py
 examples/inverse/subsurface_imaging.py
+examples/inverse/tomography_projection.py
 examples/inverse/wing_optimize_simple.py
 examples/sindy/compare_sindy_methods.py
 examples/sindy/sindy_benchmarks.py
@@ -135,6 +142,8 @@ tests/test_derivatives.py
 tests/test_device.py
 tests/test_grad_shafranov.py
 tests/test_grid_swing.py
+tests/test_integral.py
 tests/test_learnable.py
 tests/test_orbit_hill.py
+tests/test_projection.py
 tests/test_vector_basis.py

{fastlsq-0.2.6 → fastlsq-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FastLSQ
-Version: 0.2.6
+Version: 0.4.0
 Summary: One-shot PDE solving via Fourier features with exact analytical derivatives; rank-revealing solvers, learnable anisotropic bandwidth, and CPU/CUDA/MPS support
 Author: Antonin Sulc
 License-Expression: MIT
@@ -278,6 +278,8 @@ derivative engine:
 | `SinusoidalBasis` | Evaluates basis functions and arbitrary-order derivatives in O(1) via the cyclic identity |
 | `BasisCache` | Pre-computes sin(Z)/cos(Z) once, reuses across multiple derivative evaluations |
 | `DiffOperator` / `Op` | Symbolic linear differential operators that compose via +, -, scalar *; coefficients can be `nn.Parameter` for learnable PDEs |
+| `IntegralOperator` / `IntegroDifferentialOperator` | Closed-form **single-axis** definite / running (Volterra) integrals; compose with `Op` into one integro-differential design matrix |
+| `GaussianWindowedBasis` / `ProjectionOperator` | Windowed-Fourier (Gabor) basis + closed-form **projection (Radon)** operator `∫ f δ(c·z−u) dz` for tomographic / line-integral inverse problems; quadrature-free and differentiable in the optics `c` |
 | `FeatureBasis` | Adapter for non-sinusoidal solvers (e.g. PIELM with tanh) |
 | `FastLSQSolver` | Manages feature blocks; exposes `.basis` for all derivative computations |
 | `LearnableFastLSQ` | Differentiable solver with learnable bandwidth via reparameterisation trick |
@@ -367,6 +369,7 @@ See `examples/add_your_own_pde.py` for the complete tutorial.
 
 - **Analytical derivative engine**: `SinusoidalBasis` computes arbitrary-order derivatives exactly in O(1) -- the foundation of the entire framework
 - **Symbolic PDE operators**: Compose differential operators with `Op` (Laplacian, wave, Helmholtz, biharmonic, custom) via intuitive arithmetic; coefficients can be `nn.Parameter` for AdamW optimisation
+- **Closed-form integral operators**: `IntegralOperator` (single-axis definite / Volterra integrals) composes with `Op` into one integro-differential least-squares block. The integral class now also includes the **projection (Radon) operator** (`ProjectionOperator` on a `GaussianWindowedBasis`) -- quadrature-free `∫ f δ(c·z−u) dz` line/hyperplane integrals for tomographic inverse problems, differentiable in the optics `c` for experiment design
 - **Vector-valued solutions**: First-class support for **u**: ℝᵈ → ℝᵏ (elasticity, Stokes, Maxwell). Problems declare `n_outputs = k`; `block_concat` assembles coupled block systems; `solver.predict(x)` returns shape `(M, k)`. Scalar problems are the `k=1` case
 - **High-level API**: Solve PDEs in one line with `solve_linear()` and `solve_nonlinear()`
 - **Robust linear solver**: Pluggable least-squares back-ends; the default `auto` routes Cholesky -> QR -> SVD, and backward-stable QR delivers SVD-grade accuracy at QR cost on the rank-deficient random-feature system

{fastlsq-0.2.6 → fastlsq-0.4.0}/README.md

@@ -237,6 +237,8 @@ derivative engine:
 | `SinusoidalBasis` | Evaluates basis functions and arbitrary-order derivatives in O(1) via the cyclic identity |
 | `BasisCache` | Pre-computes sin(Z)/cos(Z) once, reuses across multiple derivative evaluations |
 | `DiffOperator` / `Op` | Symbolic linear differential operators that compose via +, -, scalar *; coefficients can be `nn.Parameter` for learnable PDEs |
+| `IntegralOperator` / `IntegroDifferentialOperator` | Closed-form **single-axis** definite / running (Volterra) integrals; compose with `Op` into one integro-differential design matrix |
+| `GaussianWindowedBasis` / `ProjectionOperator` | Windowed-Fourier (Gabor) basis + closed-form **projection (Radon)** operator `∫ f δ(c·z−u) dz` for tomographic / line-integral inverse problems; quadrature-free and differentiable in the optics `c` |
 | `FeatureBasis` | Adapter for non-sinusoidal solvers (e.g. PIELM with tanh) |
 | `FastLSQSolver` | Manages feature blocks; exposes `.basis` for all derivative computations |
 | `LearnableFastLSQ` | Differentiable solver with learnable bandwidth via reparameterisation trick |
@@ -326,6 +328,7 @@ See `examples/add_your_own_pde.py` for the complete tutorial.
 
 - **Analytical derivative engine**: `SinusoidalBasis` computes arbitrary-order derivatives exactly in O(1) -- the foundation of the entire framework
 - **Symbolic PDE operators**: Compose differential operators with `Op` (Laplacian, wave, Helmholtz, biharmonic, custom) via intuitive arithmetic; coefficients can be `nn.Parameter` for AdamW optimisation
+- **Closed-form integral operators**: `IntegralOperator` (single-axis definite / Volterra integrals) composes with `Op` into one integro-differential least-squares block. The integral class now also includes the **projection (Radon) operator** (`ProjectionOperator` on a `GaussianWindowedBasis`) -- quadrature-free `∫ f δ(c·z−u) dz` line/hyperplane integrals for tomographic inverse problems, differentiable in the optics `c` for experiment design
 - **Vector-valued solutions**: First-class support for **u**: ℝᵈ → ℝᵏ (elasticity, Stokes, Maxwell). Problems declare `n_outputs = k`; `block_concat` assembles coupled block systems; `solver.predict(x)` returns shape `(M, k)`. Scalar problems are the `k=1` case
 - **High-level API**: Solve PDEs in one line with `solve_linear()` and `solve_nonlinear()`
 - **Robust linear solver**: Pluggable least-squares back-ends; the default `auto` routes Cholesky -> QR -> SVD, and backward-stable QR delivers SVD-grade accuracy at QR cost on the rank-deficient random-feature system

fastlsq-0.4.0/examples/integro_differential_demo.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 Antonin Sulc
+# Licensed under the MIT License. See LICENSE file for details.
+
+"""
+Integro-differential equation in one shot: exact closed-form *calculus* -> linear LSQ.
+
+FastLSQ solves PDEs by exploiting that every *derivative* of a sinusoidal feature is
+closed-form.  The same identity runs backwards -- integration is differentiation of
+negative order -- so *integral* terms are closed-form too.  Differential and integral
+terms then compose into a single linear-least-squares design matrix.
+
+Here we solve the Volterra integro-differential boundary-value problem
+
+        u'(x) + ∫_0^x u(s) ds = f(x),   u(0) = 0,   x in [0, L],
+
+whose exact solution is u*(x) = sin(w x), giving the (known) forcing
+
+        f(x) = w cos(w x) + (1 - cos(w x)) / w.
+
+The operator is assembled as one object,
+
+        L = Op.partial(0, 1, d=1) + IntegralOperator.volterra(dim=0, lower=0.0, d=1),
+
+stacked with the initial condition, and solved in a single ``solve_lstsq`` call -- no
+time stepping, no quadrature, no autodiff.  We then verify a global conservation
+identity ∫_0^L u with ``IntegralOperator.definite``.
+
+Usage:  python integro_differential_demo.py
+"""
+
+import numpy as np
+import torch
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+from fastlsq import SinusoidalBasis, Op, IntegralOperator, solve_lstsq
+from fastlsq.geometry import sample_box
+
+
+def main():
+    torch.set_default_dtype(torch.float64)
+    torch.manual_seed(0)
+
+    # ------------------------------------------------------------------
+    # Problem definition (analytic ground truth -> exact forcing)
+    # ------------------------------------------------------------------
+    w, L = 3.0, 1.0
+    u_star = lambda x: torch.sin(w * x)                                  # exact solution
+    f_rhs = lambda x: w * torch.cos(w * x) + (1.0 - torch.cos(w * x)) / w  # known forcing
+    u0 = 0.0                                                             # initial condition
+
+    # ------------------------------------------------------------------
+    # Basis + collocation
+    # ------------------------------------------------------------------
+    basis = SinusoidalBasis.random(input_dim=1, n_features=800, sigma=5.0, normalize=False)
+    x_col = sample_box(4000, 1) * L          # interior collocation points in [0, L]
+    x_ic = torch.zeros(1, 1)                  # x = 0 for the initial condition
+
+    # ------------------------------------------------------------------
+    # One unified integro-differential operator:  u'(x) + ∫_0^x u(s) ds
+    # ------------------------------------------------------------------
+    op = Op.partial(0, 1, d=1) + IntegralOperator.volterra(dim=0, lower=0.0, d=1)
+    print("Operator:", op)
+
+    # Assemble [PDE rows ; weighted IC row]  =  [f ; weighted u0]  and solve once.
+    W_IC = 100.0
+    A = torch.cat([op.apply(basis, x_col), W_IC * basis.evaluate(x_ic)])
+    b = torch.cat([f_rhs(x_col),           W_IC * torch.full((1, 1), u0)])
+    beta = solve_lstsq(A, b, mu=1e-10)
+
+    # ------------------------------------------------------------------
+    # Report accuracy on held-out points
+    # ------------------------------------------------------------------
+    x_test = sample_box(3000, 1) * L
+    u_pred = basis.evaluate(x_test) @ beta
+    u_true = u_star(x_test)
+    val_err = (torch.norm(u_pred - u_true) / (torch.norm(u_true) + 1e-15)).item()
+
+    # Global conservation identity:  ∫_0^L u  (closed form, single functional row)
+    int_num = float(IntegralOperator.definite(0, 0.0, L, d=1).apply(basis, x_test[:1]) @ beta)
+    int_exact = float((1.0 - np.cos(w * L)) / w)
+
+    print(f"  solution rel-L2 error      : {val_err:.2e}")
+    print(f"  ∫_0^L u  (closed form)     : {int_num:.6f}   exact {int_exact:.6f}")
+
+    # ------------------------------------------------------------------
+    # Plot:  solution vs exact, and pointwise residual
+    # ------------------------------------------------------------------
+    xs = torch.linspace(0, L, 400).reshape(-1, 1)
+    us = (basis.evaluate(xs) @ beta).squeeze().numpy()
+    ue = u_star(xs).squeeze().numpy()
+    xg = xs.squeeze().numpy()
+
+    fig, (ax0, ax1) = plt.subplots(1, 2, figsize=(11, 4))
+    ax0.plot(xg, ue, "k-", lw=2.5, label="exact  sin(w x)")
+    ax0.plot(xg, us, "C1--", lw=1.8, label="FastLSQ")
+    ax0.set_title("u'(x) + ∫₀ˣ u ds = f(x),  u(0)=0")
+    ax0.set_xlabel("x"); ax0.set_ylabel("u(x)"); ax0.legend()
+    ax1.semilogy(xg, np.abs(us - ue) + 1e-18, "C3-")
+    ax1.set_title(f"pointwise |error|   (rel-L2 = {val_err:.1e})")
+    ax1.set_xlabel("x"); ax1.set_ylabel("|u_pred - u*|")
+    plt.tight_layout()
+    out = "integro_differential_demo.pdf"
+    plt.savefig(out, dpi=150, bbox_inches="tight")
+    plt.close()
+    print(f"  -> Saved: {out}")
+
+
+if __name__ == "__main__":
+    main()

fastlsq-0.4.0/examples/inverse/inverse_memory_kernel.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 Antonin Sulc
+# Licensed under the MIT License. See LICENSE file for details.
+
+"""
+Inverse problem: recover a memory-kernel strength from data through an INTEGRAL term.
+
+Many physical systems have *memory*: the rate of change depends not only on the present
+state but on its accumulated history.  A minimal model is the Volterra integro-differential
+equation
+
+        u'(x) + λ ∫_0^x u(s) ds = f(x),   u(0) = 0,
+
+where the scalar λ is the (unknown) memory / relaxation strength.  Given the known forcing
+f and noisy observations of u, we recover λ.
+
+This mirrors ``examples/learnable_helmholtz.py`` (learnable operator coefficient + AdamW),
+but the learnable coefficient now multiplies an ``IntegralOperator``: the operator is rebuilt
+each forward() as
+
+        L(λ) = Op.partial(0, 1, d=1) + λ · IntegralOperator.volterra(dim=0, lower=0.0, d=1),
+
+solved in one differentiable least-squares call, and gradients flow  loss -> u(λ) -> β ->
+lstsq -> A(λ) -> λ.  The inner solve uses Tikhonov regularisation + the SVD-based
+``gelsd`` driver (as in ``fastlsq/learnable.py``); a plain ``lstsq`` on the rank-deficient
+feature matrix yields an unreliable gradient.
+
+A closed-form / SINDy alternative (fit u, then linearly regress u' against [u, ∫u, ...] in one
+LSQ -- no optimiser) is shown in ``examples/inverse/denoising_parameter_estimation.py``.
+
+Usage:  python inverse_memory_kernel.py
+"""
+
+import numpy as np
+import torch
+import torch.nn as nn
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+from fastlsq import SinusoidalBasis, Op, IntegralOperator
+from fastlsq.geometry import sample_box
+
+
+class MemoryKernelInverse(nn.Module):
+    """Recover λ in  u'(x) + λ ∫_0^x u ds = f(x),  u(0)=0.
+
+    The operator is rebuilt each forward() so λ is always current.  The inner solve is
+    differentiable and rank-revealing (Tikhonov + gelsd), so AdamW can descend in λ.
+    """
+
+    def __init__(self, n_features: int = 600, sigma: float = 5.0, init_lam: float = 1.0,
+                 mu: float = 1e-8, rcond: float = 1e-12, w_ic: float = 100.0):
+        super().__init__()
+        self.basis = SinusoidalBasis.random(
+            input_dim=1, n_features=n_features, sigma=sigma, normalize=True
+        )
+        self.lam = nn.Parameter(torch.tensor(float(init_lam)))
+        self.mu, self.rcond, self.w_ic = mu, rcond, w_ic
+        self.beta: torch.Tensor | None = None
+
+    def solve(self, x_col, f_col, u0):
+        """Differentiable physics-constrained solve β(λ) for the current λ."""
+        op = Op.partial(0, 1, d=1) + self.lam * IntegralOperator.volterra(0, 0.0, d=1)
+        x_ic = torch.zeros(1, 1, dtype=x_col.dtype)
+        A = torch.cat([op.apply(self.basis, x_col), self.w_ic * self.basis.evaluate(x_ic)])
+        b = torch.cat([f_col, self.w_ic * torch.full((1, 1), float(u0))])
+        # Tikhonov-augmented, SVD-based solve -> stable gradient w.r.t. λ.
+        N = self.basis.n_features
+        A_aug = torch.cat([A, (self.mu ** 0.5) * torch.eye(N, dtype=A.dtype)])
+        b_aug = torch.cat([b, torch.zeros(N, 1, dtype=A.dtype)])
+        self.beta = torch.linalg.lstsq(A_aug, b_aug, rcond=self.rcond, driver="gelsd").solution
+        return self.beta
+
+    def predict(self, x):
+        return self.basis.evaluate(x) @ self.beta
+
+
+def main():
+    torch.set_default_dtype(torch.float64)
+    torch.manual_seed(0)
+
+    # ------------------------------------------------------------------
+    # Synthetic data: u* = sin(w x); forcing f encodes the TRUE memory λ*
+    # ------------------------------------------------------------------
+    w, L = 3.0, 1.0
+    lam_true = 5.0
+    u_star = lambda x: torch.sin(w * x)
+    f_rhs = lambda x: w * torch.cos(w * x) + lam_true * (1.0 - torch.cos(w * x)) / w
+    u0 = 0.0
+
+    x_col = sample_box(3000, 1) * L          # physics collocation points
+    f_col = f_rhs(x_col)                      # known forcing
+    x_obs = sample_box(300, 1) * L            # where u is observed
+    noise = 1e-3
+    u_obs = u_star(x_obs) + noise * torch.randn_like(x_obs)   # noisy observations
+
+    # ------------------------------------------------------------------
+    # Recover λ by gradient descent through the differentiable solve
+    # ------------------------------------------------------------------
+    model = MemoryKernelInverse(init_lam=1.0)
+    optimizer = torch.optim.AdamW(model.parameters(), lr=0.2)
+
+    print(f"Recovering memory strength λ  (true λ = {lam_true})")
+    print("-" * 52)
+    lam_hist, loss_hist = [], []
+    for step in range(150):
+        optimizer.zero_grad()
+        model.solve(x_col, f_col, u0)
+        loss = torch.mean((model.predict(x_obs) - u_obs) ** 2)
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(model.parameters(), 10.0)
+        optimizer.step()
+        lam_hist.append(model.lam.item()); loss_hist.append(loss.item())
+        if step % 25 == 0 or step == 149:
+            print(f"  step {step:3d}:  λ = {model.lam.item():.4f},  data-misfit = {loss.item():.2e}")
+
+    lam_hat = model.lam.item()
+    print("-" * 52)
+    print(f"  recovered λ = {lam_hat:.4f}   (true {lam_true},  |error| = {abs(lam_hat - lam_true):.2e})")
+    print(f"  noise floor ~ {noise:.0e};  recovery is within the noise level")
+
+    # ------------------------------------------------------------------
+    # Plots: λ convergence  &  fitted solution vs observations
+    # ------------------------------------------------------------------
+    with torch.no_grad():
+        xs = torch.linspace(0, L, 400).reshape(-1, 1)
+        us = model.predict(xs).squeeze().numpy()
+        ue = u_star(xs).squeeze().numpy()
+
+    fig, (ax0, ax1) = plt.subplots(1, 2, figsize=(11, 4))
+    ax0.axhline(lam_true, color="k", ls="--", lw=1.5, label=f"true λ = {lam_true}")
+    ax0.plot(lam_hist, "C0-", lw=1.8, label="AdamW iterate")
+    ax0.set_title("memory strength λ convergence")
+    ax0.set_xlabel("step"); ax0.set_ylabel("λ"); ax0.legend()
+
+    ax1.scatter(x_obs.squeeze().numpy(), u_obs.squeeze().numpy(), s=8, c="0.6",
+                label="noisy data", zorder=1)
+    ax1.plot(xs.squeeze().numpy(), ue, "k-", lw=2.2, label="true u*", zorder=2)
+    ax1.plot(xs.squeeze().numpy(), us, "C1--", lw=1.8, label="recovered u(λ̂)", zorder=3)
+    ax1.set_title(f"fit with recovered λ̂ = {lam_hat:.3f}")
+    ax1.set_xlabel("x"); ax1.set_ylabel("u(x)"); ax1.legend()
+    plt.tight_layout()
+    out = "inverse_memory_kernel.pdf"
+    plt.savefig(out, dpi=150, bbox_inches="tight")
+    plt.close()
+    print(f"  -> Saved: {out}")
+
+
+if __name__ == "__main__":
+    main()

fastlsq-0.4.0/examples/inverse/inverse_source_integral_sensors.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 Antonin Sulc
+# Licensed under the MIT License. See LICENSE file for details.
+
+"""
+Inverse problem with the definite integral as a *measurement operator*: recover a source from
+a bank of finite-aperture detectors.
+
+Real sensors rarely sample a field pointwise -- a photodiode, a thermocouple bead, a gravimeter
+all report the field *integrated over their aperture*.  So the data are window integrals
+
+        d_i = ∫_{a_i}^{b_i} u(x) dx,        i = 1 … N_det,
+
+of a field u that is itself generated by an unknown source f through the steady diffusion law
+
+        -u''(x) = f(x),   u(0) = u(1) = 0.
+
+We recover both the field u and the source f = -u'' from the (noisy) integrated readings alone.
+Each detector is one row of an ``IntegralOperator.definite`` design block -- the *exact* integral
+of every Fourier feature over the detector window -- so the forward measurement operator is
+assembled in closed form and the inverse is one regularised least-squares solve:
+
+        [ ∫_{a_i}^{b_i} φ ds ]            [ d_i ]
+        [   w · φ(0)         ]  · β  =    [  0  ]      ->   u(x)=φ(x)·β,   f(x)=-φ''(x)·β.
+        [   w · φ(1)         ]            [  0  ]
+
+Recovering a function from finitely many integral functionals is ill-posed, so the rank-revealing
+solver + a light Tikhonov ridge return the smoothest field consistent with the apertures and the
+boundary conditions.  The field u is recovered sharply; the source f = -u'' is harder (a second
+derivative amplifies measurement noise), which the error plot makes honest.
+
+Usage:  python inverse_source_integral_sensors.py
+"""
+
+import numpy as np
+import torch
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+from fastlsq import SinusoidalBasis, Op, IntegralOperator, solve_lstsq
+
+PI = np.pi
+
+
+def main():
+    torch.set_default_dtype(torch.float64)
+    torch.manual_seed(0)
+    rng = np.random.default_rng(0)
+
+    # ------------------------------------------------------------------
+    # Ground truth:  -u'' = f,  u(0)=u(1)=0,  multi-scale source
+    # ------------------------------------------------------------------
+    amps = [(1, 1.0), (3, 0.6), (5, 0.3)]                     # (mode k, amplitude)
+    f_true = lambda x: sum(a * torch.sin(k * PI * x) for k, a in amps)
+    u_true = lambda x: sum(a / (k * PI) ** 2 * torch.sin(k * PI * x) for k, a in amps)
+
+    # ------------------------------------------------------------------
+    # Detector bank: contiguous windows tiling [0, 1]; reading = ∫ window u
+    # ------------------------------------------------------------------
+    n_det = 32
+    edges = torch.linspace(0.0, 1.0, n_det + 1)
+    basis = SinusoidalBasis.random(input_dim=1, n_features=400, sigma=5.0, normalize=False)
+
+    det_rows, d_clean = [], []
+    for i in range(n_det):
+        a_i, b_i = float(edges[i]), float(edges[i + 1])
+        # one detector = exact closed-form integral of every feature over [a_i, b_i]
+        det_rows.append(IntegralOperator.definite(0, a_i, b_i, d=1).apply(basis, torch.zeros(1, 1)))
+        # true reading via fine quadrature of the exact field
+        xs = torch.linspace(a_i, b_i, 400)
+        d_clean.append(float(torch.trapz(u_true(xs), xs)))
+    A_det = torch.cat(det_rows)                                # (n_det, N)
+    d_clean = torch.tensor(d_clean).reshape(-1, 1)
+
+    noise_pct = 0.005                                          # 0.5 % detector noise
+    d_meas = d_clean + noise_pct * torch.std(d_clean) * torch.from_numpy(
+        rng.normal(0.0, 1.0, d_clean.shape))
+
+    # ------------------------------------------------------------------
+    # Inverse solve:  detectors + Dirichlet BCs, rank-revealing + light ridge
+    # ------------------------------------------------------------------
+    W_BC = 30.0
+    x_bc = torch.tensor([[0.0], [1.0]])
+    A = torch.cat([A_det, W_BC * basis.evaluate(x_bc)])
+    b = torch.cat([d_meas, torch.zeros(2, 1)])
+    beta = solve_lstsq(A, b, mu=1e-7)
+
+    # ------------------------------------------------------------------
+    # Recover field u and source f = -u'' ; report accuracy
+    # ------------------------------------------------------------------
+    xt = torch.linspace(0, 1, 400).reshape(-1, 1)
+    u_rec = (basis.evaluate(xt) @ beta).squeeze()
+    f_rec = (-Op.partial(0, 2, d=1).apply(basis, xt) @ beta).squeeze()
+    u_ref, f_ref = u_true(xt).squeeze(), f_true(xt).squeeze()
+    u_err = (torch.norm(u_rec - u_ref) / torch.norm(u_ref)).item()
+    f_err = (torch.norm(f_rec - f_ref) / torch.norm(f_ref)).item()
+    print(f"detectors: {n_det} windows, {noise_pct*100:.1f}% noise")
+    print(f"  field   u(x)        rel-L2 : {u_err:.2e}")
+    print(f"  source  f(x)=-u''   rel-L2 : {f_err:.2e}")
+
+    # ------------------------------------------------------------------
+    # Plot: recovered source | recovered field + detector readings
+    # ------------------------------------------------------------------
+    xg = xt.squeeze().numpy()
+    fig, (ax0, ax1) = plt.subplots(1, 2, figsize=(12, 4.2))
+    ax0.plot(xg, f_ref.numpy(), "k-", lw=2.5, label="true source f")
+    ax0.plot(xg, f_rec.numpy(), "C1--", lw=1.6, label="recovered  -u''")
+    ax0.set_title(f"source f(x)   (rel-L2 = {f_err:.1e})")
+    ax0.set_xlabel("x"); ax0.set_ylabel("f(x)"); ax0.legend()
+
+    ax1.plot(xg, u_ref.numpy(), "k-", lw=2.5, label="true field u")
+    ax1.plot(xg, u_rec.numpy(), "C1--", lw=1.6, label="recovered u")
+    centers = (0.5 * (edges[:-1] + edges[1:])).numpy()
+    widths = (edges[1:] - edges[:-1]).numpy()
+    ax1.bar(centers, (d_meas.squeeze() / torch.from_numpy(widths)).numpy(), width=widths * 0.9,
+            color="C0", alpha=0.25, label="detector readings (÷ width)")
+    ax1.set_title(f"field u(x) + integrating detectors   (rel-L2 = {u_err:.1e})")
+    ax1.set_xlabel("x"); ax1.set_ylabel("u(x)"); ax1.legend(fontsize=8)
+
+    fig.suptitle("Inverse source from finite-aperture detectors:  d_i = ∫ u  ->  recover u, f", y=1.02)
+    plt.tight_layout()
+    out = "inverse_source_integral_sensors.pdf"
+    plt.savefig(out, dpi=150, bbox_inches="tight")
+    plt.close()
+    print(f"  -> Saved: {out}")
+
+
+if __name__ == "__main__":
+    main()