Two Buttons and a Constant
In digital electronics, a single gate — NAND — can build any Boolean circuit. Every AND, OR, NOT, and XOR is just NAND gates wired together.
Continuous mathematics never had an equivalent. Scientific calculators need many buttons — exp, ln, sin, cos, √, the four arithmetic operations — and while mathematicians have known these are redundant (Euler's formula collapses trig into complex exponentials, logarithms turn multiplication into addition), no one had reduced the whole repertoire to a single primitive.
Until now, apparently. Andrzej Odrzywolek, a theoretical physicist at Jagiellonian University, found one:
eml(x, y) = exp(x) − ln(y)
That's it. This operator, paired with the constant 1, generates the entire standard repertoire of a scientific calculator. Integers, fractions, π, e, i, addition, subtraction, multiplication, division, exponentiation, logarithms, trig — all of it, from two buttons.
The key insight is that ln(1) = 0, which lets you neutralize the logarithmic term: eml(x, 1) = exp(x). From there, you recover the natural logarithm through a nesting trick: ln(x) = eml(1, eml(eml(1, x), 1)). Once you have both exp and ln, subtraction comes from composing them, negation from subtracting from zero, addition from double negation, and multiplication from the classical exp(ln(a) + ln(b)) identity. Exponentiation follows, then everything else.
Odrzywolek found this by systematic exhaustive search — iteratively ablating primitives from a 36-element scientific calculator basis set and testing whether the remainder could still reconstruct everything. The search stalled at three primitives, which told him a single binary operator might exist but wouldn't be among the familiar named functions. He began enumerating candidate binary operators built from elementary pieces. After, in his words, "numerous failures and a few discarded false-positives," EML emerged.
The calculator
The paper's Table 4 gives the complexity of various functions in EML form. Some are compact — exp(x) is just three RPN tokens. Others are not — multiplication requires 17, and trig functions have trees too large to print. This made me want to see the trees.
So we built an interactive EML calculator. Type a mathematical expression, and it:
- Parses and evaluates it directly (complex arithmetic, IEEE 754-compatible)
- Compiles it to a pure EML tree using the verified rewrite chain from the paper
- Evaluates the EML tree independently and confirms the results match
- Renders the tree as an interactive SVG — diamond nodes for EML gates, colored circles for leaves, with hover inspection showing the value flowing through each node
Try 2 * 3. The direct answer is 6. The EML tree has 41 nodes, 20 EML gates, and a depth of 8. Multiplication is expensive in EML-land because it routes through exp, ln, addition (which itself routes through subtraction and negation), and each of those has its own nesting depth. The RPN program is 41 tokens long. Every one of those tokens is either the constant 1, a numeric leaf, or the letters eml.
Now try exp(1). That's just eml(1, 1) — three tokens, one gate, the constant e. The simplest non-trivial computation in EML.
We had Claude in Chrome independently verify the implementation against the paper. Every formula, identity, and construction checks out. The one implementation note: the calculator uses numeric leaf values beyond just 1 as shortcuts for user-entered expressions, which is consistent with the paper's own compiler approach.
Why it matters
The paper's grammar is S → 1 | eml(S, S). That's a context-free language isomorphic to full binary trees and Catalan structures. Every elementary function expression becomes a circuit of identical nodes — which means the entire space of elementary formulas up to a given depth is searchable by gradient descent. The paper demonstrates this: parameterized EML trees, trained with Adam, can recover exact closed-form expressions from numerical data at shallow depths. When the weights snap to 0 or 1, you get the symbolic formula back.
That's the real punchline. Not just that two buttons suffice for a calculator, but that the uniform structure creates a complete, regular search space for symbolic regression. One trainable architecture, one repeated element, potentially any elementary formula.
Try the EML calculator. The paper is Odrzywolek (2026), arXiv:2603.21852.