Project: Symbolic Regression in the Browser

Hand the machine 25 points sampled from a hidden function and ask for the function back — not a fit, the formula. The engine below does it the bluntest way possible: it tries every formula, shortest first, and keeps the best one. That brute-force core is the inner loop of AI Feynman (Udrescu & Tegmark, 2020); everything clever in that paper is a way of making this loop's job smaller. The engine is written in Knot, compiled through C to a 42 KB WebAssembly module by the same pipeline as the in-browser SCF, and races about 4.4 million candidate formulas when you press run.

How the search works

A formula is a string in reverse Polish notation over a ten-symbol alphabet: the leaves $x$ and $1$, four binary operators, and four unary ones. Enumerating "every formula" means counting through $10^L$ symbol sequences at each length $L$ and discarding the ones that don't parse — a sequence is a valid program exactly when its stack depth never goes negative and ends at one. At $L\le 6$ that's 1,111,110 sequences per mystery, of which 20,090 survive the stack check. Each survivor is evaluated on the 25 data points and scored.

# the entire search, structurally (see the Knot tab above for the real thing)
for L in 1..6:                      # length = description length: short first
    for every sequence in {x, 1, +, -, *, /, sin, exp, sqrt, neg}^L:
        if not valid_rpn(seq): continue          # stack must end at depth 1
        c = sum(y*f)/sum(f*f)                    # best prefactor, closed form
        err = rms(y - c*f)
        if err < best: crown_champion(seq, c, err)

Trying lengths in order is not just tidy bookkeeping — it is the prior. A formula found at length 4 is preferred over an equally-fitting one at length 6 because the enumeration got there first: candidate number $k$ in the count costs about ${\log }_{2}k$ bits of description length, so "search short-to-long" and "prefer simple explanations" are the same act. The Pareto table under each finished race makes this concrete: at every length there is a best-effort formula, and the champion is wherever error collapses to machine zero.

One free constant, fitted in closed form

The alphabet has no constants except 1, which would make targets like $2.5x\sin x$ unreachable. The fix costs one line: score each candidate $f$ as $y\approx cf(x)$ with the multiplicative prefactor chosen by least squares, $c=\sum yf/\sum f^2$. The structure is searched discretely; the scale is fitted continuously. Watch Mystery B: the engine finds the shape $x\sin x$ at length 4 and the fit hands it $c=2.5$ for free.

# least-squares multiplicative prefactor: y ~ c * f
syf = 0.0
sff = 0.0
for p to NPTS {
    f = eval_rpn(L, xs[p])
    syf = syf + ys[p] * f
    sff = sff + f * f
}
cbest = syf / sff
sse = syy[0] - cbest * syf     # = sum(y^2) - c * sum(y f), expanded square

The champion races are worth replaying. On $x^2+x$ the engine climbs through $e^x$, then $x^2$, then — a genuine surprise — $\sqrt{x}\cdot x=x^{1.5}$ with a fitted prefactor, which on the sampled interval is a better one-term compromise between the linear and quadratic pieces than either alone. And on $e^{-x^2}$ it lands on the equivalent form $\exp ((-x)\cdot x)$ — same function, different tree, one token cheaper than negating the square.

What AI Feynman adds on top

This page is the paper's inner loop, isolated. The full method wraps it in machinery whose only purpose is to shrink $L$ before the enumeration starts: dimensional analysis removes variables outright (a nullspace computation over the units matrix), a neural network trained on the data is interrogated for symmetries and separability — if $f(x_1+a,x_2+a)$ never changes, search in $x_1-x_2$ instead — and a sequential statistical test kills bad candidates after a handful of points instead of all of them. Each trick buys another variable or another token of headroom, and the same dumb loop underneath then succeeds where it previously drowned. The symmetry-discovery step is built and running: a neural net that finds the symmetry, watching this exact engine fail on a two-variable mystery and then win after the network hands it a substitution.

The engine itself is a 250-line Knot program (the ① tab above) — flat arrays, loops, and the ten-way opcode dispatch, the same idiom as the playground's symbolic-differentiation preset. The numeric output protocol is a small trick of necessity: Knot prints numbers only, so the browser component keys on labeled show lines and decodes the RPN back to the formulas you see.

There is also an opposite strategy: skip the search entirely, fit one continuous function family whose parameter space contains the familiar formulas, and identify the answer by where the fit lands. That engine — Meijer G-functions, digamma gradients, same compiler, same 42-kilobyte-class wasm — runs at Formula Discovery Without Search.

Reproduce it

scripts/build_sr_wasm.sh rebuilds everything: symbolic_regression.knot → knotkit C backend → emscripten. The native binary runs all four searches in 0.11 s; the wasm build is the same program with a different final compiler flag. Nothing on this page is precomputed — the numbers, champions, and Pareto tables come out of the search running on your machine.