FastLSQ 0.4.2__tar.gz → 0.6.0__tar.gz

{fastlsq-0.4.2 → fastlsq-0.6.0}/CHANGELOG.md

@@ -2,6 +2,262 @@
 
 All notable changes to FastLSQ will be documented in this file.
 
+## [0.6.0] - 2026-07-21
+
+Completes the operator taxonomy: multi-axis integrals, separable kernels, and
+Fredholm equations, with the integral-equation problems promoted into the same
+`solve_linear` harness as the PDEs so they report in one table.
+
+### New features
+
+| Feature | API | What it buys |
+|---|---|---|
+| Multi-axis integrals | `MultiIntegralOperator`, `SinusoidalBasis.multi_integral` | Integrate over any subset of axes at once, each independently definite or Volterra — area/volume functionals and mixed "definite in space, running in time" memory terms that a single-axis operator cannot express |
+| Separable (degenerate) kernels | `SeparableKernelOperator` | `K(x,y) = Σ g_m(x) h_m(y)` assembles as a rank-`R` product `G @ C`; the inner products `C` are computed once, independent of the collocation points |
+| Fredholm, second kind | `fredholm_second_kind` | `u − λ∫K u = f` as `I − λK`, solved in the same single least squares as everything else |
+| Kernel diagnostics | `degenerate_eigenvalues`, `check_quadrature` | The `λ` at which the equation is singular, and whether the inner-product quadrature actually resolves the basis — both failure modes that otherwise show up only as a bad fit |
+| Integral Problem classes | `fastlsq.problems.integral` | Four integral / integro-differential problems with **closed-form** solutions, running through `solve_linear` |
+
+### Added
+
+- **`MultiIntegralOperator` / `SinusoidalBasis.multi_integral`.** The plane wave
+  factorises over axes, `e^{iW·x} = ∏_k e^{iW_k x_k}`, so a multi-axis integral
+  is a *product* of the same numerically stable one-axis factors already used by
+  `definite_integral`, and the phase collapses to the value at the per-axis
+  midpoint:
+
+      ∫∫ φ_j ∏_{k∈S} dx_k = [∏_{k∈S} Δ_k · sinc(W_k Δ_k / 2π)] · sin(Z_mid)
+
+  Exact, quadrature-free, and finite for near-DC features on every axis. With
+  `|S| = 1` it reproduces `IntegralOperator.definite` bit-for-bit (verified to
+  1e-14); against tensor-product quadrature in 2-D and 3-D it agrees to the
+  quadrature's own error. Order is 1 per axis — a repeated integral along one
+  axis remains `IntegralOperator`, whose Cauchy/Taylor branches handle the
+  small-`W` cancellation a naive repeated product would suffer.
+
+- **`SeparableKernelOperator` (`fastlsq/kernels.py`).** A degenerate kernel
+  collapses the integral operator to `Σ_m g_m(x) ∫ h_m u`, so acting on the
+  basis needs only the `R × N` matrix `C_{mj} = ∫ h_m φ_j`. Assembly is
+  `G(x) @ C` — a rank-`R` factorisation instead of an `M × M` kernel evaluation,
+  and the assembled block's rank is exactly `R` (verified).
+
+  Quadrature enters in exactly one place, computing `C`, and it is a
+  precomputation rather than a per-row cost: tensor-product Gauss-Legendre,
+  spectrally convergent for smooth integrands. Because it must still resolve the
+  feature oscillation, `check_quadrature` reports the achieved convergence
+  (2e-14 for a typical basis; the test suite also pins that it *flags* an
+  under-resolved one), and `from_inner_products` accepts analytic `C` to skip
+  quadrature entirely.
+
+- **`fredholm_second_kind` and `degenerate_eigenvalues`.** Fredholm equations of
+  the second kind assemble as `I − λK`. For a rank-`R` degenerate kernel there
+  are at most `R` characteristic values, at which the equation is singular;
+  `degenerate_eigenvalues` computes them so a near-singular `λ` is detectable
+  instead of silently producing a garbage fit. For `K(x,y)=xy` on `[0,1]` it
+  recovers the analytic `λ = 3` as `3.0000000000000093`.
+
+  Validated against degenerate-kernel theory rather than a reference quadrature:
+  the exact solution of `u − λ∫₀¹xy·u = f` is `u = f + λcx` with
+  `c = ∫yf/(1−λ/3)`, matched to ~1e-8 for `λ` swept from 0.25 to 2.9 (i.e. right
+  up to the singular value). `λ` may be an `nn.Parameter`.
+
+- **`fastlsq/problems/integral.py`.** `FredholmProductKernel`,
+  `FredholmRank2Kernel`, `VolterraSecondKind` and `IntegroDifferentialODE`, each
+  with a closed-form solution, running through `solve_linear` exactly as the PDE
+  problems do — so integral equations now produce a results table alongside the
+  PDEs rather than living only in example scripts. The module docstring writes
+  down the (duck-typed, no base class) Problem contract, which was previously
+  implicit and inconsistent.
+
+  Note the second-kind problems return an **empty** `bcs` list: the identity term
+  makes them well posed with no boundary rows at all. Only the
+  integro-differential ODE, which has a genuine constant of integration, needs
+  one.
+
+- **Accuracy regressions (`tests/test_problems_integral.py`).** Each problem is
+  solved through the real harness and checked against its analytic solution, and
+  separately each closed form is verified to satisfy its own equation by
+  independent quadrature — so a closed form and an operator cannot be wrong in
+  the same direction without being caught.
+
+### Measured
+
+All five integral-equation problems, through `solve_linear` (300 features, 2000
+collocation points), against their closed-form solutions:
+
+| Problem | rel L2 | grad rel L2 | boundary rows |
+|---|---|---|---|
+| Fredholm `K=xy`, λ=0.5 | 5.5e-14 | 5.7e-12 | 0 |
+| Fredholm `K=xy`, λ=2.0 | 3.8e-13 | 3.9e-11 | 0 |
+| Fredholm rank-2, λ=0.4 | 9.1e-14 | 9.5e-12 | 0 |
+| Volterra 2nd kind, λ=1.5 | 8.8e-13 | 1.0e-10 | 0 |
+| Integro-differential ODE, λ=4.0 | 6.2e-16 | 1.7e-14 | 1 |
+
+Approaching the kernel's singular value `λ = 3` costs only ~2 orders of
+magnitude: 5.5e-14 at `λ = 0.5`, 6.8e-13 at `λ = 2.9`, 3.9e-12 at `λ = 2.99`.
+
+### Documentation
+
+- The README now tables the SDF primitives (`sdf_ball`, `sdf_disk`, `sdf_box`,
+  `sdf_annulus`, `sdf_lshape`, `sdf_flower`, `sdf_polygon`, `sdf_tokamak`) and
+  the CSG combinators (`sdf_union`, `sdf_intersection`, `sdf_difference`,
+  `sdf_complement`) by name. They were exported in `__all__` from 0.5.0 but only
+  described in prose, so the composable `ψ`-level API was effectively
+  undiscoverable — you could find `SDFDomain.disk()` but not `sdf_disk`, and the
+  CSG functions not at all.
+- `PolynomialColumns` is likewise named explicitly alongside `AugmentedBasis`.
+
+### Changed
+
+- **Operator composition is now duck-typed.** `IntegroDifferentialOperator._as_terms`
+  and `DiffOperator.__add__` dispatch on the presence of `.apply(basis, x, cache)`
+  rather than a fixed `isinstance` tuple, so operators defined in other modules
+  (`SeparableKernelOperator`, and any user-defined operator) compose with the
+  built-ins without `basis.py` importing them. No change to existing behaviour.
+
+## [0.5.0] - 2026-07-21
+
+Closes three gaps between what the paper describes and what the package shipped:
+SDF geometry (§2.7), Fourier-symbol operators (§3.4), and explicit polynomial
+augmentation columns (§2.3).
+
+### Added
+
+- **SDF / membership-oracle geometry (`fastlsq.geometry`).** A domain can now be
+  given as any callable `ψ(x)` that is negative inside — no mesh, no analytic
+  sampler. `sample_sdf` rejection-samples the interior (unbiased, so the radial
+  CDF of a disk is exactly `r²`), `project_to_boundary` lands points on `ψ = 0`,
+  and `outward_normal` returns `∇ψ/‖∇ψ‖` via autograd, which is what a Neumann or
+  Robin condition needs. `SDFDomain` bundles these with a bounding box and CSG
+  composition (`|`, `&`, `-`), plus `neumann_rows` / `robin_rows` that contract
+  the analytic basis gradient against the normal into an `(M, N)` block.
+
+  Shipped domains: `disk`, `ball`, `box`, `annulus` (multiply-connected),
+  `lshape` (reentrant corner), `flower` (smooth non-convex), `polygon`, and
+  `tokamak` — the D-shaped Miller poloidal cross-section, at the same MAST-U
+  scale (`R ∈ [0.6, 1.4]`) as `examples/grad_shafranov.py`, which until now used
+  a plain rectangle.
+
+  Projection is **damped** Newton, `x ← x − ψ∇ψ/‖∇ψ‖²`, with per-point
+  backtracking and monotone acceptance. The `1/‖∇ψ‖²` normalisation matters:
+  the textbook `x − ψ∇ψ` is valid only for a true distance function, and
+  `sdf_flower` has `‖∇ψ‖` spanning 1 to ~10. Undamped, it left 
+  `|ψ| ≈ 1.5e-1` on the boundary; damped and monotone, 99.9% of interior seeds
+  converge to `1e-10`. The residual failures are seeds within `r < 0.2` of the
+  centre, where a non-distance `ψ` has no unique nearest boundary point;
+  `sample_boundary_sdf` filters them rather than hiding them.
+
+- **`SymbolOperator` — Fourier-multiplier (nonlocal) operators.** Every feature
+  is a plane wave, so a multiplier `L e^{iξ·x} = m(ξ) e^{iξ·x}` acts *diagonally*
+  on the basis: assembling `L` is a per-column rescale, exact to machine
+  precision, with no quadrature and no discretisation of the kernel. Operators
+  that are hard for mesh methods — the fractional Laplacian is nonlocal with a
+  singular kernel, giving a dense ill-conditioned FEM/FD matrix — cost exactly
+  what the Laplacian costs here.
+
+  Factories: `fractional_laplacian(s)`, `riesz_potential(s)`,
+  `riesz_transform(k)`, `convolution(k̂)`. The order `s` may be an
+  `nn.Parameter`: the symbol is `exp(s·log‖ξ‖²)`, so gradient descent recovers a
+  planted order (test recovers `s = 0.65` to `<1e-3`). Composes with `Op` and
+  `IntegralOperator` through the usual arithmetic.
+
+  Verified against independent references, not just self-consistency: `s=1`
+  reproduces `−Δ` and `s=2` reproduces `Δ²` bit-exactly; the symbol is checked
+  against the **singular-integral definition** including its normalising constant
+  `C(1,s)`; and Gaussian convolution matches direct quadrature to `<1e-8`.
+
+  `ConvolutionOperator` is `SymbolOperator.convolution(k̂)` — this is what
+  `examples/memory_diffusion.py:80` was doing by hand with a `(1, N)` broadcast
+  coefficient. That hand-rolled version uses `basis.W[0:1, :]`, correct only
+  because `d=2` has exactly one spatial axis; a symbol sees all of `W` and
+  generalises to any dimension.
+
+- **Polynomial / DC augmentation columns (`fastlsq.augment`).** `AugmentedBasis`
+  widens a basis with explicit `1, x, x², …` columns carrying **exact** operator
+  images — analytic monomial derivatives, antiderivatives (a negative multi-index
+  integrates: `x^p → x^{p+1}/(p+1)`), and Cauchy iterated integrals — not a
+  zero-derivative stub. It implements the same duck-typed protocol as
+  `SinusoidalBasis`, so `Op`, `IntegralOperator` and `SymbolOperator` all work
+  unchanged and return `(M, N + n_cols)`.
+
+  This is what §2.3 means by an integration constant "pinned by an explicit
+  polynomial column"; previously the only such column in the repo was hand-rolled
+  in `examples/extras/scenarios/s01_beamloss_ode.py`, which had to maintain its
+  derivative block by hand.
+
+  Scope, honestly: a sinusoidal bank with random phases can already approximate a
+  constant from near-DC features, so this is an improvement, not a rescue — on
+  `u'' = f` with a DC offset it is neutral at `C = 0` and ~12× better at
+  `C = 1000`. A non-constant monomial has no function-valued Fourier-multiplier
+  image, so `SymbolOperator` on `degree > 0` columns raises rather than inventing
+  a value.
+
+### Fixed
+
+- **`ProjectionOperator`'s docstring claimed the Fourier-symbol operators were
+  "already in the package".** They were not, until this release. It now points at
+  `SymbolOperator` and states the actual distinction (a symbol acts diagonally;
+  a projection row mixes features).
+
+### Notes
+
+- **Which fractional Laplacian.** The symbol calculus applies the multiplier to
+  the global plane-wave extension of the trial function, so
+  `fractional_laplacian` is the **whole-space (restricted)** `(−Δ)^s` on `R^d`,
+  *not* the spectral or regional variant defined by an eigenbasis of a bounded
+  domain. These coincide on `R^d` and differ on a bounded domain. Results should
+  not be read as the spectral fractional Laplacian.
+
+- Boundary points from `sample_boundary_sdf` are **not** uniform with respect to
+  surface measure — they are the pushforward of the uniform box measure under the
+  projection, which over-weights convex bulges. Fine for collocation; do not use
+  them as quadrature nodes for a surface integral without reweighting.
+
+## [0.4.3] - 2026-07-20
+
+### Fixed
+
+- **The Σ-learner trained uphill: `train_bandwidth` now uses the exact envelope
+  gradient.** The outer loss was backpropagated *through* `torch.linalg.lstsq`,
+  whose backward carries a `(AᵀA)⁻¹` and therefore squares `cond(A)`. For a
+  routine collocation system (`cond(A) ≈ 2.2e11` on the `AnisoPoisson` benchmark)
+  that needs ~5e22 of dynamic range, far past float64. Measured against central
+  finite differences at the isotropic init, the resulting "gradient" was **4.3e6×
+  too large with `cos(angle) = −0.707`** — an *ascent* direction, which `AdamW`
+  duly followed (`clip_grad` rescaled the magnitude but preserved the direction).
+  `fit()` consequently returned a solution ~3.6× *worse* than the isotropic
+  `solve_linear` baseline it is meant to beat.
+
+  The inner solve is now performed under `no_grad` and only the assembled `A(L)`
+  is differentiated. This is **exact, not an approximation**: for
+  `J(L) = ‖A(L)β* − b‖²` the chain-rule contribution through `β*` is
+  `2 (Aᵀr)ᵀ dβ*/dL`, and `Aᵀr = 0` at the least-squares optimum (the residual is
+  orthogonal to `range(A)`), so the term vanishes identically and
+  `dJ/dL = 2 rᵀ (dA/dL) β*` — the envelope (Danskin) theorem. The detached
+  gradient matches finite differences to **1.2e-3 relative, `cos(angle) = 1.0000`**,
+  and skips the ill-conditioned backward entirely.
+
+  On the `AnisoPoisson` benchmark the training loss now descends monotonically
+  (`1.9e-3` → `9.8e-11`) instead of climbing (`1.9e-3` → `1.2e+05`), an
+  independent held-out collocation draw tracks it the whole way (no overfitting),
+  and the learned Σ reaches `4.4e-8` against the isotropic `solve_linear`
+  baseline's `1.9e-4` — **~4350× better**, where it was previously ~3.6× *worse*.
+  Not backpropagating through the solve also makes each step ~6× cheaper
+  (`tests/test_learnable.py`: 389s → 57s).
+
+  Note this is the *third* attempt at this bug (see 0.2.1 and 0.2.2): both earlier
+  fixes swapped the inner solve's driver (`svd` → rank-revealing `gelsd`) to stop
+  the gradient being `NaN`. That made it **finite but never correct** — the loop
+  still differentiated through the solve. Differentiating through an
+  ill-conditioned least-squares solve is not stabilisable by choice of driver;
+  the envelope identity removes the need to do it at all.
+- **`train_bandwidth` restored the wrong "best" iterate.** `best_params` was
+  snapshotted *after* `optimizer.step()`, so it stored `θ_{t+1}` while recording
+  `loss(θ_t)` — the best-iterate restore returned the successor of the best
+  iterate. The snapshot (and the `history` entry's `sigma` / `cov_diag`, which had
+  the same off-by-one) now happens before the step, so all three describe the same
+  point.
+
 ## [0.4.2] - 2026-07-20
 
 ### Fixed

{fastlsq-0.4.2 → fastlsq-0.6.0}/FastLSQ.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FastLSQ
-Version: 0.4.2
+Version: 0.6.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
@@ -159,6 +159,128 @@ A_pde = helmholtz.apply(basis, x)    # (5000, 1500)
 wave = Op.partial(dim=2, order=2, d=3) - c**2 * Op.laplacian(d=3, dims=[0, 1])
 ```
 
+### Nonlocal operators (fractional Laplacian, convolution)
+
+Every feature is a plane wave, so a Fourier multiplier `m(ξ)` acts **diagonally**
+on the basis -- assembling it is a per-column rescale, exact, with no quadrature
+and no discretisation of the (singular, nonlocal) kernel:
+
+```python
+from fastlsq.basis import SinusoidalBasis, SymbolOperator, Op
+
+basis = SinusoidalBasis.random(input_dim=2, n_features=1500, sigma=5.0)
+
+frac = SymbolOperator.fractional_laplacian(s=0.75)   # (−Δ)^0.75
+A    = frac.apply(basis, x)                          # (M, 1500), one rescale
+
+# Mixes freely with differential terms
+L = SymbolOperator.fractional_laplacian(0.5) + 3.0 * Op.identity(d=2)
+
+# Convolution from the kernel's transform; s may be an nn.Parameter, so the
+# fractional order itself can be recovered by gradient descent.
+K = SymbolOperator.convolution(lambda W: torch.exp(-(W**2).sum(0, keepdim=True) / 12))
+```
+
+`s=1` reproduces `−Δ` bit-exactly. Note this is the **whole-space (restricted)**
+`(−Δ)^s`, not the spectral variant defined on a bounded domain -- the two differ
+once the domain is bounded.
+
+### Integral equations (Fredholm, Volterra, separable kernels)
+
+A separable kernel `K(x,y) = Σ g_m(x) h_m(y)` collapses the integral operator to
+`Σ_m g_m(x) ∫ h_m u`, so acting on the basis needs only an `R × N` matrix of
+inner products, computed once. A Fredholm equation of the second kind is then
+one linear least squares like everything else:
+
+```python
+from fastlsq import SeparableKernelOperator, fredholm_second_kind, degenerate_eigenvalues
+
+# u(x) − λ ∫₀¹ x y u(y) dy = f(x)
+K = SeparableKernelOperator([lambda x: x[:, 0]],      # g_m
+                            [lambda y: y[:, 0]],      # h_m
+                            lower=0.0, upper=1.0, d=1)
+
+print(degenerate_eigenvalues(K, basis))    # λ where the equation is singular → 3.0
+print(K.check_quadrature(basis))           # are the inner products resolved?
+
+L = fredholm_second_kind(K, lam=0.5, d=1)
+beta = solve_lstsq(L.apply(basis, x), f(x))
+```
+
+Second-kind equations need **no boundary rows** — the identity term makes them
+well posed on its own. Integration over several axes at once (definite, running,
+or mixed) is `MultiIntegralOperator`:
+
+```python
+from fastlsq import MultiIntegralOperator
+
+area = MultiIntegralOperator.definite([0, 1], [0, 0], [1, 1], d=2)   # ∫∫ over a box
+memory = MultiIntegralOperator([0, 1], [0.0, 0.0], d=2, uppers=[1.0, None])  # definite × running
+```
+
+Ready-made problems with closed-form solutions live in `fastlsq.problems` and run
+through `solve_linear` like the PDEs (`PYTHONPATH=. python3
+examples/integral_equations.py`, 300 features, 2000 collocation points):
+
+| Problem | rel L2 | grad rel L2 | boundary rows |
+|---|---|---|---|
+| `FredholmProductKernel(lam=0.5)` | 5.5e-14 | 5.7e-12 | 0 |
+| `FredholmProductKernel(lam=2.0)` | 3.8e-13 | 3.9e-11 | 0 |
+| `FredholmRank2Kernel(lam=0.4)` | 9.1e-14 | 9.5e-12 | 0 |
+| `VolterraSecondKind(lam=1.5)` | 8.8e-13 | 1.0e-10 | 0 |
+| `IntegroDifferentialODE(lam=4.0)` | 6.2e-16 | 1.7e-14 | 1 |
+
+Errors are against the **closed-form** solutions (degenerate-kernel theory for
+the Fredholm cases, the equivalent ODE for the Volterra ones), not a reference
+quadrature. Accuracy degrades gracefully toward the kernel's singular value --
+for `K = xy`, whose only characteristic value is `λ = 3`, the error moves from
+5.5e-14 at `λ = 0.5` to 3.9e-12 at `λ = 2.99`.
+
+### Complex geometry without a mesh
+
+A domain is any callable that is negative inside. Interior points come from
+rejection sampling, boundary points from projection onto `ψ = 0`, and outward
+normals from `∇ψ/‖∇ψ‖` -- which is exactly what Neumann and Robin conditions need:
+
+```python
+from fastlsq.geometry import SDFDomain
+
+dom = SDFDomain.annulus(0.3, 1.0)         # or .disk() .lshape() .flower() .tokamak()
+x   = dom.sample(4000)                    # interior collocation
+xb  = dom.sample_boundary(600)            # boundary collocation
+B   = dom.neumann_rows(basis, xb)         # (M, N) block for ∂u/∂n = g
+
+# Non-convex and multiply-connected domains are built, not meshed
+plate = SDFDomain.disk(1.0) - SDFDomain.disk(0.2, center=(0.4, 0.0))
+```
+
+Built-in domains, as `SDFDomain` constructors or as bare `ψ` callables:
+
+| Domain | `SDFDomain` | Bare `ψ` | Why it's there |
+|---|---|---|---|
+| Ball / disk | `.ball()`, `.disk()` | `sdf_ball`, `sdf_disk` | Exact SDF, any dimension; the §2.7 unit disk |
+| Axis-aligned box | `.box(lo, hi)` | `sdf_box` | Exact inside and out; the CSG building block |
+| Annulus / shell | `.annulus(r_in, r_out)` | `sdf_annulus` | **Multiply-connected** — an interior boundary whose outward normal points toward the centre |
+| L-shape | `.lshape(size, cut)` | `sdf_lshape` | **Reentrant corner**, the standard non-convex stress case (`r^{2/3}` solution singularity) |
+| Flower | `.flower(R, a, k)` | `sdf_flower` | Smooth non-convex, and deliberately **not** a distance function (`‖∇ψ‖` spans 1–10) — the case that separates a correct projection from a naive one |
+| Polygon | — | `sdf_polygon(verts)` | Exact for any simple polygon; the escape hatch for a cross-section known only as a curve (measured, CAD, traced) |
+| Tokamak | `.tokamak()` | `sdf_tokamak` | D-shaped Miller poloidal cross-section, via `sdf_polygon` |
+
+Any `ψ` of your own works too — it only has to be negative inside. Combine them
+with the CSG helpers, which are also available as plain functions:
+
+| Set operation | Operator | Function |
+|---|---|---|
+| Union `A ∪ B` | `A \| B` | `sdf_union(a, b)` |
+| Intersection `A ∩ B` | `A & B` | `sdf_intersection(a, b)` |
+| Difference `A \ B` | `A - B` | `sdf_difference(a, b)` |
+| Complement | — | `sdf_complement(a)` |
+
+CSG results are valid implicit functions (correct sign everywhere) but not
+generally exact distance functions — `min`/`max` of two exact SDFs over- or
+under-estimates distance near the seam. Nothing here depends on exactness:
+sampling uses only the sign, and `project_to_boundary` normalises by `‖∇ψ‖²`.
+
 ### Vector-valued solutions
 
 `solve_linear` / `solve_nonlinear` support vector-valued **u**: ℝᵈ → ℝᵏ for
@@ -279,7 +401,12 @@ derivative engine:
 | `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, including `order=n` **iterated** integrals `∫_lo^x (x−t)^{n−1}/(n−1)! φ dt`; compose with `Op` into one integro-differential design matrix |
+| `MultiIntegralOperator` | Closed-form integration over **several axes at once**, each independently definite or Volterra -- area/volume functionals and mixed "definite in space, running in time" memory terms. The plane wave factorises over axes, so it is a product of the same stable one-axis factors |
+| `SeparableKernelOperator` | Separable (degenerate) kernels `K(x,y) = Σ g_m(x) h_m(y)`, assembled as a rank-`R` product `G @ C` with the inner products `C` precomputed once. With `fredholm_second_kind` this makes `u − λ∫K u = f` one linear least squares |
+| `SymbolOperator` | **Fourier-multiplier (nonlocal)** operators `L e^{iξ·x} = m(ξ) e^{iξ·x}`. Features *are* plane waves, so the symbol acts diagonally -- a per-column rescale, exact, no quadrature. Ships `fractional_laplacian(s)` (with learnable `s`), `riesz_potential`, `riesz_transform`, `convolution(k̂)` |
 | `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` |
+| `AugmentedBasis` / `PolynomialColumns` | Widens a basis with explicit `1, x, x², …` columns carrying **exact** operator images, to pin integration constants and DC modes that leave the sinusoidal family. Transparent to every operator |
+| `SDFDomain` + `sample_sdf` / `project_to_boundary` / `outward_normal` | **Membership-oracle geometry**: give any `ψ(x)` negative inside and get interior points, boundary points and outward normals -- no mesh. CSG composition via `\|`, `&`, `-`; built-ins include disk, annulus, L-shape, flower, polygon and a tokamak cross-section |
 | `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 |
@@ -370,7 +497,10 @@ 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
+- **Integral equations**: Separable (degenerate) kernels `K = Σ g_m(x) h_m(y)` assemble as a rank-`R` product with inner products precomputed once, so a Fredholm equation of the second kind `u − λ∫K u = f` is a single linear least squares needing **no boundary rows**. `degenerate_eigenvalues` reports the `λ` at which the equation is singular and `check_quadrature` whether the inner products are resolved -- both otherwise-silent failure modes. `MultiIntegralOperator` integrates over several axes at once, each independently definite or Volterra
+- **Nonlocal / Fourier-symbol operators**: `SymbolOperator` assembles any multiplier `m(ξ)` as a per-column rescale -- exact, quadrature-free, and the same cost as the Laplacian. Covers the **fractional Laplacian** `(−Δ)^s` (with a *learnable* order `s`), Riesz potentials and transforms, and **convolution** `k * u` from the kernel transform `k̂`. Operators whose kernels are singular and nonlocal -- dense, ill-conditioned matrices for FEM/FD -- are diagonal here
 - **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
+- **Augmentation columns**: `AugmentedBasis` + `PolynomialColumns` widen the basis with exact `1, x, x², …` columns to pin integration constants and DC modes that leave the sinusoidal family -- transparent to every operator
 - **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
 - **Learnable bandwidth**: `LearnableFastLSQ` optimises the bandwidth (scalar or anisotropic) via reparameterisation
@@ -380,6 +510,7 @@ See `examples/add_your_own_pde.py` for the complete tutorial.
 - **Adaptive collocation**: `n_pde` / `n_bc` default to feature-count-scaled values, overridable per solve
 - **Built-in plotting**: Solution visualization, convergence plots, spectral sensitivity
 - **Geometry samplers**: Box, ball, sphere, interval, custom samplers
+- **Meshless complex geometry**: `SDFDomain` takes any membership oracle `ψ(x)` (negative inside) and supplies interior points, boundary points and outward normals `∇ψ/‖∇ψ‖` for Neumann/Robin conditions. CSG composition (`|`, `&`, `-`) builds non-convex and multiply-connected domains; built-ins include disk, annulus, L-shape, flower, arbitrary polygon, and a D-shaped tokamak poloidal cross-section
 - **Diagnostics**: Problem validation, conditioning checks, error detection
 - **Export utilities**: NumPy conversion, checkpoint saving/loading
 - **PyTorch Lightning**: Integration for training loops

{fastlsq-0.4.2 → fastlsq-0.6.0}/FastLSQ.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ examples/grid_rl_control.py
 examples/grid_swing.py
 examples/gs_inverse.py
 examples/gs_rl_control.py
+examples/integral_equations.py
 examples/integro_differential_demo.py
 examples/inverse_heat_source.py
 examples/inverse_magnetostatics.py
@@ -32,6 +33,7 @@ examples/rlc_integro_differential.py
 examples/run_all_extensions.py
 examples/run_linear.py
 examples/run_nonlinear.py
+examples/sdf_domains.py
 examples/tutorial_basic.py
 examples/tutorial_nonlinear.py
 examples/vector_basis_stream_vorticity.py
@@ -78,6 +80,7 @@ examples/extras/scenarios/s14_eeg.py
 examples/extras/scenarios/s15_circadian.py
 fastlsq/__init__.py
 fastlsq/api.py
+fastlsq/augment.py
 fastlsq/basis.py
 fastlsq/benchmark.py
 fastlsq/block.py
@@ -85,6 +88,7 @@ fastlsq/device.py
 fastlsq/diagnostics.py
 fastlsq/export.py
 fastlsq/geometry.py
+fastlsq/kernels.py
 fastlsq/learnable.py
 fastlsq/lightning.py
 fastlsq/linalg.py
@@ -96,19 +100,26 @@ fastlsq/utils.py
 fastlsq/vector.py
 fastlsq/viz.py
 fastlsq/problems/__init__.py
+fastlsq/problems/integral.py
 fastlsq/problems/linear.py
 fastlsq/problems/nonlinear.py
 fastlsq/problems/regression.py
+tests/test_augment.py
 tests/test_basic.py
 tests/test_benchmarks_inverse.py
 tests/test_block.py
 tests/test_derivatives.py
 tests/test_device.py
 tests/test_diagnostics_timing.py
+tests/test_geometry_sdf.py
 tests/test_grad_shafranov.py
 tests/test_grid_swing.py
 tests/test_integral.py
+tests/test_kernels.py
 tests/test_learnable.py
+tests/test_multi_integral.py
 tests/test_orbit_hill.py
+tests/test_problems_integral.py
 tests/test_projection.py
+tests/test_symbol.py
 tests/test_vector_basis.py