Exhibits

Each one measures itself.

Nine live exhibits. The math kernel runs on your device in WebAssembly; every frame ships its own joule receipt — Landauer floor, TDP envelope, impedance μ. Open one to watch a kernel earn its picojoules. Open /receipts afterwards to see your session aggregate, and /scale to anchor the numbers on physics.

static L0-closed

cad-eval — does the kernel reproduce the drawing?

The physical-brep B-rep kernel run through the CADSmith protocol: Chamfer Distance / F1@1mm / volumetric IoU, measured by the geometry kernel itself, not judged by a model. Five cases, mean 0.341 mm — at the sub-voxel floor the 0.5 mm reference grid imposes. Faithful, measured not asserted.

cad-eval::brep_agreement

2-D canvas L0-closed

Factor graph — anytime inference, one sweep at a time

Sum-product message passing on the one-step active-inference graph, animated sweep by sweep. Marginals stay proper distributions mid-inference; the convergence trace falls to machine precision; every sweep carries a receipt.

mgai-factor-graph::Graph::sweep

2-D canvas L0-closed

Structure learning — the model grows its own state space

An active-inference learner starts with one hidden state and grows its own state space as observation regimes shift: Dirichlet count learning, threshold expansion, log-Beta Bayesian-model-reduction merges. No gradients; bit-identical on replay.

mgai-active-inference::structure::StructureLearner

2-D canvas cascade

Spine — PCs/NPCs typed contract

The substrate's canonical architecture live: a deterministic Compartment handles the common case, a Leaf only fires on a miss, and a Verifier gates every leaf proposal. Three bars show the per-stage bit-ops asymmetry.

mgai-spine::PcsNpcsRunner

2-D canvas L0-closed

Constrained design — rule encoder over voxel kernel

A parametric sphere under three engineering constraints converges by deterministic seeded search. Watch the cross-section, the ✗→✓ constraint flips, the descending objective — then download the result as a printable binary STL.

mgai-cea::search

2-D canvas L0-closed

Active inference — observe, infer, plan, act

A discrete-time Friston agent minimises variational free energy on each observation and picks the action with the lowest expected free energy. The whole loop is closed-form categorical math at picojoule grain.

mgai-active-inference::Agent::step

2-D canvas cascade

Reason — chain of thought

A small math-domain cascade walks every query through five tiers and emits the trace as the chain of thought.

mathground_view::cascade::walk

2-D canvas L0-closed

Determinism — 1000 FFTs, one hash

Same FFT 256-pt kernel runs 1000 times per frame on a fixed input. Deterministic substrate → 1 unique hash. Toggle a perturbation to see the failure mode Horace He's post calls out.

mathground_view::mount_determinism

2-D canvas L0-retrieved

Code-memory — HDC cosine query, no model

Thirty concept cards encoded as 10 000-dim hypervectors. A query lands in the same space; top-K read off by cosine. Mathground's answer to Graphify-shaped queryable memory, in the substrate's grammar.

mathground_view::mount_code_memory

2-D canvas L0-retrieved

Cascade-memory — structural + similarity, one cascade

One query, two memory paths side-by-side. mgai-graph typed-edge queries resolve at L0-retrieved; HDC cosine ranks the same 30 items by similarity. The cascade reports the routing decision; the receipt records the tier.

mathground_view::mount_cascade_memory

static L0-retrieved

Persistent graph — log → state survives reload

mgai-graph's event-log persistence demonstrated in the browser. Mutations land in localStorage; the page replays them through WASM on every reload and shows the resulting state hash. Same log in → same hash out, every time.

mgai-graph::Graph::from_log

2-D canvas L0-identifiable

Omnimodal — one shape-key space

Text, image, audio, and video each ride a deterministic encoder; the cross-modal cosine matrix is the substrate property.

mathground_view::modal

static L2

Escalate — lazy-loaded L2 leaf

The model tier ships as a separate WASM bundle and only loads when the cascade fails to resolve at L0/L1.

mathground_l2_leaf

2-D canvas L0-closed

FFT — radix-2

Cooley–Tukey radix-2 FFT on a live two-tone signal; power spectrum in dB.

mathground_view::fft::fft_in_place

2-D canvas L0-closed

2-D FFT — visual lineage

Row-then-column 1-D FFT passes on a procedural intensity field, beside its log-magnitude spectrum.

mathground_view::fft2d::fft2d_in_place

2-D canvas L0-closed

Lorenz '63 — RK4

Three coupled ODEs integrated by fourth-order Runge–Kutta; the (x, z) projection of the attractor.

mathground_view::lorenz::lorenz_rk4_step

2-D canvas L0-closed

Heat equation — Euler

2-D explicit forward-Euler diffusion under periodic boundary; integral conserved.

mathground_view::heat::heat_step

2-D canvas L0-closed

Gradient descent — Rosenbrock

Polyak heavy-ball gradient descent on the curved valley, navigating to the minimum at (1, 1).

mathground_view::graddescent::gd_step

2-D canvas L0-closed

Particle filter — 512 particles

Bootstrap SMC on a 1-D sinusoidal target; systematic resample at ESS < N/2.

mathground_view::pfilter::pfilter_step

2-D canvas L0-closed

SDF level-set — marching squares

A 2-D signed-distance field (two smooth-unioned circles) traced by marching squares.

mathground_view::sdf::marching_squares

WebGL2 L0-closed

3-D SDF — sphere trace

Signed distance field (sphere ⊕ box smooth-union) sphere-traced in a WebGL2 fragment shader.

mathground_view::sdf3d::FRAGMENT_SRC

WebGPU L0/L2

Splat world — 3-D Gaussians

Anisotropic Gaussian splats rendered through a full WebGPU pipeline: project → 6-stage radix sort → premultiplied-alpha paint. Upload an image to author a new splat shell and see the substrate cost.

mathground_splat::render

static L0-closed

Sudoku — CSP receipts

AC-3 constraint propagation vs brute force vs Z3 on a canonical CSP set; published receipts.

mgai_proof::verify_with

About these exhibits

Math kernels live in crates/mathground-view, written once in Rust with native tests, compiled to a single 90 KB WebAssembly bundle.
Receipts are computed in your browser by mgai-meter-web — Landauer's kT·ln 2 at 300 K against the kernel's bit-op count, plus a TDP envelope from wall time.
Method labels are honest: every receipt says tdp_estimate + landauer_floor because no live energy counter exists in a browser tab.
Session aggregates accumulate in localStorage on your device. Nothing is uploaded.