SuperBEST v5.2 2026-04-21 arXiv:2603.21852 Taxonomy Locked — 23 ops · No 24th exists

SuperBEST Routing Table

Minimum F16-node constructions for every elementary arithmetic primitive. Proved optimal via derivative obstruction lower bounds and explicit constructions. Taxonomy definitively closed: PROVED — no 24th operator passes PGC+AIT filter on open domain.

PROVED
23
elementary operators
16 base F16 + 7 extended; CONJ_NO_OP_24 closed
OBSERVATION
8
Pfaffian tower generators
max depth ≤ 4 from any tower
BENCH
578
expressions across 12 subdomains
master corpus post Color-Science merge
LIVE
35/36
scientific calculator functions
factorial via Gamma tower (E-201); modulo outside
OBSERVATION
ρ = 0.885
dynamics counter (n=193, p=1.8e-65)
Spearman ρ across elementary + PNE; r ≈ 2·n_oscillation + 1·n_decay + chain_order(generator). Tower-base = chain order, exact 17/18 rows.

23 elementary operators (PROVED closed via PGC+AIT filter) + 8 Pfaffian tower generators (OBSERVATION tier; empirically verified) = 31 operators mapping two tiers of mathematics.

Two-layer accounting policy: Layer 1 (F16) — formal theorems, arXiv paper; counts only F16 orbit nodes. Layer 2 (23-op) — library/ML/physics use; extended operators count as 1n each. Must be labeled.
14n / 80.8% savings (positive domain, exp=ln=mul=recip=pow=sqrt=1n via UpperBounds.lean; mul_pos reconciled + sqrt reconciled to 1n)

Core Arithmetic Primitives (F16 Layer 1)

Operation Nodes (x>0) Naive Construction (positive) Notes
exp(x) 1 1 EML(x,1) = e^x primitive — no domain restriction
ln(x) 1 1 EXL(0,x) = ln(x), x > 0 primitive; domain-restricted to x > 0
recip(x) = 1/x 1 1 ELSb(0,x) = exp(0 - ln(x)) = 1/x, x > 0 R16-C1; X8 audit confirms negative x also handled in implementation
div(x,y) = x/y 1 2 ELSb(ln(x), y) = exp(ln(x) - ln(y)) = x/y, x > 0, y > 0 X7/X8 confirmed: x > 0 hard constraint; y can be negative
neg(x) = -x 2 2 EXL(0, DEML(x,1)) = ln(exp(-x)) = -x; or DEML(x,1)=exp(-x) then EXL gives -x T09; 2n for all reals; positive domain gives no cost improvement
mul(x,y) = x*y 2 2 ELAd(EXL(0,x), y) = exp(ln(x)) * y = x*y, x > 0 T10u; F16 optimal for x > 0. X7/X8 confirmed domain restriction.
sub(x,y) = x - y 2 2 LEdiv(x, EML(y,1)) = ln(exp(x)/exp(y)) = x - y T33; 2n for all reals; X8 confirmed
add(x,y) = x + y 2 LEdiv(x, DEML(y,1)) = ln(exp(x)/exp(-y)) = x + y NEW v5 (ADD-T1): all real x,y. Replaced add_pos=3n and add_gen=11n with unified 2n.
sqrt(x) = x^(1/2) 1 2 EPL(0.5, x) = ELMl(0.5, x) = exp(0.5·ln(x)) = sqrt(x), x > 0 — single F16 node T_SQRT_1N; EPL(0.5,x) = ELMl direct primitive. Same mechanism as pow=1n. Corrected from v5.1 (was 2n). Verified: EPL(0.5,4)=2.0, EPL(0.5,9)=3.0, EPL(0.5,16)=4.0.
pow(x,n) = x^n 1 3 EPL(n,x) = ELMl(n,x) = exp(n * ln(x)) = x^n, x > 0 — single 1-node F16 operator from the 16-operator census X20 RESOLUTION: EPL/ELMl = exp(x*ln(y)) = y^x IS in F16 census. pow(x,n)=x^n=EPL(n,x) for x>0 costs 1n (direct), not 3n. The 3n construction used EXL+ELAd+EML explicitly rather than recognizing EPL as a primitive. For positive domain: corrected to 1n.

Extended Operators (23-op Beyond F16)

Category A: genuine F16 algebraic shortcut. Category B: genuine via EML sign-variant. Category C: notation-only (23-op counts 1n; F16 costs 3–4n; no F16 shortcut exists).

Operator F16 cost (Layer 1) 23-op cost (Layer 2) Genuine saving Category Description
EEM 3 1n 1 A Algebraic shortcut (add+exp)
EED 3 1n 1 A Algebraic shortcut (sub+exp)
EES 1n/4n 1n 3n(const)/0n(gen) B/C Genuine F16 for const arg; notation-only general
LLA 3 1n 1 A Algebraic shortcut (mul+ln)
LLS 3 1n 1 A Algebraic shortcut (div+ln)
LLD 4 1n 0 C Notation-only — no F16 shortcut
EEA 4 1n 0 C Notation-only — enables LSE=2n in 23-op

High-Impact Expressions

Layer 1 = F16 ground-truth; Layer 2 = 23-op extended (must be labeled)

ML / Smooth Functions

ExpressionNaiveF16 (Layer 1)23-op (Layer 2)Saving type
softplus ln(1+exp(x)) 4n 2n 2n B: EML(x,1/e)+ln
LSE(x,y) = ln(exp(x)+exp(y)) 8n 4n 2n F16: exp+exp+add+ln (corrected from 5n)
sigmoid 1/(1+exp(-x)) 6n 4n 3n F16 route
KL term l*ln(l/m) 6n 5n 3n A: div+ln+mul

Quantum / Information

ExpressionNaiveF16 (Layer 1)23-op (Layer 2)Saving type
quantum rel entropy (per term) 6n 5n 3n A: genuine 1n save
von Neumann entropy (per term) 8n 7n 4n A: 1n save
Bures distance 5n 4n 3n B: genuine
partition fn pair exp(-bEj)/exp(-bEi) 10n 10n 7n C: EEA notation-only
spectral decay exp(-g*t) 4n 3n 2n A: mul+exp
Kraus factor sqrt(1-exp(-g*t)) 6n 4n 3n B: EML-variant+EPL

Physics

ExpressionNaiveF16 (Layer 1)23-op (Layer 2)Saving type
Boltzmann ratio exp(-b*(Ej-Ei)) 10n 6n 5n A: sub+mul+neg+exp
Mayer f-function exp(-b*u)-1 6n 3n 3n B: EML_neg+mul
hydrogen radial decay 4n 3n 3n B: genuine
Fermi-Dirac 1/(exp((e-m)/kT)+1) 8n 6n 4n A: algebraic route

Special Functions (all require infinite F16 depth)

FunctionF16 costReason
erf(x) T01: infinite zeros
J_0(x) Bessel T01: infinite zeros
Gamma(x) AIL theorem
sin(x), cos(x) T01/AIL: proved

Pfaffian Tower Extensions OBSERVATION

Empirically verified at sample points, not Lean-proved. The 'no single operator spans two towers' theorem is open (CONJECTURE). The 8 tower families form a 3-rooted hierarchy under DLMF closed-form identities (see hierarchy_note below). Adding 8 tower generators to the EML grammar brings 33 previously-infinite-depth functions inside finite EML trees of depth ≤ 4. Tier label: OBSERVATION (empirical, not Lean-proved).

Tower Generator Functions Examples Max relerr
T_erf erf 6 erf, erfc, erfi, dawson, fresnel{s,c} ~1e-31
T_Si Si 6 Si, Ci, Shi, Chi, Ei, li ~1e-31
T_J J_0 6 J_0, J_1, Y_0, I_0, K_0, H_1 ~1e-31
T_Ai Ai 4 Ai, Bi, Ai′, Bi′ 1.5e-7 (via ODE)
T_Γ Γ 5 Γ, lnΓ, ψ, β, ψ_n ~1e-18 (one tricky sample)
T_W W 2 W_0, W_{−1} 0 (exact, no integral)
T_K K(m) 3 K, E, F ~1e-31
T_F _2F_1 1 _2F_1 (super-tower) 0 (exact, series)

Verification: 2 towers exact (W, F); 4 towers to ~1e-31 — erf, Si, J, K (mpmath@30-digit precision at sample points); Γ to ~1e-18 (one tricky sample, others 0.0); Airy via the defining ODE Ai″(x) = x·Ai(x) to 1.5e-7 (the cubic-phase improper integral resists direct mpmath.quadosc convergence).

Hierarchy (3-rooted): Pairwise pass over all 28 tower pairs (28-pair probe in exploration/tower-independence-2026-04-27/): 5 SUBSUMES — T_F (₂F₁) covers T_erf, T_Si, T_J, T_Ai, T_K via DLMF identities (7.18.5, 6.11.2, 10.16.5, 9.4, 19.5.1). 1 PARTIAL — T_Ai ⇆ T_J via fractional-order Bessel (DLMF 9.6.1). 22 INDEPENDENT pairs. The 8 families form a 3-rooted hierarchy: in the F16 grammar all 8 are operationally needed; in the abstract Pfaffian-closure sense the minimum generating set is {T_F, T_Γ, T_W} = 3. Minimum generating set in the abstract Pfaffian-closure sense: {T_F, T_Γ, T_W} = 3 towers. All 8 remain operationally needed in the F16 EML grammar (which lacks parameter-substitution primitives).

Outside the closure: Functions still outside the 23-op + 8-tower closure: zeta-family beyond polylog, modular forms, modulo, set/Boolean ops, generic non-computable. See the atlas page for the full out-of-closure list.

Honest Savings Summary

Catalog Layer 1 — F16 genuine Layer 2 — 23-op extended
Core arithmetic (9 ops) 80.8% 80.8%
ML functions (6 items) ~35% ~55%
Quantum (8 items) ~15% ~35%
Physics (5 items) ~30% ~45%
Special functions 0% (all inf) 0% (all inf)
Aggregate ~12% ~40%

Verify it yourself

Reproduce the cost analysis on your own machine. `eml-cost 0.12.0` is live on PyPI; the 578-row corpus is bundled inside the wheel.

Install bash
pip install eml-cost
Cost class for any expression python
from eml_cost import analyze
from sympy import symbols, exp, sin

x, t = symbols('x t')
a = analyze(exp(-x) * sin(t))
print(a.cost_class)        # 'p2-d5-w2-c1' — the headline cross-domain class
print(a.pfaffian_r, a.is_pne)   # 2  False
Predict dynamics counter (E-196 slope-2 rule, ρ=0.885) python
from eml_cost import analyze_dynamics
from sympy import symbols, exp, sin, cos

x, t = symbols('x t')
d = analyze_dynamics(exp(-x) * sin(t) * cos(2*t))
print(d.predicted_r)       # 5  (1 decay + 2 oscillation modes)
print(d.confidence)        # 'high'
Find structural siblings across the 578-row corpus python
from eml_cost import find_siblings
from sympy import symbols, sin, pi

x = symbols('x')
for s in find_siblings(sin(pi*x)/(pi*x), max_distance=0)[:3]:
    print(s.distance, s.expression, s.domain)

Code matches the published 0.12.0 API. `analyze_dynamics` and `find_siblings` ship in 0.10.0+ (rolled up into 0.11.0 / 0.12.0).

Key results

Full proof: papers and Lean proofs · Machine-verified proofs (Lean 4) ↗ · Interactive: explorer ↗