---
title: Elementary Logic Units (ELUs)
url: https://www.emergentmind.com/topics/elementary-logic-units-elus
type: topic
---

# Elementary Logic Units (ELUs)

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" [2603.21852]. 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 [2603.21852]. 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 [1511.07289] [1704.07483].

## 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$ [2603.21852]. 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 [2603.21852].

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 [2603.21852]. 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 [2603.21852].

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 [2603.21852]. 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:
$$
e^x=\operatorname{eml}(x,1),
$$
and
$$
\ln x=\operatorname{eml}\!\big(1,\ \operatorname{eml}(\operatorname{eml}(1,x),1)\big).
$$
The first has minimal tree depth $1$ and leaf count $3$; the second has leaf count $7$ [2603.21852]. These two identities anchor the rest of the system, because higher operations are reduced to $\exp$ and $\ln$ and then compiled recursively into EML form.

Arithmetic operations are obtained through standard exp–log identities. The compiler uses
$$
x+y=\ln\!\big(e^x\cdot e^y\big),\qquad
xy=\exp\!\big(\ln x+\ln y\big),\qquad
\frac{x}{y}=\exp\!\big(\ln x-\ln y\big),\qquad
x^y=\exp\!\big(y\,\ln x\big),
$$
after which every occurrence of $\exp$ and $\ln$ is replaced by its EML construction, and the remaining arithmetic is itself compiled into EML using search-derived trees [2603.21852]. The paper reports minimal leaf counts from direct search of $19$ for $x+y$, $11$ for $x-y$, $17$ for $x\times y$, $17$ for $x/y$, $25$ for $x^y$, and $29$ for $\log_x y$; multiplication has reported minimal tree depth $8$ [2603.21852].

The framework extends beyond arithmetic. Square root is expressed as
$$
\sqrt{x}=x^{1/2}=\operatorname{eml}\!\big(\tfrac{1}{2}\,\ln x,\ 1\big),
$$
with $\tfrac12$ itself represented in EML form [2603.21852]. Trigonometric functions are built through Euler’s formula,
$$
e^{i\varphi}=\cos\varphi+i\sin\varphi,
$$
yielding constructions such as
$$
\sin x=\frac{e^{ix}-e^{-ix}}{2i},\qquad
\cos x=\frac{e^{ix}+e^{-ix}}{2},\qquad
\tan x=\frac{\sin x}{\cos x},
$$
where $i$, constants, and products such as $ix$ are also compiled into EML trees [2603.21852]. The same strategy covers inverse trigonometric and hyperbolic functions through exp–log identities, including
$$
\arctan x=\frac{i}{2}\,\ln\!\Big(\frac{1-ix}{1+ix}\Big),
\qquad
\arcsin x=-\,i\ln\!\big(ix+\sqrt{1-x^2}\big),
$$
and the usual formulas for $\sinh$, $\cosh$, $\tanh$, $\operatorname{arsinh}$, $\operatorname{arcosh}$, and $\operatorname{artanh}$ [2603.21852].

Constants are also included. The first success in the paper’s constructive chain is
$$
e=\operatorname{eml}(1,1),
$$
while $\pi$ and $i$ are obtained in pure EML form with substantially larger trees; the tables report that $i$ requires more than $55$ leaves and $\pi$ more than $53$ leaves, with a compiler output of $193$ leaves for $\pi$ [2603.21852]. 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 [2603.21852]. 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 $\operatorname{eml}(x,y)=\exp(x)-\ln(y)$ with terminal $1$ passed the VerifyBaseSet test [2603.21852].

The constructive proof strategy is operational rather than purely existential. A verified set $S$ is grown from $\{1,\operatorname{eml}\}$ by repeatedly finding EML expressions for items in a target list $C$, moving each success into $S$ until $C$ is empty [2603.21852]. The first discovered item is $e$, followed by $\ln$, arithmetic operations, and then more complex transcendental constructions. The compiler embodies this procedure: it reduces target expressions to $\exp$ and $\ln$, substitutes the EML forms of those operations, and then resolves internal arithmetic using search-derived minimal trees [2603.21852].

The paper also emphasizes that EML is not unique. It identifies close variants such as
$$
\operatorname{edl}(x,y)=\exp(x)/\ln(y)\quad\text{(with constant }e),
$$
and
$$
-\operatorname{eml}(y,x)=\ln(x)-\exp(y)\quad\text{(with constant }-\infty),
$$
as related single-operator bases [2603.21852]. 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 [2603.21852]. 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,\text{variable(s)},\text{previous node output}\}$, and a convenient parameterization is
$$
u_i(x,f)=\alpha_i+\beta_i x+\gamma_i f,
$$
with either simplex reparameterization or softmax over $\{\alpha_i,\beta_i,\gamma_i\}$ to encourage one-hot selection; leaves use only $\alpha,\beta$ [2603.21852].

For depth-$2$ trees, the paper gives the master formula
$$
F(x)=\operatorname{eml}\!\Big(
\alpha_1+\beta_1 x+\gamma_1\,\operatorname{eml}(\alpha_3+\beta_3 x,\ \alpha_4+\beta_4 x),\
\alpha_2+\beta_2 x+\gamma_2\,\operatorname{eml}(\alpha_5+\beta_5 x,\ \alpha_6+\beta_6 x)
\Big),
$$
and notes that specific parameter choices reproduce targets such as $e^x$ or constants such as $e$ [2603.21852]. 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 $100\%$ at depth $2$, about $25\%$ at depths $3$–$4$, below $1\%$ at depth $5$, and was not observed at depth $6$ in $448$ runs [2603.21852]. When initialization is placed near the true solution through small Gaussian perturbations, convergence to exact weights succeeds in $100\%$ up to depth $6$ [2603.21852]. Upon snapping, achieved MSE is at machine precision squared, approximately $10^{-32}$ [2603.21852].

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 [2603.21852]. 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 [2603.21852]. Complex values are required for the construction of $i$, $\pi$, 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 [2603.21852].

This is especially visible in the EML realization of the logarithm,
$$
\ln z=\operatorname{eml}\!\big(1,\ \operatorname{eml}(\operatorname{eml}(1,z),1)\big),
$$
which the paper identifies as equivalent to $e-\ln((e^e)/z)$ [2603.21852]. On the principal branch, crossing the negative real axis introduces a jump of $2\pi i$ because of the $1/z$ term. The paper notes that this can flip signs for identities such as $\ln(-1)=i\pi$, and reports two remedies in the compiler: rebranching EML to match the system’s principal $\ln$, or applying a one-time sign correction for $i$ [2603.21852].

The system also relies on extended-real conventions where needed. The paper explicitly uses IEEE-754 and symbolic-real conventions such as $\ln 0=-\infty$ and $e^{-\infty}=0$, reporting that these edge cases are handled cleanly in Mathematica and IEEE-754 environments, while pure Python or Julia may require explicit $\inf/\mathrm{NaN}$ handling [2603.21852]. Correctness was checked through numeric bootstrapping on transcendental test points, symbolic verification in Mathematica, and numerical validation across C, NumPy, PyTorch, and mpmath [2603.21852].

From an implementation perspective, ELUs inherit the numerical trade-offs of $\exp$ and $\ln$. The paper cites overflow in $\exp$, positivity or complex-domain requirements for $\ln$, and the need for branch-consistent evaluation as primary stability issues [2603.21852]. 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 $\{0,1\}$ before snapping [2603.21852]. 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 [2603.21852].

## 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
$$
f(x)=
\begin{cases}
x, & x>0\\
\alpha(e^x-1), & x\le 0
\end{cases}
$$
to speed up learning and improve generalization in deep neural networks [1511.07289]. A later reparameterization, CELU, was introduced as
$$
f_{\mathrm{CELU}}(x;\alpha)=
\begin{cases}
x, & x>0\\
\alpha\left(e^{x/\alpha}-1\right), & x\le 0
\end{cases}
$$
in order to make the activation $C^1$ for all $\alpha>0$ [1704.07483]. The 2026 EML paper states explicitly that its "Elementary Logic Unit" is not this activation function [2603.21852].

| Term | Meaning | Source |
|---|---|---|
| ELU | Exponential Linear Unit activation | [1511.07289] |
| CELU | Continuously differentiable ELU activation | [1704.07483] |
| ELU | Elementary Logic Unit, i.e. an EML node | [2603.21852] |

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 [1511.07289] [1704.07483]. 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 [2603.21852]. 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 [1511.07289] [1704.07483] [2603.21852].

## 7. Open problems and prospective research directions

The paper identifies several unresolved questions around the ELU/EML framework [2603.21852]. One is minimality and uniqueness: EML is sufficient, but related operators such as EDL and swapped-argument $-\mathrm{EML}$ 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$, $e$, or $-\infty$; the paper asks whether a single binary operator could generate constants from arbitrary inputs in a manner more analogous to NAND-generated Boolean constants [2603.21852].

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 [2603.21852]. Further open directions include tight lower bounds for minimal-depth or minimal-leaf representations of specific constants and functions such as $\pi$, $i$, and $\sqrt{2}$; 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 [2603.21852].

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 [2603.21852]. 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 [2603.21852].

Source: https://www.emergentmind.com/topics/elementary-logic-units-elus