All elementary functions from a single binary operator
The paper establishes that a single binary operator $\operatorname{eml}(x,y)=\exp(x)-\ln(y)$, together with the constant $1$, suffices to generate all elementary functions—trigonometric, exponential, logarithmic, and arithmetic operations. This provides a continuous analog to the Sheffer stroke in Boolean logic, enabling uniform binary-tree representations of mathematical expressions and opening avenues for gradient-based symbolic regression using identical computational nodes.
The core claim is constructively valid: the author demonstrates explicit EML expressions for all 36 primitives listed in Table 1, verified through symbolic simplification and numerical cross-checks across multiple implementations (C, NumPy, PyTorch, mpmath). The reduction sequence from 36 primitives to EML (Table 2) is logically sound, and the existence of alternative variants (EDL, swapped EML) supports the robustness of the approach. However, the practical significance is limited by the exponential blow-up in expression depth—computing $\pi$ requires depth 193 in the prototype compiler—and the necessity of complex arithmetic even for real-valued outputs.
The exhaustive search methodology and constructive proof are the paper's strongest elements. The iterative bootstrapping procedure—progressively moving verified primitives from the candidate list to the base set—provides a clear algorithmic pathway for verifying functional completeness. The symbolic regression experiments (Section 4.3) successfully demonstrate exact formula recovery from numerical data at shallow tree depths (up to depth 4) using standard Adam optimization, validating that EML trees can function as trainable circuits with discrete weight snapping to 0/1.
The primary limitation is the prohibitive complexity of EML expressions compared to standard forms. While theoretically universal, the compiled representations are exponentially larger than conventional formulas (e.g., multiplication requires depth 41 in the compiler versus a single operation). The claim of a "single" operator is slightly misleading: it requires pairing with a distinguished constant ($1$, $e$, or $-\infty$) and necessarily involves complex intermediate values to compute real functions like $\sin(x)$ via Euler's formula. The symbolic regression scalability is poor—success drops below 1% at depth 5—suggesting the approach faces significant barriers for discovering non-trivial formulas from data.
The evidence adequately supports the completeness claim through concrete derivation chains (Figure 1) and verified reconstructions of all Table 1 primitives. Comparisons to related work—Boolean Sheffer strokes, Wolfram's minimal axioms, and OISC architectures—are appropriate and well-cited. However, the paper understates the computational overhead relative to existing symbolic regression systems (AI Feynman, PySR) which operate directly on human-readable expression grammars. The comparison to NAND gates (Table 3) is conceptually apt but masks the fact that EML requires transcendental operations (exp, log) internally, whereas NAND operates on discrete bits without additional numerical infrastructure.
Reproducibility is excellent. The author provides complete source code in Mathematica and a Rust reimplementation (rust_verify) on GitHub, with an archival Zenodo snapshot (DOI: 10.5281/zenodo.19183008). The paper specifies hyperparameters for symbolic regression experiments (PyTorch complex128, Adam optimizer, simplex reparameterization) and provides supplementary materials with full derivation chains. Potential barriers to reproduction include numerical instability from nested exponentials (noted in Section 4.3) and the reliance on extended real arithmetic ($\ln 0 = -\infty$) which behaves differently across languages (e.g., Python raises errors where NumPy returns -inf).
A single two-input gate suffices for all of Boolean logic in digital hardware. No comparable primitive has been known for continuous mathematics: computing elementary functions such as sin, cos, sqrt, and log has always required multiple distinct operations. Here I show that a single binary operator, eml(x,y)=exp(x)-ln(y), together with the constant 1, generates the standard repertoire of a scientific calculator. This includes constants such as $e$, $\pi$, and $i$; arithmetic operations including $+$, $-$, $\times$, $/$, and exponentiation as well as the usual transcendental and algebraic functions. For example, $e^x=\operatorname{eml}(x,1)$, $\ln x=\operatorname{eml}(1,\operatorname{eml}(\operatorname{eml}(1,x),1))$, and likewise for all other operations. That such an operator exists was not anticipated; I found it by systematic exhaustive search and established constructively that it suffices for the concrete scientific-calculator basis. In EML (Exp-Minus-Log) form, every such expression becomes a binary tree of identical nodes, yielding a grammar as simple as $S \to 1 \mid \operatorname{eml}(S,S)$. This uniform structure also enables gradient-based symbolic regression: using EML trees as trainable circuits with standard optimizers (Adam), I demonstrate the feasibility of exact recovery of closed-form elementary functions from numerical data at shallow tree depths up to 4. The same architecture can fit arbitrary data, but when the generating law is elementary, it may recover the exact formula.
Pick a starting point or write your own. Challenges run in the background, so you can keep reading while the AI investigates.
No challenges yet. Disagree with the review? Ask the AI to revisit a specific claim.