The Master Key of Mathematics: One Operator to Rule Them All

A single two-input gate suffices for all of Boolean logic in digital hardware. No comparable primitive has been known for continuous mathematics… Here I show that a single binary operator… generates the standard repertoire of a scientific calculator. — Odrzywołek (2026)

Imagine walking into a concert hall where every instrument—violin, trumpet, drum, oboe—plays a different note, yet all of them are made from the same material, tuned by the same physical law, and fundamentally, are just vibrations in air. Now imagine something stranger: a single vibrating string, plucked in exactly the right sequence, producing the entire symphony.

This is what Andrzej Odrzywołek has discovered in the world of mathematics. Hidden inside the crowded toolbench of elementary functions—sine, cosine, logarithm, square root, addition, multiplication, exponentiation—lies a single, surprisingly simple operation from which every other function can be built. Not approximately. Not in a limiting sense. Exactly.

His name for it is EML.

---

The Mystery of the Crowded Calculator

Pick up any scientific calculator and you will find dozens of buttons: sin, cos, tan, log, √, x², eˣ, +, −, ×, ÷, and more. Each button invokes a different rule, a different algorithm, a different piece of mathematical machinery. For centuries, we have treated this diversity as natural and necessary. You cannot compute a logarithm with a sine wave, or so we assumed.

In digital electronics, however, a strange and beautiful fact has been known since 1913: a single logic gate, NAND, can build every other gate. AND, OR, NOT, XOR—all of them are just NAND gates wired together in clever arrangements. Your entire computer, with its billions of transistors running operating systems, browsers, and language models, ultimately rests on this one humble operation. It is the universal primitive of binary logic.

But continuous mathematics—the realm of real and complex numbers, curves, waves, and rates of change—has never had such a primitive. Until now.

---

Meet EML: The Exp-Minus-Log Operator

The operator is almost embarrassingly simple:

$$\text{eml}(x,y)=e^x-\ln (y)$$

That is it. Exponentiate the first input. Take the natural logarithm of the second. Subtract the second from the first.

If you are wondering how something so small could possibly generate the sprawling family of elementary functions, you are in good company. Odrzywołek found this operator not by deriving it from theory, but by systematic exhaustive search—a computational expedition through the space of all candidate binary operators, testing each one to see if it could reconstruct the full scientific-calculator repertoire. EML emerged as the winner. It was not predicted. It was discovered.

The only other ingredient you need is the constant 1.

---

How One Becomes Many: The Calculator Compression Algorithm

Think of EML as a kind of universal solvent for mathematics. Drop any function into it, and with enough steps, it dissolves and reconstitutes into a binary tree of identical EML nodes.

Here is how a few familiar functions look in pure EML form:

Function	Standard Form	EML Form
Exponential	$e^x$	eml(x, 1)
Natural log	$\ln (x)$	eml(1, eml(eml(1, x), 1))
Constant $e$	$e$	eml(1, 1)
Addition	$x+y$	(see paper; depth-8 tree)
Multiplication	$x\times y$	(depth-8 tree)
Sine	$\sin (x)$	(depth-10+ tree)

The logarithm, for example, requires a nesting of EML operations seven layers deep. It is not elegant in the way a poet means elegance. It is elegant in the way DNA is elegant: a simple alphabet generating astronomical complexity through repetition and structure.

In fact, every elementary expression becomes a binary tree of identical nodes. The grammar is almost laughably minimal:

$$S\to 1|\text{eml}(S,S)$$

This is the mathematical equivalent of discovering that every novel ever written can be encoded using only one letter of the alphabet—provided you are allowed to nest the letter inside itself as many times as you like.

---

The Phylogenetic Tree of Functions

Odrzywołek draws a powerful analogy in his paper: the bootstrapping process by which EML reconstructs the calculator functions resembles a phylogenetic tree of life. EML and the constant 1 act as the Last Universal Common Ancestor (LUCA). From this primordial pair, the exponential function emerges first. Then logarithm. Then negation, reciprocal, and the basic arithmetic operations. Then trigonometric functions. Each new function is built from combinations of already-discovered ones, spiraling outward like the branches of an evolutionary tree.

Here is a simplified ASCII view of how the tree begins:

                         [EML, 1]  ← LUCA
                            |
            +---------------+---------------+
            |                               |
         eml(1,1)                        eml(x,1)
            = e                            = eˣ
            |                               |
            +---------------+---------------+
                            |
                      eml(1, eml(...))
                            = ln(x)
                            |
            +---------------+---------------+
            |                               |
        -x (negation)                  1/x (reciprocal)
            |                               |
            +---------------+---------------+
                            |
                      x + y, x × y, ...
                            |
                      sin(x), cos(x), ...

This is not mere taxonomy. It is a compression algorithm for mathematics. Odrzywołek systematically reduced a 36-button scientific calculator down to just two buttons: 1 and EML.

---

Why This Matters: Symbolic Regression and the Search for Hidden Laws

Here is where the discovery crosses from pure mathematics into machine learning—and connects back to ideas we have explored before.

In our discussion of the Platonic Representation Hypothesis, we saw how different AI models, trained on different data for different tasks, are converging toward a shared internal map of reality. The hypothesis suggests that beneath the apparent diversity of models and methods, there may be a single “platonic representation” that all sufficiently capable systems asymptotically approach.

EML hints at a similar convergence—not in the space of neural networks, but in the space of mathematical expressions. If every elementary function can be expressed as a binary tree of identical EML nodes, then the apparent diversity of formulas in physics, engineering, and finance may be a surface illusion. Underneath, there may be a single, uniform grammar generating them all.

This has immediate practical consequences for symbolic regression: the problem of discovering a closed-form formula from raw numerical data. Traditional symbolic regression searches through a messy space of many different operators (+, −, ×, ÷, sin, cos, exp, log…). The search space is heterogeneous, irregular, and vast.

EML collapses this heterogeneity into a single, regular architecture. Odrzywołek demonstrates that an EML tree can be treated as a trainable circuit: assign learnable parameters to the inputs of each node, optimize with standard gradient descent (Adam), and the tree can “snap” into an exact closed-form expression when the underlying data was generated by an elementary function.

This is not unlike the argument in our analysis of Trustworthy Agent Networks: complex, heterogeneous systems often harbor simpler, more regular structures beneath the surface. The question is whether we architect our search to exploit that regularity, or bolt on complexity and hope for the best.

---

The Master Formula: A Trainable Equation

To make this concrete, consider what Odrzywołek calls the level-2 master formula:

F(x) = eml( α₁ + β₁x + γ₁·eml(α₃ + β₃x, α₄ + β₄x),
            α₂ + β₂x + γ₂·eml(α₅ + β₅x, α₆ + β₆x) )

This single expression contains 14 tunable parameters (the α’s, β’s, and γ’s). By adjusting them, the formula can become:

• $e^x$ (the exponential function)
• $e$ (the constant)
• $e^{e^x}$ (the double exponential)
• …and with deeper trees, any elementary function whatsoever.

Think of it as a stem cell of mathematics: one generic template that differentiates into any specialized function, given the right parameter settings. The search for the correct formula becomes a continuous optimization problem—something modern deep learning is exceptionally good at.

---

Limitations and Open Questions

No honest exploration ends without acknowledging the cracks in the foundation.

Depth and efficiency. While EML can express any elementary function, the resulting trees are often deep and unwieldy. A direct EML compiler produces expressions with leaf counts in the dozens or hundreds for functions as simple as sine or π. This is not how you would want to compute values in practice. It is a proof of existence, not an engineering blueprint.

Branch cuts and edge cases. EML operates in the complex plane internally, even when computing real-valued results. This introduces subtle issues with branch cuts—discontinuities in the complex logarithm that can produce unexpected jumps for negative real inputs. Odrzywołek notes that some formulas fail in standard floating-point environments (Python, Julia, Lean 4) without careful handling of infinities and signed zeros.

The search was heuristic. The discovery of EML relied on numerical bootstrapping and exhaustive search up to expression depth 9. While independently verified with symbolic checks and cross-validation, the method is not a constructive proof in the traditional sense. The author openly notes this and provides a sketch of a completeness proof in the supplementary materials.

Is EML unique? Almost certainly not. Odrzywołek has already discovered close cousins: EDL ($e^x/\ln (y)$, requiring constant $e$) and a variant using $-\infty$ as a terminal. Preliminary searches suggest a ternary operator may exist that requires no distinguished constant at all. The iceberg has more mass below the waterline.

---

The Deeper Pattern: Simplicity Beneath Complexity

EML is not just a mathematical curiosity. It is a case study in a recurring theme across science and technology: the universe tends to hide profound simplicity beneath superficial diversity.

• NAND sufficed for all of digital logic.
• DNA’s four nucleotides encode all known life.
• The Standard Model’s handful of particles generate all matter and force.
• The platonic representation may underlie all capable AI models.

And now, EML sufficed for all of elementary mathematics.

This does not mean we should throw away our calculators and start computing sines with nested exponentials and logarithms. Practicality matters. But the existence of EML changes our ontological picture. The elementary functions are not a crowded zoo of unrelated species. They are a single species, viewed from different angles, at different depths, through different lenses.

---

Further Reading

• Original Paper: Odrzywołek, A. (2026). All elementary functions from a single binary operator. arXiv:2603.21852. PDF | Code
• Related on INFOPARITY: The Platonic Representation Hypothesis — on convergence toward universal representations in AI.
• Related on INFOPARITY: Trust in AI Agent Networks Must Be Baked In, Not Bolted On — on finding simple underlying structures in complex systems.
• Classical Background: Sheffer, H. M. (1913). A set of five independent postulates for Boolean algebras. — The original discovery of the NAND universal gate.
• Numerical Methods: Press et al., Numerical Recipes — The practical engine that runs on elementary functions.