[arXiv 2026] The "NAND Gate" of Continuous Math: All Elementary Functions from a Single Operator

TL;DR

In a groundbreaking result for mathematical logic and scientific computing, Andrzej Odrzywolek has demonstrated that a single binary operator—eml(x, y) = exp(x) - ln(y)—plus the constant 1, is sufficient to generate all elementary functions. This means your scientific calculator doesn't need 30+ buttons; it only needs two. Beyond the aesthetic symmetry, this work provides a uniform, differentiable framework for Symbolic Regression, allowing neural networks to "discover" exact laws of nature using gradient descent.

Background: The Search for a Continuous "Sheffer Stroke"

In digital electronics, the NAND gate is king. It is functionally complete, meaning any Boolean function can be built using only NAND gates. However, continuous mathematics has always seemed "messy" by comparison. We teach students a dizzying array of functions—$\sin ,\cos ,\log ,\exp ,\sqrt{x}$—each with its own rules.

While Euler's formula $e^{i\phi }=\cos \phi +i\sin \phi$ showed that trigonometry is linked to exponentials, a complete reduction to a single operator remained elusive. The author asks: Is this diversity intrinsic, or is there a hidden generative basis?

The Discovery: The EML Operator

The magic formula discovered through systematic search is the EML (Exp-Minus-Log) operator:

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

By nesting this operator, we can build the entire "phylogenetic tree" of mathematics. For example:

• The constant $e$: $eml(1,1)=\exp (1)-\ln (1)=e$
• The Natural Log $\ln (x)$: $eml(1,eml(eml(1,x),1))$
• Exponentiation $e^x$: $eml(x,1)$

Figure 1: The "Evolutionary" path from the EML operator (the LUCA - Last Universal Common Ancestor) to complex operations like trigonometry and roots.

Methodology: Brute Force meets Numeric Sieve

Finding such an operator is a needle-in-a-haystack problem. The author used Ablation Testing, starting with 36 primitives and systematically removing them to see if the remainder was still "complete."

To verify if a candidate EML expression equaled a target function (like $\sin x$), the author used a Numeric Bootstrapping approach. Instead of complex symbolic algebra, he plugged in "wild" transcendental constants (like the Euler-Mascheroni constant $\gamma$) and checked the numerical output. Under the Schanuel Conjecture, if the numbers match to high precision, the formulas are almost certainly identical.

From Math to Machine Learning: Symbolic Regression

The most exciting application of EML is in Symbolic Regression (SR). Traditional SR uses genetic algorithms or reinforcement learning to "guess" formulas, which is notoriously difficult to scale.

Because every EML expression is a uniform binary tree, we can treat the entire tree as a trainable neural circuit. By parameterizing the inputs to each EML node as a weighted sum of variables and constants, we can use Adam optimizer to minimize the error between the tree's output and raw data.

Figure 2: Examples of the structural simplicity of EML trees for identity, negation, and multiplication.

The "Snapping" Effect

As the network trains, the weights $(\alpha ,\beta ,\gamma )$ are pushed towards 0 or 1. If the underlying data follows an elementary law (like $y=\ln x$), the optimizer can "snap" the weights into the exact discrete structure of the EML formula. The author demonstrated that at shallow depths, this method recovers exact closed-form expressions with 100% reliability.

Critical Insight: Why Does This Work?

The success of EML relies on three pillars:

1. Inverse Pairing: It includes both $\exp$ and its inverse $\ln$.
2. Non-commutativity: Subtraction ensures that the order of operations matters, allowing for directed "circuitry."
3. Complex Domain: To compute real-valued trigonometric functions, EML must operate over the complex plane ($\mathbb{C}$), mirroring how quantum mechanics uses complex amplitudes to reach real probabilities.

Conclusion & Future Outlook

The EML operator reveals that elementary functions are members of a much simpler class than previously recognized. While the current "compiler" produces deep trees for complex functions (e.g., depth 17+ for multiplication), the existence proof is a "striking and conceptually deep structural fact."

Future Work: Can we find a version that doesn't require the constant 1? Or a set of operators that avoids the "explosive" growth of exponentials during training? The author hints at a ternary variant $T(x,y,z)$ that might further reduce the requirements.

Elementary math just got a whole lot simpler—and a whole lot more "computable."