FastLSQ 0.2.3__tar.gz → 0.2.5__tar.gz

{fastlsq-0.2.3 → fastlsq-0.2.5}/CHANGELOG.md

@@ -2,6 +2,60 @@
 
 All notable changes to FastLSQ will be documented in this file.
 
+## [0.2.5] - 2026-06-04
+
+### Fixed
+
+- **`Wave2D_MS` solves via `solve_linear`.** The long-time anisotropic wave
+  returned relative value error 1.0 in every configuration because its
+  `t_max = 100` time normalisation packed ~87 temporal cycles into `tau ∈ [0,1]`:
+  the PDE's second time-derivative amplifies the random-feature *representation*
+  error by `Omega²` (`Omega = pi·sqrt(1+a2)·t_max`), so the one-shot
+  least-squares collocation cannot resolve the oscillation -- even 8000 features
+  with near-hard boundary constraints stay at rel-err 1.0, because the best
+  representable solution itself carries a huge PDE residual. Reducing `t_max` to
+  `4` (~3.5 cycles) and matching the anisotropic temporal feature bandwidth to
+  `Omega` (`scale_multipliers = [1, 1, 7]`) recovers the solution to ~3e-4 at
+  900 features (`scale = 3`); the exactly-consistent `t_max²`-scaled operator is
+  unchanged. Added to the `tests/test_benchmarks_inverse.py` linear smoke test.
+  Resolves the `Wave2D_MS` [0.2.4] known issue.
+- **`ElasticWave2D` solves via the block-stacked vector path.** The coupled
+  2-output elastic-wave problem now declares `n_outputs = 2`, assembles its
+  operator in block-stacked form (`A ∈ ℝ^{Mk×Nk}`, `b ∈ ℝ^{Mk×1}`) via
+  `block_concat`, and gains the `exact_grad` Jacobian (shape `(M, d, k)`, time
+  axis chain-ruled by `t_max`) that the error metric requires. `unpack_beta` now
+  recovers a `(N, 2)` `beta`, so `solve_linear(ElasticWave2D(), scale=5.0)`
+  recovers both components (relative value error ~7e-3 at the default
+  resolution) instead of failing to unpack the vector solution. Added to the
+  `tests/test_benchmarks_inverse.py` linear smoke test. Resolves the
+  `ElasticWave2D` [0.2.4] known issue; the `t_max²` operator scaling from
+  [0.2.2] (consistent with `Wave2D_MS`) is preserved.
+
+## [0.2.4] - 2026-06-04
+
+### Added
+
+- **Benchmark + inverse-problem test suite** (`tests/test_benchmarks_inverse.py`):
+  12 deterministic smoke tests (~11 s) that solve the linear (`PoissonND`,
+  `HeatND`, `Wave1D`, `Helmholtz2D`, `Maxwell2D_TM`) and nonlinear
+  (`NLPoisson2D`, `Bratu2D`, `SteadyBurgers1D`, `NLHelmholtz2D`, `AllenCahn1D`)
+  benchmark equations through the public `solve_linear` / `solve_nonlinear` API,
+  plus two inverse pipelines -- Gaussian source-position recovery (forward solve
+  + L-BFGS) and SINDy-style PDE discovery via analytical derivatives --
+  exercising the 0.2.3 QR / N-scaled-collocation solver path end to end.
+
+### Known issues
+
+- `Wave2D_MS` does not solve via `solve_linear` (relative error 1.0 in every
+  configuration tested) -- a pre-existing problem-definition gap, independent of
+  the solver work, excluded from the new smoke test pending a fix. *(Fixed in
+  [0.2.5]: `t_max` reduced 100 -> 4 so the normalised-time oscillation
+  (~3.5 vs ~87 cycles) is resolvable; now covered by the smoke test.)*
+- `ElasticWave2D` -- a 2-output vector problem whose `exact()` returns `(N, 2)`
+  -- never sets `n_outputs`, so the scalar API cannot unpack it; also excluded
+  here. *(Fixed in [0.2.5]: it now uses the block-stacked vector path and
+  is covered by the smoke test.)*
+
 ## [0.2.3] - 2026-06-04
 
 ### Added

{fastlsq-0.2.3 → fastlsq-0.2.5}/FastLSQ.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FastLSQ
-Version: 0.2.3
+Version: 0.2.5
 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
@@ -55,9 +55,12 @@ analytical derivative engine for random Fourier features.  For sinusoidal
 features `phi_j(x) = sin(W_j . x + b_j)`, every derivative of every order
 admits an exact closed-form expression -- no automatic differentiation needed.
 
-Linear PDEs are solved in a single least-squares step; nonlinear PDEs are
-solved via Newton-Raphson iteration with Tikhonov regularisation,
-1/sqrt(N) feature normalisation, and continuation/homotopy.
+Linear PDEs are solved in a single least-squares step.  The random-feature
+system is typically rank-deficient, so the solve is routed through a
+backward-stable, auto-selected least-squares back-end (Cholesky fast-path ->
+Householder QR -> rank-revealing SVD) that runs on CPU, CUDA, or Apple-MPS.
+Nonlinear PDEs are solved via Newton-Raphson iteration with Tikhonov
+regularisation, 1/sqrt(N) feature normalisation, and continuation/homotopy.
 
 ## Installation
 
@@ -68,7 +71,7 @@ pip install fastlsq
 For development (includes testing and build tools):
 
 ```bash
-git clone https://github.com/asulc/FastLSQ.git
+git clone https://github.com/sulcantonin/FastLSQ.git
 cd FastLSQ
 pip install -e ".[dev]"
 ```
@@ -101,6 +104,26 @@ print(f"Converged in {result['n_iters']} iterations")
 print(f"Value error: {result['metrics']['val_err']:.2e}")
 ```
 
+### Choose a solver back-end and device
+
+The linear solve is routed automatically, but `solve_linear` exposes the
+back-end via `method=` (see [How it works](#how-it-works) for the routing):
+
+```python
+from fastlsq import solve_linear, set_device
+from fastlsq.problems.linear import PoissonND
+
+# "auto" (default) -- Cholesky fast-path -> QR -> rank-revealing SVD
+# "qr"             -- Householder QR; SVD-grade accuracy at QR cost (full-rank A)
+# "svd"            -- rank-revealing truncated SVD; the rank-deficient-safe reference
+# "cholesky"       -- normal-equations Cholesky; fast, well-conditioned A only
+# "rsvd"           -- randomized SVD, O(MNk), for strongly low-rank A
+result = solve_linear(PoissonND(), scale=5.0, method="qr")
+
+# Device selection (CPU / CUDA / Apple-MPS), or set FASTLSQ_DEVICE=cuda
+set_device("cuda")   # the float64 default stays on CPU/CUDA; MPS is float32-only
+```
+
 ### Use the basis directly
 
 ```python
@@ -204,9 +227,10 @@ u_yy = A @ solver.beta                           # (M, k): ∂²u/∂y² per com
 
 Scalar problems are untouched: `n_outputs` defaults to `1`, `solver.beta` keeps
 shape `(N, 1)`, and `predict_with_grad` returns gradient shape `(M, d)` for
-backward compatibility (the trailing component axis is squeezed when k=1).
-`ElasticWave2D` in [fastlsq/problems/linear.py](fastlsq/problems/linear.py) is
-the canonical coupled vector example.
+backward compatibility (the trailing component axis is squeezed when k=1). The
+`Stokes2D` sketch above and [tests/test_block.py](tests/test_block.py) -- a
+runnable `block_concat` + `unpack_beta` solve that recovers both components of a
+k=2 system -- are the reference for the block-stacked vector path.
 
 ### Plot solutions
 
@@ -258,11 +282,15 @@ derivative engine:
 | `FastLSQSolver` | Manages feature blocks; exposes `.basis` for all derivative computations |
 | `LearnableFastLSQ` | Differentiable solver with learnable bandwidth via reparameterisation trick |
 | `block_concat`, `pack_beta`, `unpack_beta` | Block-structured assembly helpers for vector-valued **u** (coupled systems). `solver.beta` has shape `(N, k)`; scalar problems are the k=1 case |
+| `solve_lstsq` | Multi-back-end least-squares solve (`auto`/`qr`/`svd`/`cholesky`/`rsvd`); rank-revealing by default for the rank-deficient feature matrix |
+| `resolve_device` / `set_device` / `get_device` | CPU / CUDA / Apple-MPS selection, dtype-aware (MPS is float32-only; factorizations fall back to CPU) |
 
 ### How it works
 
 1. **Basis construction.** Given collocation points **x**, construct a
-   `SinusoidalBasis` with random weights W and biases b.
+   `SinusoidalBasis` with random weights W and biases b. The collocation counts
+   default to scale with the feature count
+   (`n_pde = max(3000, 3 * n_blocks * hidden_size)`, `n_bc = max(800, n_pde // 5)`).
 
 2. **Analytical derivatives.** Exploit the cyclic derivative identity:
    the n-th derivative of sin(z) cycles through {sin, cos, -sin, -cos}
@@ -273,8 +301,13 @@ derivative engine:
    (e.g. `Op.laplacian(d=2)`) and apply it to the basis to get the system
    matrix `A`.
 
-4. **Linear solve.** Solve `A beta = b` via least squares
-   (optionally Tikhonov-regularised).
+4. **Linear solve.** Solve `A beta = b` in the least-squares sense. The
+   random-feature matrix `A` is typically rank-deficient (near-duplicate
+   columns), so the default `method="auto"` starts from a Cholesky fast-path
+   (guarded by a cheap conditioning probe), falls back to backward-stable
+   Householder **QR**, and resorts to a rank-revealing **SVD** only if the QR
+   solution blows up. A Tikhonov ridge `mu` enters via the `[A; sqrt(mu) I]`
+   augmentation, not the condition-squaring normal equations.
 
 5. **Newton iteration (nonlinear).** Linearise the PDE residual, solve
    `J delta_beta = -R` with backtracking line search, and repeat.
@@ -336,9 +369,12 @@ See `examples/add_your_own_pde.py` for the complete tutorial.
 - **Symbolic PDE operators**: Compose differential operators with `Op` (Laplacian, wave, Helmholtz, biharmonic, custom) via intuitive arithmetic; coefficients can be `nn.Parameter` for AdamW optimisation
 - **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
 - **Learnable bandwidth**: `LearnableFastLSQ` optimises the bandwidth (scalar or anisotropic) via reparameterisation
 - **Learnable PDE coefficients**: Plug `nn.Parameter` into `Op` (e.g. Helmholtz wavenumber `k`) and optimise via AdamW; gradients flow through the prebuilt linear solve
 - **Auto-tuning**: Automatic scale selection via grid search
+- **Device support**: CPU / CUDA / Apple-MPS via `set_device()` or the `FASTLSQ_DEVICE` env var, dtype-aware (the float64 high-accuracy path stays on CPU/CUDA)
+- **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
 - **Diagnostics**: Problem validation, conditioning checks, error detection

{fastlsq-0.2.3 → fastlsq-0.2.5}/FastLSQ.egg-info/SOURCES.txt

@@ -96,6 +96,7 @@ fastlsq/problems/linear.py
 fastlsq/problems/nonlinear.py
 fastlsq/problems/regression.py
 tests/test_basic.py
+tests/test_benchmarks_inverse.py
 tests/test_block.py
 tests/test_derivatives.py
 tests/test_device.py

{fastlsq-0.2.3 → fastlsq-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FastLSQ
-Version: 0.2.3
+Version: 0.2.5
 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
@@ -55,9 +55,12 @@ analytical derivative engine for random Fourier features.  For sinusoidal
 features `phi_j(x) = sin(W_j . x + b_j)`, every derivative of every order
 admits an exact closed-form expression -- no automatic differentiation needed.
 
-Linear PDEs are solved in a single least-squares step; nonlinear PDEs are
-solved via Newton-Raphson iteration with Tikhonov regularisation,
-1/sqrt(N) feature normalisation, and continuation/homotopy.
+Linear PDEs are solved in a single least-squares step.  The random-feature
+system is typically rank-deficient, so the solve is routed through a
+backward-stable, auto-selected least-squares back-end (Cholesky fast-path ->
+Householder QR -> rank-revealing SVD) that runs on CPU, CUDA, or Apple-MPS.
+Nonlinear PDEs are solved via Newton-Raphson iteration with Tikhonov
+regularisation, 1/sqrt(N) feature normalisation, and continuation/homotopy.
 
 ## Installation
 
@@ -68,7 +71,7 @@ pip install fastlsq
 For development (includes testing and build tools):
 
 ```bash
-git clone https://github.com/asulc/FastLSQ.git
+git clone https://github.com/sulcantonin/FastLSQ.git
 cd FastLSQ
 pip install -e ".[dev]"
 ```
@@ -101,6 +104,26 @@ print(f"Converged in {result['n_iters']} iterations")
 print(f"Value error: {result['metrics']['val_err']:.2e}")
 ```
 
+### Choose a solver back-end and device
+
+The linear solve is routed automatically, but `solve_linear` exposes the
+back-end via `method=` (see [How it works](#how-it-works) for the routing):
+
+```python
+from fastlsq import solve_linear, set_device
+from fastlsq.problems.linear import PoissonND
+
+# "auto" (default) -- Cholesky fast-path -> QR -> rank-revealing SVD
+# "qr"             -- Householder QR; SVD-grade accuracy at QR cost (full-rank A)
+# "svd"            -- rank-revealing truncated SVD; the rank-deficient-safe reference
+# "cholesky"       -- normal-equations Cholesky; fast, well-conditioned A only
+# "rsvd"           -- randomized SVD, O(MNk), for strongly low-rank A
+result = solve_linear(PoissonND(), scale=5.0, method="qr")
+
+# Device selection (CPU / CUDA / Apple-MPS), or set FASTLSQ_DEVICE=cuda
+set_device("cuda")   # the float64 default stays on CPU/CUDA; MPS is float32-only
+```
+
 ### Use the basis directly
 
 ```python
@@ -204,9 +227,10 @@ u_yy = A @ solver.beta                           # (M, k): ∂²u/∂y² per com
 
 Scalar problems are untouched: `n_outputs` defaults to `1`, `solver.beta` keeps
 shape `(N, 1)`, and `predict_with_grad` returns gradient shape `(M, d)` for
-backward compatibility (the trailing component axis is squeezed when k=1).
-`ElasticWave2D` in [fastlsq/problems/linear.py](fastlsq/problems/linear.py) is
-the canonical coupled vector example.
+backward compatibility (the trailing component axis is squeezed when k=1). The
+`Stokes2D` sketch above and [tests/test_block.py](tests/test_block.py) -- a
+runnable `block_concat` + `unpack_beta` solve that recovers both components of a
+k=2 system -- are the reference for the block-stacked vector path.
 
 ### Plot solutions
 
@@ -258,11 +282,15 @@ derivative engine:
 | `FastLSQSolver` | Manages feature blocks; exposes `.basis` for all derivative computations |
 | `LearnableFastLSQ` | Differentiable solver with learnable bandwidth via reparameterisation trick |
 | `block_concat`, `pack_beta`, `unpack_beta` | Block-structured assembly helpers for vector-valued **u** (coupled systems). `solver.beta` has shape `(N, k)`; scalar problems are the k=1 case |
+| `solve_lstsq` | Multi-back-end least-squares solve (`auto`/`qr`/`svd`/`cholesky`/`rsvd`); rank-revealing by default for the rank-deficient feature matrix |
+| `resolve_device` / `set_device` / `get_device` | CPU / CUDA / Apple-MPS selection, dtype-aware (MPS is float32-only; factorizations fall back to CPU) |
 
 ### How it works
 
 1. **Basis construction.** Given collocation points **x**, construct a
-   `SinusoidalBasis` with random weights W and biases b.
+   `SinusoidalBasis` with random weights W and biases b. The collocation counts
+   default to scale with the feature count
+   (`n_pde = max(3000, 3 * n_blocks * hidden_size)`, `n_bc = max(800, n_pde // 5)`).
 
 2. **Analytical derivatives.** Exploit the cyclic derivative identity:
    the n-th derivative of sin(z) cycles through {sin, cos, -sin, -cos}
@@ -273,8 +301,13 @@ derivative engine:
    (e.g. `Op.laplacian(d=2)`) and apply it to the basis to get the system
    matrix `A`.
 
-4. **Linear solve.** Solve `A beta = b` via least squares
-   (optionally Tikhonov-regularised).
+4. **Linear solve.** Solve `A beta = b` in the least-squares sense. The
+   random-feature matrix `A` is typically rank-deficient (near-duplicate
+   columns), so the default `method="auto"` starts from a Cholesky fast-path
+   (guarded by a cheap conditioning probe), falls back to backward-stable
+   Householder **QR**, and resorts to a rank-revealing **SVD** only if the QR
+   solution blows up. A Tikhonov ridge `mu` enters via the `[A; sqrt(mu) I]`
+   augmentation, not the condition-squaring normal equations.
 
 5. **Newton iteration (nonlinear).** Linearise the PDE residual, solve
    `J delta_beta = -R` with backtracking line search, and repeat.
@@ -336,9 +369,12 @@ See `examples/add_your_own_pde.py` for the complete tutorial.
 - **Symbolic PDE operators**: Compose differential operators with `Op` (Laplacian, wave, Helmholtz, biharmonic, custom) via intuitive arithmetic; coefficients can be `nn.Parameter` for AdamW optimisation
 - **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
 - **Learnable bandwidth**: `LearnableFastLSQ` optimises the bandwidth (scalar or anisotropic) via reparameterisation
 - **Learnable PDE coefficients**: Plug `nn.Parameter` into `Op` (e.g. Helmholtz wavenumber `k`) and optimise via AdamW; gradients flow through the prebuilt linear solve
 - **Auto-tuning**: Automatic scale selection via grid search
+- **Device support**: CPU / CUDA / Apple-MPS via `set_device()` or the `FASTLSQ_DEVICE` env var, dtype-aware (the float64 high-accuracy path stays on CPU/CUDA)
+- **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
 - **Diagnostics**: Problem validation, conditioning checks, error detection

{fastlsq-0.2.3 → fastlsq-0.2.5}/README.md

@@ -14,9 +14,12 @@ analytical derivative engine for random Fourier features.  For sinusoidal
 features `phi_j(x) = sin(W_j . x + b_j)`, every derivative of every order
 admits an exact closed-form expression -- no automatic differentiation needed.
 
-Linear PDEs are solved in a single least-squares step; nonlinear PDEs are
-solved via Newton-Raphson iteration with Tikhonov regularisation,
-1/sqrt(N) feature normalisation, and continuation/homotopy.
+Linear PDEs are solved in a single least-squares step.  The random-feature
+system is typically rank-deficient, so the solve is routed through a
+backward-stable, auto-selected least-squares back-end (Cholesky fast-path ->
+Householder QR -> rank-revealing SVD) that runs on CPU, CUDA, or Apple-MPS.
+Nonlinear PDEs are solved via Newton-Raphson iteration with Tikhonov
+regularisation, 1/sqrt(N) feature normalisation, and continuation/homotopy.
 
 ## Installation
 
@@ -27,7 +30,7 @@ pip install fastlsq
 For development (includes testing and build tools):
 
 ```bash
-git clone https://github.com/asulc/FastLSQ.git
+git clone https://github.com/sulcantonin/FastLSQ.git
 cd FastLSQ
 pip install -e ".[dev]"
 ```
@@ -60,6 +63,26 @@ print(f"Converged in {result['n_iters']} iterations")
 print(f"Value error: {result['metrics']['val_err']:.2e}")
 ```
 
+### Choose a solver back-end and device
+
+The linear solve is routed automatically, but `solve_linear` exposes the
+back-end via `method=` (see [How it works](#how-it-works) for the routing):
+
+```python
+from fastlsq import solve_linear, set_device
+from fastlsq.problems.linear import PoissonND
+
+# "auto" (default) -- Cholesky fast-path -> QR -> rank-revealing SVD
+# "qr"             -- Householder QR; SVD-grade accuracy at QR cost (full-rank A)
+# "svd"            -- rank-revealing truncated SVD; the rank-deficient-safe reference
+# "cholesky"       -- normal-equations Cholesky; fast, well-conditioned A only
+# "rsvd"           -- randomized SVD, O(MNk), for strongly low-rank A
+result = solve_linear(PoissonND(), scale=5.0, method="qr")
+
+# Device selection (CPU / CUDA / Apple-MPS), or set FASTLSQ_DEVICE=cuda
+set_device("cuda")   # the float64 default stays on CPU/CUDA; MPS is float32-only
+```
+
 ### Use the basis directly
 
 ```python
@@ -163,9 +186,10 @@ u_yy = A @ solver.beta                           # (M, k): ∂²u/∂y² per com
 
 Scalar problems are untouched: `n_outputs` defaults to `1`, `solver.beta` keeps
 shape `(N, 1)`, and `predict_with_grad` returns gradient shape `(M, d)` for
-backward compatibility (the trailing component axis is squeezed when k=1).
-`ElasticWave2D` in [fastlsq/problems/linear.py](fastlsq/problems/linear.py) is
-the canonical coupled vector example.
+backward compatibility (the trailing component axis is squeezed when k=1). The
+`Stokes2D` sketch above and [tests/test_block.py](tests/test_block.py) -- a
+runnable `block_concat` + `unpack_beta` solve that recovers both components of a
+k=2 system -- are the reference for the block-stacked vector path.
 
 ### Plot solutions
 
@@ -217,11 +241,15 @@ derivative engine:
 | `FastLSQSolver` | Manages feature blocks; exposes `.basis` for all derivative computations |
 | `LearnableFastLSQ` | Differentiable solver with learnable bandwidth via reparameterisation trick |
 | `block_concat`, `pack_beta`, `unpack_beta` | Block-structured assembly helpers for vector-valued **u** (coupled systems). `solver.beta` has shape `(N, k)`; scalar problems are the k=1 case |
+| `solve_lstsq` | Multi-back-end least-squares solve (`auto`/`qr`/`svd`/`cholesky`/`rsvd`); rank-revealing by default for the rank-deficient feature matrix |
+| `resolve_device` / `set_device` / `get_device` | CPU / CUDA / Apple-MPS selection, dtype-aware (MPS is float32-only; factorizations fall back to CPU) |
 
 ### How it works
 
 1. **Basis construction.** Given collocation points **x**, construct a
-   `SinusoidalBasis` with random weights W and biases b.
+   `SinusoidalBasis` with random weights W and biases b. The collocation counts
+   default to scale with the feature count
+   (`n_pde = max(3000, 3 * n_blocks * hidden_size)`, `n_bc = max(800, n_pde // 5)`).
 
 2. **Analytical derivatives.** Exploit the cyclic derivative identity:
    the n-th derivative of sin(z) cycles through {sin, cos, -sin, -cos}
@@ -232,8 +260,13 @@ derivative engine:
    (e.g. `Op.laplacian(d=2)`) and apply it to the basis to get the system
    matrix `A`.
 
-4. **Linear solve.** Solve `A beta = b` via least squares
-   (optionally Tikhonov-regularised).
+4. **Linear solve.** Solve `A beta = b` in the least-squares sense. The
+   random-feature matrix `A` is typically rank-deficient (near-duplicate
+   columns), so the default `method="auto"` starts from a Cholesky fast-path
+   (guarded by a cheap conditioning probe), falls back to backward-stable
+   Householder **QR**, and resorts to a rank-revealing **SVD** only if the QR
+   solution blows up. A Tikhonov ridge `mu` enters via the `[A; sqrt(mu) I]`
+   augmentation, not the condition-squaring normal equations.
 
 5. **Newton iteration (nonlinear).** Linearise the PDE residual, solve
    `J delta_beta = -R` with backtracking line search, and repeat.
@@ -295,9 +328,12 @@ See `examples/add_your_own_pde.py` for the complete tutorial.
 - **Symbolic PDE operators**: Compose differential operators with `Op` (Laplacian, wave, Helmholtz, biharmonic, custom) via intuitive arithmetic; coefficients can be `nn.Parameter` for AdamW optimisation
 - **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
 - **Learnable bandwidth**: `LearnableFastLSQ` optimises the bandwidth (scalar or anisotropic) via reparameterisation
 - **Learnable PDE coefficients**: Plug `nn.Parameter` into `Op` (e.g. Helmholtz wavenumber `k`) and optimise via AdamW; gradients flow through the prebuilt linear solve
 - **Auto-tuning**: Automatic scale selection via grid search
+- **Device support**: CPU / CUDA / Apple-MPS via `set_device()` or the `FASTLSQ_DEVICE` env var, dtype-aware (the float64 high-accuracy path stays on CPU/CUDA)
+- **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
 - **Diagnostics**: Problem validation, conditioning checks, error detection

{fastlsq-0.2.3 → fastlsq-0.2.5}/fastlsq/__init__.py

@@ -44,7 +44,7 @@ from fastlsq.export import (
 )
 from fastlsq import viz
 
-__version__ = "0.2.3"
+__version__ = "0.2.5"
 __all__ = [
     # Device selection (CPU / CUDA / Apple-MPS, dtype-aware)
     "resolve_device",

{fastlsq-0.2.3 → fastlsq-0.2.5}/fastlsq/problems/linear.py

@@ -17,6 +17,7 @@ import torch
 import numpy as np
 
 from fastlsq.utils import device
+from fastlsq.block import block_concat
 
 
 # ======================================================================
@@ -218,17 +219,36 @@ class Wave1D:
 # ======================================================================
 
 class Wave2D_MS:
-    """Wave 2-D multi-scale with time normalisation and frequency compensation.
-
-    Domain: [0,1]^2 x [0, t_max]  (t normalised to [0,1]).
+    """Wave 2-D multi-scale (anisotropic, normalised time).
+
+    Anisotropic wave  u_tt = u_xx + a2 u_yy  on [0,1]^2 x [0, t_max], with time
+    normalised to tau = t / t_max in [0,1].  ``build`` therefore carries the
+    spatial term's t_max^2 factor (d^2/dt^2 = t_max^-2 d^2/dtau^2), so the
+    discretised operator  u_tautau - t_max^2 (u_xx + a2 u_yy)  is satisfied
+    exactly by ``exact`` (the (1,1) standing mode, omega = pi sqrt(1+a2)).
+
+    Resolvability constraint on ``t_max``.  In normalised time the solution
+    oscillates at  Omega = omega * t_max, i.e. ~ sqrt(1+a2) * t_max / 2 temporal
+    cycles over tau in [0,1].  The PDE's second time-derivative amplifies the
+    random-feature *representation* error by Omega^2, so the one-shot
+    least-squares collocation only resolves a handful of cycles before that
+    amplified error swamps the solution -- the original ``t_max = 100`` (~87
+    cycles) did not solve in *any* configuration (rel-err 1.0, the [0.2.4] known
+    issue), even at 8000 features with near-hard boundary constraints, because
+    the best representable solution itself carries a huge PDE residual.
+    ``t_max = 4`` keeps it at ~3.5 cycles (solves to ~1e-3 at 900 features); the
+    anisotropic ``scale_multipliers`` place the temporal feature bandwidth at
+    ~Omega while the spatial bandwidth stays ~pi.
     """
 
     def __init__(self):
         self.name = "Wave 2D-MS"
         self.dim = 3
         self.a2 = 2.0
-        self.t_max = 100.0
-        self.scale_multipliers = [1.0, 1.0, 300.0]
+        self.t_max = 4.0          # ~3.5 temporal cycles -- see class docstring
+        # Anisotropic feature bandwidth: temporal ~ Omega = pi*sqrt(1+a2)*t_max
+        # ~= 21.8, matched at scale ~3 (multiplier 7); spatial bandwidth ~ pi.
+        self.scale_multipliers = [1.0, 1.0, 7.0]
 
     def exact(self, x_in):
         xv = x_in[:, 0:1]
@@ -316,6 +336,7 @@ class ElasticWave2D:
     def __init__(self, c_p: float = 2.0, c_s: float = 1.0, t_max: float = 2.0):
         self.name = "Elastic Wave 2D"
         self.dim = 3  # x, y, t
+        self.n_outputs = 2  # (u_x, u_y) -- block-stacked vector solve
         self.c_p = c_p
         self.c_s = c_s
         self.c_p2 = c_p ** 2
@@ -351,6 +372,33 @@ class ElasticWave2D:
         uy_t = (self.ky * torch.sin(self.kx * xv) * torch.cos(self.ky * yv) * fac)
         return torch.cat([ux_t, uy_t], dim=1)
 
+    def exact_grad(self, x_in):
+        """Jacobian of (u_x, u_y). Returns (M, d, k) with J[:, j, c] = du_c/dx_j.
+
+        Time is normalised (t_phys = t * t_max), so the t-derivatives pick up a
+        t_max chain-rule factor -- matching ``exact_ut`` and ``Wave2D_MS`` and the
+        normalised inputs ``predict_with_grad`` differentiates against.
+        """
+        xv, yv, tv = x_in[:, 0:1], x_in[:, 1:2], x_in[:, 2:3] * self.t_max
+        kx, ky = self.kx, self.ky
+        cx, sx = torch.cos(kx * xv), torch.sin(kx * xv)
+        cy, sy = torch.cos(ky * yv), torch.sin(ky * yv)
+        ct, st = torch.cos(self.omega_p * tv), torch.sin(self.omega_p * tv)
+        dt = -self.omega_p * self.t_max * st  # d/dt_norm of cos(omega_p * t_phys)
+
+        # u_x = kx cos(kx x) sin(ky y) cos(omega_p t)
+        ux_x = kx * (-kx * sx) * sy * ct
+        ux_y = kx * cx * (ky * cy) * ct
+        ux_t = kx * cx * sy * dt
+        # u_y = ky sin(kx x) cos(ky y) cos(omega_p t)
+        uy_x = ky * (kx * cx) * cy * ct
+        uy_y = ky * sx * (-ky * sy) * ct
+        uy_t = ky * sx * cy * dt
+
+        grad_ux = torch.cat([ux_x, ux_y, ux_t], dim=1)  # (M, 3)
+        grad_uy = torch.cat([uy_x, uy_y, uy_t], dim=1)  # (M, 3)
+        return torch.stack([grad_ux, grad_uy], dim=-1)  # (M, 3, 2)
+
     def get_train_data(self, n_pde=5000, n_bc=1000):
         x_pde = torch.rand(n_pde, 3, device=device)
         x_ic = torch.cat([
@@ -378,10 +426,14 @@ class ElasticWave2D:
         ], None
 
     def build(self, slv, x_pde, bcs, f_pde_ignored):
-        """Build block system for coupled (u_x, u_y). Returns A (M, 2N), b (M, 1)."""
+        """Block-stacked system for the coupled (u_x, u_y) solve.
+
+        Two column blocks (u_x, u_y coefficients); each equation / BC adds a
+        block row. ``block_concat`` assembles A in R^{Mk x Nk}, b in R^{Mk x 1}
+        (k = n_outputs = 2) so ``unpack_beta`` recovers a (N, 2) beta.
+        """
         basis = slv.basis
         cache = basis.cache(x_pde)
-        N = basis.n_features
 
         # Derivatives for (x, y, t) with t as dim 2
         u_xx = basis.derivative(x_pde, (2, 0, 0), cache=cache)
@@ -389,48 +441,36 @@ class ElasticWave2D:
         u_tt = basis.derivative(x_pde, (0, 0, 2), cache=cache)
         u_xy = basis.derivative(x_pde, (1, 1, 0), cache=cache)
 
-        # t is normalised to [0,1]; physical d²/dt² = (1/t_max)² d²/dτ²
+        # t is normalised to [0,1]; physical d²/dt² = (1/t_max)² d²/dτ², so the
+        # spatial + cross terms carry a t_max² factor (consistent with Wave2D_MS).
         t_scale = self.t_max ** 2
+        cross = t_scale * self.c_cross
 
         # PDE1: u_x_ττ = t_max²·(c_p² u_x_xx + c_s² u_x_yy + (c_p²-c_s²) u_y_xy)
         A1_x = u_tt - t_scale * (self.c_p2 * u_xx + self.c_s2 * u_yy)
-        A1_y = -t_scale * self.c_cross * u_xy
-
+        A1_y = -cross * u_xy
         # PDE2: u_y_ττ = t_max²·(c_p² u_y_yy + c_s² u_y_xx + (c_p²-c_s²) u_x_xy)
-        A2_x = -t_scale * self.c_cross * u_xy
+        A2_x = -cross * u_xy
         A2_y = u_tt - t_scale * (self.c_p2 * u_yy + self.c_s2 * u_xx)
 
-        A_pde = torch.cat([
-            torch.cat([A1_x, A1_y], dim=1),
-            torch.cat([A2_x, A2_y], dim=1),
-        ], dim=0)
-        b_pde = torch.zeros(2 * len(x_pde), 1, device=device)
+        z_pde = torch.zeros(len(x_pde), 1, device=device)
+        rows = [[A1_x, A1_y], [A2_x, A2_y]]   # block rows: [u_x col, u_y col]
+        rhs = [[z_pde], [z_pde]]              # matching RHS column blocks
 
-        As, bs = [A_pde], [b_pde]
         w_bc = 1000.0
-
         for (pts, vals, type_) in bcs:
-            h = basis.evaluate(pts)
-            dh = basis.gradient(pts)
-            n_pts = len(pts)
             if type_ == "dirichlet":
-                # vals: (N_pts, 2) for u_x, u_y
-                H_block_x = torch.cat([h, torch.zeros_like(h)], dim=1)
-                H_block_y = torch.cat([torch.zeros_like(h), h], dim=1)
-                A_bc = torch.cat([H_block_x, H_block_y], dim=0) * w_bc
-                b_bc = torch.cat([vals[:, 0:1], vals[:, 1:2]], dim=0) * w_bc
+                op = basis.evaluate(pts) * w_bc
             elif type_ == "neumann_t":
-                dh_t = dh[:, 2, :]
-                D_block_x = torch.cat([dh_t, torch.zeros_like(dh_t)], dim=1)
-                D_block_y = torch.cat([torch.zeros_like(dh_t), dh_t], dim=1)
-                A_bc = torch.cat([D_block_x, D_block_y], dim=0) * w_bc
-                b_bc = torch.cat([vals[:, 0:1], vals[:, 1:2]], dim=0) * w_bc
+                op = basis.gradient(pts)[:, 2, :] * w_bc
             else:
                 continue
-            As.append(A_bc)
-            bs.append(b_bc)
+            # vals: (n_pts, 2). One block row per component:
+            #   u_x -> [op, None],  u_y -> [None, op]
+            rows += [[op, None], [None, op]]
+            rhs += [[vals[:, 0:1] * w_bc], [vals[:, 1:2] * w_bc]]
 
-        return torch.cat(As), torch.cat(bs)
+        return block_concat(rows), block_concat(rhs)
 
     def get_test_points(self, n=2000):
         return torch.rand(n, 3, device=device)

{fastlsq-0.2.3 → fastlsq-0.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "FastLSQ"
-version = "0.2.3"
+version = "0.2.5"
 description = "One-shot PDE solving via Fourier features with exact analytical derivatives; rank-revealing solvers, learnable anisotropic bandwidth, and CPU/CUDA/MPS support"
 readme = "README.md"
 license = "MIT"

fastlsq-0.2.5/tests/test_benchmarks_inverse.py

@@ -0,0 +1,156 @@
+# Copyright (c) 2026 Antonin Sulc -- MIT.
+"""Smoke tests for the benchmark PDE equations and the inverse-problem workflows.
+
+Exercises the forward benchmark problems through the public ``solve_linear`` /
+``solve_nonlinear`` API and two inverse pipelines -- parameter recovery via an
+outer optimiser, and SINDy-style PDE discovery via analytical derivatives -- so
+the v0.2.3 QR / N-scaled-collocation solver path is covered end-to-end, not just
+on the single Poisson problem in ``test_basic``.
+
+Scales are fixed (not auto-selected) and the RNG is seeded so the smoke test is
+fast and deterministic; tolerances carry ~10x headroom over measured errors.
+
+``ElasticWave2D`` -- a coupled 2-output vector problem -- exercises the
+block-stacked vector path (``n_outputs = 2``, ``block_concat`` assembly,
+``unpack_beta`` -> ``(N, 2)`` beta); it carries a per-case ``n_blocks`` bump
+since the coupled solve needs more features than the scalar benchmarks.
+
+``Wave2D_MS`` -- a long-time anisotropic wave -- likewise bumps ``n_blocks``;
+its ``t_max`` was reduced from 100 to 4 so the normalised-time solution spans
+~3.5 temporal cycles rather than ~87.  The PDE's second time-derivative
+amplifies the random-feature representation error by ``Omega**2``, so the
+one-shot collocation only resolves a few cycles (see the class docstring) --
+the old t_max=100 gave rel-err 1.0 in every configuration.
+"""
+import numpy as np
+import pytest
+import torch
+
+from fastlsq import (
+    solve_linear, solve_nonlinear, solve_lstsq, Op, SinusoidalBasis,
+    sample_box, sample_boundary_box,
+)
+from fastlsq.problems import linear as L
+from fastlsq.problems import nonlinear as NL
+
+
+# (class, fixed scale, val_err tolerance, solver-config overrides)
+LINEAR_CASES = [
+    (L.PoissonND,    0.5, 5e-3, {}),
+    (L.HeatND,       0.5, 1e-1, {}),
+    (L.Wave1D,      15.0, 5e-3, {}),
+    (L.Helmholtz2D, 10.0, 1e-5, {}),
+    (L.Maxwell2D_TM, 2.0, 5e-3, {}),
+    # Long-time anisotropic wave: temporal-matched bandwidth + more features
+    # (t_max reduced 100 -> 4 so the collocation can resolve the ~3.5 cycles).
+    (L.Wave2D_MS,    3.0, 1e-2, {"n_blocks": 3}),
+    # Coupled 2-output vector problem: needs more features than the scalars.
+    (L.ElasticWave2D, 6.0, 1e-1, {"n_blocks": 3}),
+]
+
+NONLINEAR_CASES = [
+    (NL.NLPoisson2D,     8.0, 1e-4),
+    (NL.Bratu2D,        15.0, 1e-4),
+    (NL.SteadyBurgers1D,10.0, 1e-4),
+    (NL.NLHelmholtz2D,   5.0, 1e-4),
+    (NL.AllenCahn1D,    15.0, 2e-1),
+]
+
+
+@pytest.mark.parametrize(
+    "cls,scale,tol,solver_kw", LINEAR_CASES, ids=[c[0].__name__ for c in LINEAR_CASES]
+)
+def test_linear_benchmark_solves(cls, scale, tol, solver_kw):
+    """Each linear benchmark equation solves end-to-end via the public API."""
+    torch.set_default_dtype(torch.float64)
+    torch.manual_seed(0)
+    cfg = dict(n_blocks=2, hidden_size=300, n_test=1500,
+               auto_scale=False, verbose=False)
+    cfg.update(solver_kw)
+    r = solve_linear(cls(), scale=scale, **cfg)
+    ve = r["metrics"]["val_err"]
+    assert np.isfinite(ve), f"{cls.__name__}: non-finite val_err"
+    assert ve < tol, f"{cls.__name__}: val_err={ve:.2e} exceeds tol {tol:.0e}"
+
+
+@pytest.mark.parametrize(
+    "cls,scale,tol", NONLINEAR_CASES, ids=[c[0].__name__ for c in NONLINEAR_CASES]
+)
+def test_nonlinear_benchmark_solves(cls, scale, tol):
+    """Each nonlinear benchmark equation converges via Newton + the public API."""
+    torch.set_default_dtype(torch.float64)
+    torch.manual_seed(0)
+    r = solve_nonlinear(cls(), scale=scale, n_blocks=2, hidden_size=300,
+                        n_test=1500, max_iter=15, auto_scale=False, verbose=False)
+    ve = r["metrics"]["val_err"]
+    assert r["n_iters"] > 0, f"{cls.__name__}: no Newton iterations ran"
+    assert np.isfinite(ve), f"{cls.__name__}: non-finite val_err"
+    assert ve < tol, f"{cls.__name__}: val_err={ve:.2e} exceeds tol {tol:.0e}"
+
+
+def test_inverse_source_position():
+    """Recover a Gaussian source position from sensor data (forward solve + L-BFGS)."""
+    opt = pytest.importorskip("scipy.optimize")
+    torch.set_default_dtype(torch.float64)
+    torch.manual_seed(0)
+
+    pde_op = -Op.laplacian(d=2)
+    basis = SinusoidalBasis.random(input_dim=2, n_features=700, sigma=5.0,
+                                   normalize=True)
+    x_pde = sample_box(3000, 2)
+    x_bc = sample_boundary_box(400, 2)
+    n_bc = x_bc.shape[0]
+    cache = basis.cache(x_pde)
+    A = torch.cat([pde_op.apply(basis, x_pde, cache=cache),
+                   100.0 * basis.evaluate(x_bc)])
+    x_sens = torch.tensor([[0.3, 0.3], [0.7, 0.7], [0.3, 0.7], [0.7, 0.3]])
+
+    def forward(xs, ys):
+        b = torch.exp(-((x_pde[:, 0] - xs) ** 2
+                        + (x_pde[:, 1] - ys) ** 2) / 0.1).unsqueeze(1)
+        b = torch.cat([b, torch.zeros(n_bc, 1, dtype=b.dtype)])
+        beta = solve_lstsq(A, b)
+        return (basis.evaluate(x_sens) @ beta).detach().cpu().numpy().ravel()
+
+    true = np.array([0.4, 0.6])
+    rng = np.random.default_rng(0)
+    u_obs = forward(*true) + 0.005 * rng.standard_normal(4)
+
+    res = opt.minimize(
+        lambda p: float(np.sum((forward(float(p[0]), float(p[1])) - u_obs) ** 2)),
+        x0=[0.5, 0.5], method="L-BFGS-B", bounds=[(0.1, 0.9)] * 2,
+    )
+    assert np.linalg.norm(res.x - true) < 0.06, f"recovered {res.x} vs {true}"
+
+
+def test_pde_discovery_recovers_governing_equation():
+    """SINDy-style discovery via analytical derivatives recovers u_xx = a*u + b*u_x.
+
+    Synthetic damped oscillator u = exp(-x/2) sin(2x) -> u_xx = -4.25 u - 1.0 u_x.
+    The dominant restoring term is recovered tightly; the damping term is harder
+    from 2% noise, so it is only bounded in sign/magnitude.
+    """
+    torch.set_default_dtype(torch.float64)
+    torch.manual_seed(42)
+
+    M = 500
+    x = torch.linspace(0, 2 * np.pi, M).reshape(-1, 1)
+    u_true = torch.exp(-0.5 * x) * torch.sin(2 * x)
+    u_noisy = u_true + 0.02 * torch.randn_like(u_true)
+
+    basis = SinusoidalBasis.random(input_dim=1, n_features=400, sigma=4.0,
+                                   normalize=True)
+    beta = solve_lstsq(basis.evaluate(x), u_noisy, mu=1e-3)
+    cache = basis.cache(x)
+    u = basis.evaluate(x, cache=cache) @ beta
+    u_x = basis.derivative(x, alpha=(1,), cache=cache) @ beta
+    u_xx = basis.derivative(x, alpha=(2,), cache=cache) @ beta
+
+    coef = solve_lstsq(torch.cat([u, u_x], dim=1), u_xx)  # u_xx = a*u + b*u_x
+    a, b = float(coef[0]), float(coef[1])
+    assert abs(a - (-4.25)) < 0.3, f"restoring coeff a={a:.3f} (want -4.25)"
+    assert b < 0 and abs(b - (-1.0)) < 0.5, f"damping coeff b={b:.3f} (want -1.0)"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

{fastlsq-0.2.3 → fastlsq-0.2.5}/tests/test_vector_basis.py

@@ -20,7 +20,7 @@ from fastlsq.utils import device
 # ----------------------------------------------------------------------
 
 def test_version():
-    assert fastlsq.__version__ == "0.2.3"
+    assert fastlsq.__version__ == "0.2.5"
 
 
 def test_imports():