Closed-form derivatives for scientific AI
Derivon computes Laplacians, Hessians, and high-order operators in closed form - orders of magnitude faster than nested autodiff, bit-stable to machine precision, and certified across PyTorch and JAX.
Prefer email? info@derivon.ai
Open-core · PyTorch & JAX · float64 bit-identical · reproducible benchmarks
Headline speedups are single data-center GPU measurements. See benchmark methodology.
Built for derivative-heavy scientific computing
Autodiff is the wrong tool for iterated high-order operators
Automatic differentiation is exactly right for first-order gradients. But scientific models are dominated by operators that are not first-order gradients - Laplacians, Hessians, trace-of-Jacobians, high-order Stein operators.
For those, nested AD grows exponentially in cost as you iterate the operator, materializes quadratic-memory Hessians, and accumulates round-off across an ever-deeper graph.
- Dense Hessians scale as O(D²) in memory and time
- Iterated Laplacians Δᵏ re-pay the whole pass each order
- High-order finite differences are numerically hopeless
A closed-form derivative tower from a single forward pass
Derivon evaluates σⁿ(z) as a polynomial recurrence on one activation call. The Laplacian becomes a contraction whose only dimension-dependent term is computed once and reused across the batch - so the overhead is O(1) in D.
import jax.numpy as jnp
from omnibias.jax import neural_field_value_grad_laplacian
# Closed-form value, gradient, and Laplacian of a one-layer field on R^D.
# One activation-tower evaluation - no nested autodiff, O(1) overhead in D.
val, grad, lap = neural_field_value_grad_laplacian(
x, W, beta, c, b, activation="tanh"
)
# Iterated Laplacian for high-order PDEs stays flat in k:
from omnibias.jax import neural_field_polylaplacian
d4 = neural_field_polylaplacian(x, W, beta, c, b, "tanh", k=2) # biharmonicEverything you need to make derivatives cheap and trustworthy
One primitive, exposed as a full operator surface, with reproducible numerics and certified bounds where it matters.
One forward pass, any order
Evaluate the derivative tower σⁿ(z) in closed form for arbitrary n. A single activation call yields the whole tower - gradient, Laplacian, biharmonic, and beyond.
O(1) in input dimension
The Laplacian overhead is independent of D. Grow the dimension 80x and the wall-clock barely moves, because the D-dependent term is computed once and reused.
Bit-identical backends
PyTorch, JAX, and Keras 3 import the same pure-Python coefficients, so every (activation, order) pair is float64-ULP-equal across frameworks - verified each release.
Certified, not just fast
Outward-rounded interval and Taylor-model arithmetic produce enclosures that provably contain the true value, sealed in tamper-evident certificates with a formal-kernel gate.
Drop-in integration
A folx-compatible Laplacian adapter is bit-identical to FermiNet's default. Swap the kernel, keep the physics - the energy curve does not move.
Operators, not just numbers
Gradient, divergence, curl, Hessian, Jacobian, Laplace-Beltrami, exterior derivative, and multivariate jets - all closed-form contractions of the same exact tower.
One source of truth, every backend, end to end
The polynomial coefficients live in one pure-Python core. Every backend imports them, so the closed-form derivative math is bit-identical across backends by construction.
Identical answers. Dramatically less compute.
float64 on a single data-center GPU. Every method agrees to ≤ 1e-15 - the speedups are bit-for-bit, never an accuracy trade.
float64, GPU, H = 256, B = 4096. Lower is faster. All methods agree to <= 1e-15.
MiB, process-isolated per method. Lower is better.
Per-sample overhead over the forward pass. omnibias is O(1) in D; dense-Hessian autodiff is O(D²).
milliseconds. omnibias is flat in k; folx-nested OOMs at Δ⁴.
Conditions: H = 256, B = 4096, float64, data-center GPU. Full derivation and reproduction scripts in the documentation.
Where closed-form derivatives change the calculus
If your inner loop spends its time on Laplacians, Hessians, jets, or certified bounds, Derivon is built for you.
Neural quantum chemistry
Local kinetic energy and relativistic Δᵏψ corrections for FermiNet / DeepQMC-class wavefunctions.
Physics-informed ML
Stable Laplacians and high-order PDE residuals for biharmonic, Kuramoto-Sivashinsky, and Cahn-Hilliard systems.
Certified surrogates
Rigorous residual and robustness enclosures for model statements your safety reviewers will accept.
Second-order optimization
Closed-form Hessian, Fisher, and KFAC factors for natural-gradient and curvature-aware training.
Equation discovery
Read exact derivative jets off a fitted field and recover the governing ODE/PDE - a library-free SINDy variant.
Differential geometry
Metric, Christoffel, curvature, and Laplace-Beltrami on learned manifolds, validated against the round sphere.
A kernel your reviewers can inspect
Ship faster simulations
Cut wall-clock and memory in the inner loop without touching your model's physics or its converged answers.
De-risk the numerics
Bit-identical cross-backend results and certified enclosures replace 'trust me' with reproducible, falsifiable evidence.
Spend less on compute
63-108x memory reductions on high-dimensional Laplacians mean smaller instances and larger batches per GPU.
Put closed-form derivatives in your inner loop
Send us one derivative bottleneck. We will benchmark a closed-form, bit-stable replacement against your current autodiff path - on your problem sizes.
Or email info@derivon.ai