The Magic of One Button: How the EML Operator Tames All Elementary Math Functions

Imagine holding a scientific calculator covered with buttons: sin, cos, tan, log, √, π, e... Behind each button lies its own set of mathematical rules. We spend years learning these functions, memorizing their formulas, and understanding their properties.

Now imagine someone telling you: those buttons are all redundant.

With just two buttons—one labeled "EML" and one labeled "1"—this calculator can do everything the others can. Computing a sine? Press EML a few times. Square root? EML. The value of π? EML again.

It sounds like magic, but it's real.

The "Broken Calculator"

There's a fun problem in mathematics called the "broken calculator": if most of your calculator's keys stop working and only a few remain, can you still compute what you need?

Andrzej Odrzywołek of Jagiellonian University in Poland (an researcher who wanders between astrophysics and computational mathematics) pushed this problem to its extreme. He wasn't satisfied with moderate versions like "only the four arithmetic operations" or "only exponentials and logarithms." He wanted to know: can we go lower? And lower? Until we reach the minimum.

The answer is: one binary operator plus one constant.

The operator he found is called EML, short for "Exp-Minus-Log":

eml(x, y) = exp(x) - ln(y)

That's it. e to the power x, minus the natural log of y. Add the constant 1, and that's the entire toolkit.

How the Magic Works

The exponential function

The most direct case:

exp(x) = eml(x, 1)

Since ln(1) = 0, eml(x, 1) = exp(x) - 0 = exp(x). One step, done.

The natural logarithm

This one is trickier, requiring four levels of nesting:

ln(z) = eml(1, eml(eml(1, z), 1))

Expand it: the inner eml(1, z) = e¹ - ln(z) = e - ln(z), then wrap another layer... trust the math—it really equals ln(z).

Multiplication

Multiplication requires nesting to depth 8. The formula looks wild, but the logic holds: once you have exp and ln, you can use logarithmic conversion to turn multiplication back into addition, and then express addition through EML combinations.

x × y = exp(ln(x) + ln(y))

Since EML produces exp and ln, it produces multiplication.

The constants π, i, and e

Even mathematical constants emerge from EML and 1:

• e = eml(1, 1)
• π can be obtained via the path ln(-1) = iπ
• i (the imaginary unit) hides in the branch choice of the complex logarithm

All of this, from just eml(x,y) = exp(x) - ln(y) and the number 1.

Why This Matters

A "minimal generating set" for mathematics

In digital circuits, there's a classic result: all Boolean logic can be built from a single NAND gate. Whether you want AND, OR, NOT, or more complex logic, repeated NAND combinations suffice.

But for continuous mathematics—the kind dealing with real and complex numbers—people assumed no such "universal building block" existed. You needed addition, multiplication, exponentials, logarithms, trigonometric functions... each with its own role, none dispensable.

Odrzywołek's result proves: continuous mathematics has its NAND gate. EML is that single atomic operation; everything else is derived from it.

A unified data structure

In the EML world, every mathematical expression becomes a binary tree. Every node has the same shape—an EML operation—differing only in leaves (some are 1, some are input variables).

What does that mean? All elementary functions share a single grammar:

S → 1 | eml(S, S)

This is the unified representation computer scientists dream of. sin(x), √x, e^x—all become instances of the same structure in EML form. This opens new doors for symbolic computation, equation discovery, and code optimization.

Implications for AI

The second half of the paper presents an interesting application: symbolic regression with EML trees.

Symbolic regression means: given data points, find the formula that generates them. Traditional methods search a vast function space, but EML's unified structure compresses that space dramatically.

Using a standard Adam optimizer, training EML trees of depth at most 4, the author successfully recovered exact closed-form elementary functions from numerical data. Even better, the same architecture can fit arbitrary data—but when the underlying law really is an elementary function, it automatically discovers the exact formula.

This evokes the question of activation function choice in neural networks. ReLU is popular partly because it's simple, differentiable, and composable into complex behavior. Could EML become a new "differentiable computational primitive," especially in applications requiring symbolic interpretability?

The Intuition Behind the Math

Why exp(x) - ln(y) specifically?

Odrzywołek says he found it through a "systematic exhaustive search." But there's some intuition to share:

exp and ln are inverse operations. Like addition/subtraction or multiplication/division. When they appear in the same expression, they create an interesting "tension"—one grows, the other shrinks. This asymmetry may be the source of the operator's expressive richness.

Subtraction is non-commutative. eml(x,y) ≠ eml(y,x). This gives expression trees "directionality"—the same nodes in different orders produce different results. That freedom is essential for building complex functions.

The paper also mentions two EML "cousins":

• EDL: exp(x) / ln(y), requiring the constant e
• -EML: ln(x) - exp(y), requiring the constant -∞

So EML isn't the only answer—but it's the simplest, needing only the constant 1.

Some Reflections

Educational possibilities

If EML ever went mainstream, what would math education look like? Imagine students no longer memorizing multiplication tables or agonizing over sin and cos definitions, but learning a "universal computational language" where every operation is an arrangement of one basic block.

It sounds radical, but intriguing. Of course, real teaching must respect cognitive development: children need concrete before abstract. But EML at least provides a conceptual anchor: whatever function you learn, remember it's just a different face of the same root.

The philosophy of computation

There's also a philosophical point: the relationship between simplicity and complexity.

We assume complex things (a scientific calculator's full functionality) need complex components (36 buttons). But mathematics keeps telling us: complexity often emerges from the iterated application of simple rules.

From Conway's Game of Life to the Mandelbrot set, from NAND gates to the EML operator, the world seems to love generating "much" from "little."

It recalls physicists' drive toward a "theory of everything." EML isn't physics's theory of everything, but it displays a similar minimalist aesthetic: one primitive, explaining it all.

About the Author

Andrzej Odrzywołek is a researcher at the Institute of Theoretical Physics, Jagiellonian University, with a background spanning astrophysics, general relativity, and computational mathematics. He has studied black hole accretion, supernova explosions, and neutrino astronomy—and even wrote a playful paper titled "How to Build the Perfect Igloo."

The EML paper extends his research line on "numerical constant identification"—a long-standing interest in recovering formulas from numbers. A 2020 arXiv preprint on standards for identifying numerical constants was an earlier step; finding EML via exhaustive search is a natural continuation.

Interestingly, the discovery was entirely unexpected. As the paper states: the existence of such an operator "was not anticipated; I found it through a systematic exhaustive search."

Many major breakthroughs in science happen this way: not derived from theory, but popping out of "let's try it" computer searches.

Conclusion

Next time you pick up a scientific calculator, or call Math.sin() or Math.log() in code, consider this: these seemingly independent functions can all grow from one simple combination.

eml(x, y) = exp(x) - ln(y)

One formula, plus the number 1. That's everything.

The beauty of mathematical simplicity sometimes hides in the most unexpected places.

---

Reference paper:

• Odrzywołek, A. (2026). *All elementary functions from a single binary operator*. arXiv:2603.21852
• Paper link: https://arxiv.org/abs/2603.21852

Further reading:

• Sheffer stroke (the NAND-gate equivalent in Boolean logic)
• Wolfram's search for a "theory of everything"
• Symbolic regression and AI-driven scientific discovery

*"The mark of truly understanding something is being able to explain it in simple language."*

*— a physicist who liked playing the bongo drums*