semiflow

no_std Rust solver for linear evolution equations (∂ₜu = Lu) via Chernoff approximation of operator semigroups. No matrix exponentials. No linear solves. Flat memory footprint. Ships 60+ engine implementations across heat, Schrödinger, diffusion, graph, manifold, and hypoelliptic operators.

Performance note (iter-8, HEAD b923777): The library's primary measured advantage is memory frugality (~3 MB flat working set vs 50–418 MB for heavy frameworks). Wallclock is NOT a strength for general matched-accuracy PDE solving — RC is uniformly slower than adaptive ODE solvers and spectral methods. Parallelism scales well only at large 3D grid sizes (eta8=0.908 for F7 fine; eta8≈0.125 for 2D). See the root workspace README for the full honest benchmark picture.

Mathematical foundation: Theorem 6 of I. D. Remizov (2025), Vladikavkaz Math. J. 27(4), 124–135 (doi:10.46698/a3908-1212-5385-q).

How it works

Each step S(τ) is an explicit, allocation-free contraction kernel. The Chernoff product formula then gives:

(S(t/n))ⁿ f  →  e^{tL} f   as n → ∞

The hot loop operates entirely on Vec<F> buffers with reused scratch space — steady-state evolution is zero-allocation and cache-friendly. Generic over F: SemiflowFloat (default f64; f32 supported with native f32x8 AVX2 / f32x4 NEON kernels; forward-mode AD via Dual<F>).

Install

[dependencies]
semiflow = "0.9"

Or:

cargo add semiflow

MSRV: Rust 1.78. Default feature: simd (AVX2 on x86_64, NEON on aarch64; scalar fallback on all other targets). no_std + alloc compatible: disable default features.

# no_std build
semiflow = { version = "0.9", default-features = false }

Quickstart

Solve ∂ₜu = ½·∂ₓₓu from u₀(x) = exp(-x²) to t = 1:

use semiflow::{Grid1D, GridFn1D, DiffusionChernoff, ChernoffSemigroup};

let grid = Grid1D::new(-10.0, 10.0, 1000)
    .expect("grid bounds and node count are valid");
let u0 = GridFn1D::from_fn(grid, |x| (-x * x).exp());

// a(x) = 0.5 constant; a' = 0, a'' = 0 enables the fast ζ-A path.
let diff = DiffusionChernoff::new(|_| 0.5_f64, |_| 0.0, |_| 0.0, 0.5, grid);
let semi = ChernoffSemigroup::new(diff, 100)
    .expect("n >= 1 required");
let u1 = semi.evolve(1.0, &u0)
    .expect("evolve should not fail for valid inputs");
// Closed-form oracle: u(1,x) = 3^{-1/2} exp(-x²/3)
// Numerical sup-norm error ≈ 1.46e-6 at n = 100

Engine catalogue

1D Chernoff functions

Compositions

2D tensor-product

3D tensor-product

Adaptive

Boundary conditions

Resolvent and nonautonomous

Riemannian manifold

High-dimensional and sparse-grid

Matrix-valued operators

Quantum graphs

Reverse-mode AD

Scope: constant-a DiffusionChernoff<F> only. Multi-parameter (K>1) sensitivity via ReverseChernoff::with_region_map. Variable-coefficient kernels are deferred.

Tensor-train carrier

Scope: linear diagonal-A Gaussian class (TtChernoff); separable diagonal variable coefficients (VarCoefTt). Non-separable variable coefficients and off-diagonal A are research-track. VarCoefTt::new returns SemiflowError::VarCoefOutOfClass when inputs fall outside the separable diagonal class.

Gridless / particle-ensemble

Executor

ChernoffSemigroup<C, S> — wraps a ChernoffFunction and a step count; call .evolve(t, &f) to compute (S(t/n))ⁿ f.

Feature flags

no_std + alloc works without std; libm provides f32/f64 transcendentals.

The parallel feature uses std::thread::scope and is incompatible with WASM targets. Bit-equality is guaranteed across thread counts {1, 2, 4, 8} for f64 monomorphisations (ADR-0018).

Examples

cargo run -p semiflow --example heat_2d_demo

Mathematical references

• I. D. Remizov, Vladikavkaz Math. J. 27(4) (2025) 124–135. DOI 10.46698/a3908-1212-5385-q. Primary reference; Theorem 6 (Chernoff formula) and Theorem 3 (Laplace-Chernoff resolvent).
• S. Mazzucchi, V. Moretti, I. D. Remizov, O. G. Smolyanov, Math. Nachr. (2023). Riemannian manifold Chernoff with R/12 curvature correction.
• J. S. Howland, Trans. AMS 207 (1974). Nonautonomous augmented-generator lift.
• Y. A. Butko, Fract. Calc. Appl. Anal. 21 (2018). Feynman-Kac killing for Dirichlet BC.
• J. Walsh, Séminaire de Probabilités 20 (1986). Image method for Neumann BC.

@article{Remizov2025,
  author  = {I. D. Remizov},
  title   = {Chernoff Approximations of the Solution of Linear ODE with Variable Coefficients},
  journal = {Vladikavkaz Math. J.},
  volume  = {27},
  number  = {4},
  pages   = {124--135},
  year    = {2025},
  doi     = {10.46698/a3908-1212-5385-q}
}

Bindings

This crate is Rust-only. Sibling crates wrap it for other languages:

All three binding surfaces now cover the full user-facing operator zoo, including S³ carriers (TtEvolver, TtCoupledEvolver, VarCoefTtEvolver, GridlessEvolver, MeasureState), the new boundary kernel (DirichletHeat2nd1D in WASM/Python, smf_dirichlet_heat2nd1d_* in C), Laplacian introspection (SmfLaplacian with row_ptr/col_idx/vals/to_dense; SmfGraphTraj), and obstacle surfaces (SmfObstacleGamma, SmfObstacleND2). The GraphAdjoint pre-sampled time-grid path (GraphAdjointPresampled / smf_graph_adjoint_new_presampled) works across all three surfaces; the live-callback constructor is PyO3-only. Binding surfaces are a curated mirror of user-facing types — internal composition types (AxisLift, StrangSplit) are not directly exposed.

See the workspace README for cross-language status and build instructions.

License

Dual MIT OR Apache-2.0. See LICENSE-MIT and LICENSE-APACHE in the workspace root.

Author

Created and maintained by Ilia Volkov — ilia.volkov@outlook.com.

Changelog

Full version history in CHANGELOG.md. Tagged releases (with wheels and notes) on GitHub Releases.

Contributing

See CONTRIBUTING.md and CODE_OF_CONDUCT.md. Security reports to ilia.volkov@outlook.com per SECURITY.md.