Correction (2026-09-13): this post said the solutions are the minimal EML trees for their functions, the cheapest possible representations in the F16 census. Nothing shows that. The node counts are constructions from the SuperBEST v5.2 table, counted in F16 nodes, and only a few table entries have lower bounds.

Functional equations are how mathematicians define the elementary functions without reaching for calculus. f(x + y) = f(x) · f(y) for every real x, y — together with continuity — forces f(x) = eᶜˣ. Change one symbol and you get the logarithm instead: f(xy) = f(x) + f(y) gives f(x) = c · ln x.

What’s rarely noticed is how small the solutions to these equations are as trees. The Cauchy equations don’t just produce exp and ln: their solutions take 2 or 3 F16 nodes in the SuperBEST table. Those are constructions; whether any is the cheapest possible is not shown, since only a few SuperBEST entries have lower bounds (see /superbest).

Ten olympiad-style problems, run through the SuperBEST v5.2 cost table. Every number below is a node count, not a marketing figure.

The Cauchy trio, in nodes

Additive Cauchy. f(x + y) = f(x) + f(y) → f(x) = c · x. That’s one mul — mul = 2n. The equation itself is addition (also 2n). Input operation and output function share the same budget.

Exponential Cauchy. f(x + y) = f(x) · f(y) → f(x) = eᶜˣ. Compute c · x (2n), then apply exp (1n). Total: 3n. The gap between 2n and 3n is exactly one exp node — the operator that turns addition into multiplication. That’s the whole folklore in one number.

Logarithmic Cauchy. f(xy) = f(x) + f(y) → f(x) = c · ln x. One ln (1n) via EXL(0, x), then mul (2n). Total: 3n — the same as exponential Cauchy. exp and ln are conjugate, and that conjugacy shows up in the node count.

Solutions are often cheaper than their equations

f(x + y) = f(x)·eʸ + f(y)·eˣ → f(x) = k · x · eˣ.

On x > 0 the solution factors through exp(ln x + x): one ln (1n), one add (2n), one exp (1n). Solution cost: 4n.

The right-hand side of the equation, on the other hand, requires two mul (4n), two exp (2n), one add (2n) — 8n per evaluation. The functional equation costs twice what its solution costs. This is not a coincidence specific to this problem: fixed points of cost-heavy constraints tend to live at low cost.

The multiplicative Cauchy family is a 3-node primitive

f(xy) = f(x) + f(y) + f(x)·f(y) → f(x) = xᵏ − 1.

EPL(k, x) = exp(k · ln x) = xᵏ is a single F16 node (verified at machine precision on a 100 k-sample random sweep — max relative error 2 × 10⁻¹⁵). Subtract 1 and you’re done. 3n total.

Every power-law scaling relation — Zipf, Pareto, allometric biology, Kepler’s third law, Stefan-Boltzmann — lives in this cell. They are all the same 3-node tree with different values of k.

An inequality is a cost comparison

x + 1/x ≥ 2 + ln²(x) for x > 0.

• LHS tree: add(x, recip x) — 3n.
• RHS tree: add(2, mul(ln x, ln x)) — 5n.

A 3-node expression bounds a 5-node expression from above, with equality at x = 1. The cheaper tree is the upper bound.

Does this direction always hold? Not quite — the classical AM-GM inequality (a + b) / 2 ≥ √(ab) bounds a 4-node arithmetic mean above a 3-node geometric mean. Here the more expensive tree is the upper bound. Cost is silent on the direction of the inequality; it just tells you which trees are in play.

Power means have a cost hierarchy

For a, b > 0:

The harmonic mean is the most expensive, which is why numerical code usually rewrites it as 2ab / (a + b) — that drops one recip pair and lands at 6n. EML accounting makes the rewrite quantitative: it’s a 2-node saving, independent of input.

The recurrence that climbs an EML tower

f(x) = exp(f(x − 1)) + ln|x| is a one-shot EAL per step. f(n) from f(0) takes n applications of the EAL operator, stacked. That’s a linear growth of the tree’s depth with x, one new node per step, the same shape as the exp^k tower of T30. Whether a tower like this can be shortcut is open in general: that exp^k needs exactly k nodes is a conjecture (T30), and MachLib proves it for k ≤ 4.

The ln|x| term puts the equation on the ELC boundary for x < 0: absolute value is piecewise, so the negative-axis branch formally sits outside pure ELC. Restrict to x > 0 and the whole tower is ELC-interior.

The hyperbolic-vs-trigonometric split

f(x+y) + f(x−y) = 2·f(x)·cosh(y) + 2·x·sinh(y) has the solution family f(x) = a·x·eˣ + b·x·e⁻ˣ + c. All three summands are inside ELC: x·eˣ via exp(ln x + x) (4n) and x·e⁻ˣ via the DEML primitive (3n, because DEML(x, 1) = e⁻ˣ is a 1-node operator; multiplying by x adds 2n). Full solution: about 15n.

Replace cosh and sinh with cos and sin and the same equation has solutions in the trig family — which the Infinite Zeros Barrier (T01) rules out of any finite real EML tree. One symbol change flips the problem from ELC-interior to ELC-exterior.

One impossibility, two mechanisms

f(z)² = eᶻ + e⁻ᶻ = 2·cosh(z). On the real line f(z) = √(2·cosh z) is a clean 5-node construction (4n for the sum of two exponentials, +1 for the square root). Over the complex plane, cosh has zeros at z = iπ(n + 1/2), each of which becomes a branch point of the square root — and an entire function can’t carry a countable lattice of branch points.

The Olympiad problem’s impossibility is structurally the same as the Infinite Zeros Barrier, running in reverse. In T01 a function has too many zeros to sit inside real EML; here the function’s square has zeros that obstruct the square-root’s entirety. Same analytic source, different direction.

Reproduce

git clone https://github.com/agent-maestro/monogate-research       # private
cd monogate-research/exploration/olympiad-sessions
python scripts/verify_claims.py          # the 6 baseline identities
python scripts/olympiad_eml.py           # the 10-problem node-cost table

Both scripts output JSON to data/ and a markdown note to findings/. Every number in this post comes from one of those files. The post itself is OBSERVATION tier — it cites classical Olympiad solutions and adds the node-count layer; it does not claim new theorems.

The pattern

These ten problems don’t agree on which side of an inequality to put which tree, or whether the equation is larger than its solution or smaller than it. They agree on one thing: the solutions are tiny EML trees. A functional equation that defines exp, ln, or a power produces a 1-, 2-, 3-, or 4-node tree as its answer. The operator structure that generates elementary functions generates low-cost trees. That’s what “EML is the universal operator” means in practice — not a philosophical claim, a node-count claim that survives every concrete olympiad case we tested.