Elementary Logic Units (ELUs)

• Elementary Logic Units (ELUs) are defined as building blocks that compute exp(x) – ln(y) with a constant 1, forming a complete basis for elementary functions.
• They employ a context-free grammar S → 1 | eml(S,S) that consolidates traditional operator sets into a single binary operation, akin to the NAND gate in Boolean logic.
• ELU trees function as differentiable circuits for symbolic regression, achieving exact symbolic recovery via gradient-based methods and systematic search.

Searching arXiv for the relevant papers and acronym usage. Searching arXiv for "Elementary Logic Units" and related ELU papers. Elementary Logic Units (ELUs) are the identical building blocks—the EML nodes—that populate uniform binary trees for representing elementary functions in the framework introduced in "All elementary functions from a single binary operator" (Odrzywołek, 23 Mar 2026). Each ELU computes the binary operation

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

and, together with the distinguished constant $1$, forms a complete basis for the standard "scientific calculator" repertoire of constants, arithmetic operations, transcendental functions, inverse functions, and algebraic functions (Odrzywołek, 23 Mar 2026). In this usage, an ELU is not a neural-network activation. The acronym conflicts with the established deep-learning meaning "Exponential Linear Unit," and the 2026 paper explicitly distinguishes its Elementary Logic Units from the ELU and CELU activations studied in deep learning (Clevert et al., 2015, Barron, 2017).

1. Core definition and formal grammar

The primitive underlying Elementary Logic Units is the EML operator

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

used with the constant $1$ so that the logarithmic term can be neutralized through $\ln(1)=0$ (Odrzywołek, 23 Mar 2026). In the paper’s terminology, each internal node of an expression tree is an ELU: a single binary gate that always computes $\exp(\text{left})-\ln(\text{right})$. Leaves are terminals, namely the constant $1$ and, when functions of inputs are expressed, variables (Odrzywołek, 23 Mar 2026).

This induces a context-free grammar of the form

$S \to 1 \mid \operatorname{eml}(S,S),$

with variables added as terminals for functional expressions (Odrzywołek, 23 Mar 2026). The significance of this grammar is structural rather than merely notational. Standard symbolic representations rely on heterogeneous operator sets such as $\{+, -, \times, /, \exp, \ln, \sin,\dots\}$, whereas the EML formalism collapses the internal vocabulary to one node type. The paper presents this as a continuous-mathematics analogue of the role played by NAND or NOR in Boolean logic: one sufficient operator, repeated composition, and a fixed terminal (Odrzywołek, 23 Mar 2026).

The claimed universality is constructive. The paper states that EML and $1$ generate the entire repertoire in its Table Calc-36 and gives explicit identities, a bootstrapped discovery chain, and a feasibility proof that every item in that list can be expressed in pure EML form (Odrzywołek, 23 Mar 2026). This places ELUs at the level of representational primitives rather than at the level of a particular algorithm for numerical approximation.

2. Expressive completeness and explicit constructions

The simplest constructions recover the elementary exponential and logarithm directly:

$1$0

and

$1$1

The first has minimal tree depth $1$2 and leaf count $1$3; the second has leaf count $1$4 (Odrzywołek, 23 Mar 2026). These two identities anchor the rest of the system, because higher operations are reduced to $1$5 and $1$6 and then compiled recursively into EML form.

Arithmetic operations are obtained through standard exp–log identities. The compiler uses

$1$7

after which every occurrence of $1$8 and $1$9 is replaced by its EML construction, and the remaining arithmetic is itself compiled into EML using search-derived trees (Odrzywołek, 23 Mar 2026). The paper reports minimal leaf counts from direct search of $\operatorname{eml}(x,y)=\exp(x)-\ln(y),$0 for $\operatorname{eml}(x,y)=\exp(x)-\ln(y),$1, $\operatorname{eml}(x,y)=\exp(x)-\ln(y),$2 for $\operatorname{eml}(x,y)=\exp(x)-\ln(y),$3, $\operatorname{eml}(x,y)=\exp(x)-\ln(y),$4 for $\operatorname{eml}(x,y)=\exp(x)-\ln(y),$5, $\operatorname{eml}(x,y)=\exp(x)-\ln(y),$6 for $\operatorname{eml}(x,y)=\exp(x)-\ln(y),$7, $\operatorname{eml}(x,y)=\exp(x)-\ln(y),$8 for $\operatorname{eml}(x,y)=\exp(x)-\ln(y),$9, and $1$0 for $1$1; multiplication has reported minimal tree depth $1$2 (Odrzywołek, 23 Mar 2026).

The framework extends beyond arithmetic. Square root is expressed as

$1$3

with $1$4 itself represented in EML form (Odrzywołek, 23 Mar 2026). Trigonometric functions are built through Euler’s formula,

$1$5

yielding constructions such as

$1$6

where $1$7, constants, and products such as $1$8 are also compiled into EML trees (Odrzywołek, 23 Mar 2026). The same strategy covers inverse trigonometric and hyperbolic functions through exp–log identities, including

$1$9

and the usual formulas for $\ln(1)=0$0, $\ln(1)=0$1, $\ln(1)=0$2, $\ln(1)=0$3, $\ln(1)=0$4, and $\ln(1)=0$5 (Odrzywołek, 23 Mar 2026).

Constants are also included. The first success in the paper’s constructive chain is

$\ln(1)=0$6

while $\ln(1)=0$7 and $\ln(1)=0$8 are obtained in pure EML form with substantially larger trees; the tables report that $\ln(1)=0$9 requires more than $\exp(\text{left})-\ln(\text{right})$0 leaves and $\exp(\text{left})-\ln(\text{right})$1 more than $\exp(\text{left})-\ln(\text{right})$2 leaves, with a compiler output of $\exp(\text{left})-\ln(\text{right})$3 leaves for $\exp(\text{left})-\ln(\text{right})$4 (Odrzywołek, 23 Mar 2026). This asymmetry between functional completeness and expression compactness is central to the framework: representability is guaranteed, but shortest representations can be large.

3. Discovery procedure and constructive proof strategy

The EML basis was obtained through a systematic search over reduced operator sets derived from a 36-button scientific calculator basis (Odrzywołek, 23 Mar 2026). According to the paper, the search proceeded by ablation through smaller bases—Calc 3, Calc 2, Calc 1, and Calc 0—until single-operator candidates were tested. The successful pattern paired inverse functions with a non-commutative asymmetric composition, and $\exp(\text{left})-\ln(\text{right})$5 with terminal $\exp(\text{left})-\ln(\text{right})$6 passed the VerifyBaseSet test (Odrzywołek, 23 Mar 2026).

The constructive proof strategy is operational rather than purely existential. A verified set $\exp(\text{left})-\ln(\text{right})$7 is grown from $\exp(\text{left})-\ln(\text{right})$8 by repeatedly finding EML expressions for items in a target list $\exp(\text{left})-\ln(\text{right})$9, moving each success into $1$0 until $1$1 is empty (Odrzywołek, 23 Mar 2026). The first discovered item is $1$2, followed by $1$3, arithmetic operations, and then more complex transcendental constructions. The compiler embodies this procedure: it reduces target expressions to $1$4 and $1$5, substitutes the EML forms of those operations, and then resolves internal arithmetic using search-derived minimal trees (Odrzywołek, 23 Mar 2026).

The paper also emphasizes that EML is not unique. It identifies close variants such as

$1$6

and

$1$7

as related single-operator bases (Odrzywołek, 23 Mar 2026). This does not weaken the role of ELUs in the paper; rather, it situates them within a broader question of minimal or near-minimal continuous primitives. A plausible implication is that the importance of ELUs lies less in uniqueness than in furnishing one explicit, verified, and compiler-compatible universal substrate.

4. ELU trees as differentiable circuits for symbolic regression

Beyond representational universality, the paper treats ELU trees as trainable circuits for symbolic regression (Odrzywołek, 23 Mar 2026). The objective is typically mean squared error, optimized with Adam or related gradient-based methods. Each ELU takes left and right inputs restricted to one of $1$8, and a convenient parameterization is

$1$9

with either simplex reparameterization or softmax over $S \to 1 \mid \operatorname{eml}(S,S),$0 to encourage one-hot selection; leaves use only $S \to 1 \mid \operatorname{eml}(S,S),$1 (Odrzywołek, 23 Mar 2026).

For depth-$S \to 1 \mid \operatorname{eml}(S,S),$2 trees, the paper gives the master formula

$S \to 1 \mid \operatorname{eml}(S,S),$3

and notes that specific parameter choices reproduce targets such as $S \to 1 \mid \operatorname{eml}(S,S),$4 or constants such as $S \to 1 \mid \operatorname{eml}(S,S),$5 (Odrzywołek, 23 Mar 2026). This makes the symbolic search space differentiable while preserving the uniform ELU architecture.

The reported recovery behavior is sharply depth-dependent. From random initialization, exact snapping to closed forms succeeds in $S \to 1 \mid \operatorname{eml}(S,S),$6 at depth $S \to 1 \mid \operatorname{eml}(S,S),$7, about $S \to 1 \mid \operatorname{eml}(S,S),$8 at depths $S \to 1 \mid \operatorname{eml}(S,S),$9–$\{+, -, \times, /, \exp, \ln, \sin,\dots\}$0, below $\{+, -, \times, /, \exp, \ln, \sin,\dots\}$1 at depth $\{+, -, \times, /, \exp, \ln, \sin,\dots\}$2, and was not observed at depth $\{+, -, \times, /, \exp, \ln, \sin,\dots\}$3 in $\{+, -, \times, /, \exp, \ln, \sin,\dots\}$4 runs (Odrzywołek, 23 Mar 2026). When initialization is placed near the true solution through small Gaussian perturbations, convergence to exact weights succeeds in $\{+, -, \times, /, \exp, \ln, \sin,\dots\}$5 up to depth $\{+, -, \times, /, \exp, \ln, \sin,\dots\}$6 (Odrzywołek, 23 Mar 2026). Upon snapping, achieved MSE is at machine precision squared, approximately $\{+, -, \times, /, \exp, \ln, \sin,\dots\}$7 (Odrzywołek, 23 Mar 2026).

These results do not imply that arbitrary symbolic regression becomes easy. The same section states that the architecture can fit arbitrary data, but exact formula recovery is especially relevant when the generating law is elementary (Odrzywołek, 23 Mar 2026). This suggests that ELU trees are best understood as a differentiable program space with exact symbolic endpoints, rather than as a general-purpose guarantee of tractable discovery at arbitrary depth.

5. Domains, branches, and computational behavior

Although many target functions are real-valued, the ELU formalism operates essentially in complex arithmetic when generating the full scientific-calculator set (Odrzywołek, 23 Mar 2026). Complex values are required for the construction of $\{+, -, \times, /, \exp, \ln, \sin,\dots\}$8, $\{+, -, \times, /, \exp, \ln, \sin,\dots\}$9, and trigonometric or hyperbolic functions via Euler’s formula. The paper therefore uses the principal branch of the complex logarithm and treats branch management as part of the correctness problem, not as an implementation detail to be ignored (Odrzywołek, 23 Mar 2026).

This is especially visible in the EML realization of the logarithm,

$1$0

which the paper identifies as equivalent to $1$1 (Odrzywołek, 23 Mar 2026). On the principal branch, crossing the negative real axis introduces a jump of $1$2 because of the $1$3 term. The paper notes that this can flip signs for identities such as $1$4, and reports two remedies in the compiler: rebranching EML to match the system’s principal $1$5, or applying a one-time sign correction for $1$6 (Odrzywołek, 23 Mar 2026).

The system also relies on extended-real conventions where needed. The paper explicitly uses IEEE-754 and symbolic-real conventions such as $1$7 and $1$8, reporting that these edge cases are handled cleanly in Mathematica and IEEE-754 environments, while pure Python or Julia may require explicit $1$9 handling (Odrzywołek, 23 Mar 2026). Correctness was checked through numeric bootstrapping on transcendental test points, symbolic verification in Mathematica, and numerical validation across C, NumPy, PyTorch, and mpmath (Odrzywołek, 23 Mar 2026).

From an implementation perspective, ELUs inherit the numerical trade-offs of $1$00 and $1$01. The paper cites overflow in $1$02, positivity or complex-domain requirements for $1$03, and the need for branch-consistent evaluation as primary stability issues (Odrzywołek, 23 Mar 2026). It mitigates these in symbolic-regression experiments with Complex128 tensors in PyTorch, clamping of exponential arguments, careful NaN handling without breaking autodiff, and a hardening phase that pushes logits toward $1$04 before snapping (Odrzywołek, 23 Mar 2026). The same section notes that modern autodiff frameworks such as PyTorch and JAX work directly because EML evaluates through standard exp/log primitives, with complex-valued autodiff required for trigonometric and hyperbolic derivations (Odrzywołek, 23 Mar 2026).

6. Terminological distinction from neural-network ELUs

The acronym ELU is historically associated with the Exponential Linear Unit activation function in deep learning, introduced as

$1$05

to speed up learning and improve generalization in deep neural networks (Clevert et al., 2015). A later reparameterization, CELU, was introduced as

$1$06

in order to make the activation $1$07 for all $1$08 (Barron, 2017). The 2026 EML paper states explicitly that its "Elementary Logic Unit" is not this activation function (Odrzywołek, 23 Mar 2026).

Term	Meaning	Source
ELU	Exponential Linear Unit activation	(Clevert et al., 2015)
CELU	Continuously differentiable ELU activation	(Barron, 2017)
ELU	Elementary Logic Unit, i.e. an EML node	(Odrzywołek, 23 Mar 2026)

The distinction is substantive. In deep learning, ELU and CELU are pointwise nonlinearities for neural networks, motivated by mean activations near zero, reduced bias shift, non-vanishing positive-side gradients, and smoothness or bounded derivatives (Clevert et al., 2015, Barron, 2017). In the 2026 work, an ELU is a universal computational gate for elementary mathematics, embedded in uniform binary trees and used for exact symbolic construction and differentiable symbolic regression (Odrzywołek, 23 Mar 2026). The overlap is therefore terminological rather than conceptual.

A common misconception is to treat the 2026 ELU as a continuation of the activation-function literature because both involve exponentials and logarithms. The papers indicate otherwise. The activation-function ELU concerns optimization dynamics in deep architectures, whereas the Elementary Logic Unit concerns functional completeness and symbolic representation (Clevert et al., 2015, Barron, 2017, Odrzywołek, 23 Mar 2026).

7. Open problems and prospective research directions

The paper identifies several unresolved questions around the ELU/EML framework (Odrzywołek, 23 Mar 2026). One is minimality and uniqueness: EML is sufficient, but related operators such as EDL and swapped-argument $1$09 also exist, raising the question of whether there are simpler operators with shorter trees on average or better numerical properties. Another is the role of the distinguished constant. The system currently depends on a fixed terminal such as $1$10, $1$11, or $1$12; the paper asks whether a single binary operator could generate constants from arbitrary inputs in a manner more analogous to NAND-generated Boolean constants (Odrzywołek, 23 Mar 2026).

The paper also poses a "unary Sheffer" question: whether a univariate activation, together with standard linear or matrix operations, could exactly evaluate all elementary functions (Odrzywołek, 23 Mar 2026). Further open directions include tight lower bounds for minimal-depth or minimal-leaf representations of specific constants and functions such as $1$13, $1$14, and $1$15; improved search strategies that combine numeric bootstrapping with stronger symbolic sieves and AI-guided search; and extensions beyond elementary functions, including ternary operators, special functions, and analog or FPGA realizations of ELU circuits (Odrzywołek, 23 Mar 2026).

On the applied side, the paper points to program synthesis, differentiable programming with exact symbolic recovery, and analog computing blocks for multivariate functions as possible destinations for the framework (Odrzywołek, 23 Mar 2026). This suggests that Elementary Logic Units occupy an unusual position between symbolic algebra, numerical analysis, and differentiable systems. Their central claim is not merely that one can encode familiar mathematics with a single gate, but that doing so yields a uniform substrate for compilation, verification, and trainable symbolic computation (Odrzywołek, 23 Mar 2026).