Every operation in mathematics, replaced by one. Does that help a neural network?

§1Topology instead of vocabulary

Language models read mathematics as a flat token sequence like [sin, (, x, +, 1, )], and must memorize precedence rules and distinct behaviors for dozens of operators. In EML form, any continuous expression becomes a strict binary tree where every internal node is the exact same gate. A graph neural network reading that tree never has to learn what an operator is, only where things connect: purely topological routing, three token types (eml, 1, variables) instead of an open vocabulary.

§2What the original proposal got wrong

The first proposal pitched “EML-native foundation models for universal mathematical reasoning.” A 10k-expression prototype (Goals 1–5, complete) measured the premises. Where the data disagreed, the claim was rewritten in red, with the evidence attached. GEML is now a controlled representation study, not a moonshot.

1. Shrinking the vocabulary to one operator shrinks the math. Raw EML trees are ~11–12× larger than ASTs. Compression makes EML trainable; whether homogeneity then generalizes better is the hypothesis under test. evidence: mean α ≈ 10.6, median ≈ 11.4, vs threshold ≈ 1.56 (Goal 2)
2. GPT-4-level mathematical competency at a fraction of the parameters. Competitive accuracy with fewer parameters, on a bounded algebraic domain. unfalsifiable as stated → explicit parameter-efficiency experiment (Goal 11.2)
3. A leap toward universal, zero-shot automated theorem proving. Verified equational rewrite-proofs on a bounded domain, with a verifier gating every step. GEML operates on a bounded algebraic fragment (Goal 8)
4. Equivalence as graph isomorphism. Equivalence is semantic, not structural: learned from e-graph-generated pairs with rule provenance, never assumed from shape. equivalent expressions are generally not isomorphic graphs (Goal 6.1)
5. EML as the universal “machine code” all AIs use to think about mathematics. Removed from claims. At most a speculative closing remark for future work. claim discipline, agreed for the release (Goal 12.2)

§3The α threshold, and the race to get under it

Let α = |T_EML| / |T_AST|, the factor by which the tree grows when rewritten in pure EML. Counting representable expressions (Catalan shapes × operator labels × leaf choices) gives a break-even point: the single-operator representation wins only if

α < 1 + log_4L(K) ≈ 1.56 (current grammar)

Raw EML misses that by an order of magnitude. Three families of compression (exact DAG sharing, semantic e-graph rewriting, and motif dictionaries) close the gap. All figures below are measured on the v1 corpus (10k expressions), converted with the official EML compiler, no abbreviations, no hidden leaves.

Null results are recorded with the same prominence as wins: the learned methods that didn’t pay off are documented and off the critical path. 262/262 tests green on a fresh clone of the prototype.

Three channels carry forward into every experiment

§4Goals 6–12, each behind a gate

Goals 1–5 (data, expansion study, DAG, e-graph, ML compression) are done in the prototype and will be rebuilt from scratch at scale in this repository, not copied. Every learning goal ends at a gate: an explicit pass/fail criterion that decides whether the next goal proceeds, proceeds narrowed, or stops.

1. Goals 1–5 · complete (prototype)

   Representation & compression pipeline

   Generator, AST/EML converters, expansion study, DAG, e-graphs, motifs; to be re-implemented at 10–100× scale with full review.

2. Goal 6

   Equivalence learning grid

   Can a GNN learn E₁ ≡ E₂, and under which representation? Trace-rich pair dataset (≥50k pairs with rule provenance), GIN + compute-matched transformer + trivial baseline, 6-arm grid, depth- and family-OOD.

   Gate G6. All GNN arms beat the trivial baseline, else stop and fix the dataset; the EML-vs-AST verdict is recorded either way.
3. Goal 7

   Rewrite-step prediction

   From a state graph, predict (rule, application site). The sharpest EML test: does homogeneous topology help rule application transfer across contexts?

   Gate G7. Learned policy beats uniform-random valid steps by a wide margin; no dead rules.
4. Goal 8

   Verified proof-path generation

   Best-first search over rewrites with a verifier on every step; value head guides search; simplification mode reuses exact-cost machinery; frontier LLMs run as a reference ceiling through the same verifier.

   Gate G8. Guided search beats uniform on nodes-expanded at equal success; zero invalid steps emitted.
5. Goal 9

   Symbolic regression track

   EML’s predicted native home: recover f(x) from samples. EML-space vs AST-space search, against PySR/GP and transformer-SR baselines.

   Gate G9. Exact recovery above the GP baseline at matched budget, or a documented negative.
6. Goal 10

   Domain expansion: trig

   The stress test: trig may explode EML size. Extend compiler and rules, rebuild the corpus, re-measure α, re-run any grid whose verdict could flip.

   Gate G10. Expanded compiler passes purity and numeric audits; α behavior for trig documented.
7. Goal 11

   Scale-up & final comparison

   Corpus at 10–100×, scaling curves per channel, the parameter-efficiency hypothesis tested explicitly, frontier-LLM comparison normalized by the verifier.

   Gate G11. Every headline number ships with denominators, multi-seed variance, and scaling caveats resolved or stated.
8. Goal 12

   Consolidation & release

   Findings report (positive or null, equal prominence), one-command reproducibility package, paper under the agreed claim discipline.

Predictions on record

§5Who does what

• 2–3 people bridge both groups as supervisors with end-to-end visibility.
• Documentation is continuous: every member documents their work as it lands, with no end-of-project crunch. This is what makes the paper writable.
• Paper: 5–7 days before the deadline, two members start writing; the rest become reviewers once code is frozen.
• Open decision: which constants to implement. π and e are candidates; i is likely out (it would change the pipeline fundamentally).
• Agent policy: the prototype repo is for understanding, not for templating; agents rebuild here from specs, never copy its structure.