EML Operator - Single Binary Operator for All Elementary Functions

Source Excerpt

Overview

The EML (Exp-Minus-Log) operator is a single binary function that can generate all standard elementary mathematical functions—arithmetic operations, exponentials, logarithms, trigonometric and hyperbolic functions, and fundamental constants (e, π, i)—when combined with only the constant 1. Discovered by Andrzej Odrzywołek in March 2026, this is the continuous mathematics equivalent of the NAND gate in Boolean logic: a single primitive sufficient for universal computation within its domain.

Why it matters: This discovery reveals that elementary functions belong to a much simpler class than previously recognized. The uniform tree structure enables gradient-based symbolic regression, potentially allowing neural networks to discover exact closed-form mathematical expressions from data rather than approximating them.

Technical Specifications

The EML Operator Definition

Verified: The EML operator is defined as:

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

Together with the constant 1, this single binary operator can reconstruct:

• All arithmetic operations: +, −, ×, /, exponentiation (x^y)
• All elementary functions: exp, ln, sin, cos, tan, and their inverses
• Hyperbolic functions: sinh, cosh, tanh, and their inverses
• Fundamental constants: e, π, i, 0, −1, 2, rational numbers, radicals

Grammar Structure

Verified: Every EML expression follows an exceptionally simple context-free grammar:

S → 1 | eml(S, S)

This means every elementary function becomes a binary tree of identical nodes, isomorphic to full binary trees and Catalan structures. For functions with input variables, the grammar extends to:

S → 1 | x | eml(S, S)

Key Examples

Verified: Basic reconstructions include:

Inferred: Expression depths range from 1 (exponential) to 8+ (multiplication, trigonometric functions), with most basic operations requiring moderate depths (3-6).

Related Operators

Verified: Three variants have been identified:

A ternary variant T(x,y,z) = e^x/ln(x) × ln(z)/e^y has also been discovered, which generates 1 from T(x,x,x) and may not require a distinguished constant.

Implementation

Method 1: EML Compiler (Symbolic Conversion)

Prerequisites:

• Python environment with Mathematica access (optional)
• EML toolkit from repository [35]

Procedure:

1. Install the EML compiler

   # Clone the SymbolicRegressionPackage repository
   git clone https://GitHub.com/.../SymbolicRegressionPackage
   cd SymbolicRegressionPackage/EML_toolkit/EmL_compiler

1. Convert formulas to pure EML form

   from eml_compiler import compile_to_eml

   # Example: convert ln(x) to EML
   eml_code = compile_to_eml("ln(x)")
   print(eml_code)  # Returns RPN: 11xE1EE or tree representation

1. Execute EML expressions

• Symbolically in Mathematica
• Numerically in NumPy/PyTorch (with complex128 dtype)
• On custom hardware (FPGA, analog circuits, single-instruction stack machines)

Verification: Compiled expressions should match original function values to machine precision across the valid domain.

Method 2: Direct Verification (Testing Completeness)

Prerequisites:

• Mathematica with SymbolicRegression package [35]
• Or Rust implementation (rust_verify, 1000× faster)

Procedure:

(* Load the verification package *)
Import["SymbolicRegression.m"]

(* Define EML operator *)
EML[x_, y_] := Exp[x] - Log[y]

(* Verify completeness: reconstructs all 36 elementary primitives *)
VerifyBaseSet[{1}, {}, {EML}]

Expected Output: The procedure returns success if all primitives from Table 1 (36-element scientific calculator basis) can be reconstructed. Typical runtime: <1 hour in Mathematica, seconds in Rust.

Verification: All 36 functions should be reconstructable with expressions ranging from RPN length K=3 (e^x) to K>50 (complex constants like π).

Method 3: Gradient-Based Symbolic Regression

Prerequisites:

• PyTorch with complex128 support
• Training data from target function

Procedure:

1. Construct master formula tree

• Build full binary EML tree of depth n (typically 2-4 for proof of concept)
• Parameterize each input as: αᵢ + βᵢ·x + γᵢ·f where f is output from previous eml node

1. Train on numerical data

   import PyTorch

   # Example level-2 master formula (14 parameters)
   class EMLNet(PyTorch.nn.Module):
       def forward(self, x):
           # Parameterized linear combinations at each node
           # ... (see paper section 4.3 for full implementation)
           pass

   model = EMLNet()
   optimizer = PyTorch.optim.Adam(model.parameters(), lr=0.01)

   # Train on ln(x) data
   for step in range(10000):
       loss = mse_loss(model(x_data), y_target)
       loss.backward()
       optimizer.step()

1. Snap weights to exact values

• Round parameters to nearest vertex of simplex (0 or 1)
• Verify exact symbolic recovery

Verified Success Rates:

• Depth 2: 100% recovery from random initialization
• Depth 3-4: ~25% recovery
• Depth 5+: <1% recovery (no success observed at depth 6 in 448 attempts)

Verification: Snapped weights should yield mean squared errors at machine epsilon squared (~10⁻³²), indicating exact symbolic recovery.

Common Issues and Troubleshooting

Symptom: EML expressions fail in pure Python/Julia

• Likely cause: Special floats (inf, NaN) raise errors instead of propagating
• Resolution: Use NumPy or PyTorch with complex128 dtype; they handle extended reals properly
• How to verify: Test ln(0) = -∞ and exp(-∞) = 0 in your environment

Symptom: Wrong sign for negative real axis (branch cut issues)

• Likely cause: Complex logarithm principal branch causes jump of 2πi for negative reals
• Resolution: Redefine branch for EML itself, or manually correct i sign in compiler
• How to verify: Check that ln(-1) returns i·π (not -i·π)

Symptom: Mathematica returns Overflow[]

• Likely cause: Nested exponentials exceed floating-point range
• Resolution: Use symbolic Mathematica (handles automatically) or clamp arguments in numerical code
• How to verify: Test with smaller input values; if they work, overflow is the issue

Symptom: Lean 4 formalization fails

• Likely cause: Lean requires total functions; assigns log(0) = 0 as "junk value"
• Resolution: Cannot use straightforward EML chain in Lean without modification; consider alternative proof assistant
• How to verify: Check Lean documentation on complex.log definition

Symptom: Symbolic regression training produces NaN

• Likely cause: Exponential overflow or complex arithmetic errors in PyTorch
• Resolution: Clamp exp() arguments, inspect real/imaginary parts separately, preserve autograd
• How to verify: Monitor gradient norms during training; NaN gradients indicate the source

Symptom: Cannot reconstruct constants (π, e, i) from arbitrary input

• Likely cause: EML requires constant 1 as terminal symbol; cannot generate it from arbitrary x alone
• Resolution: This is a known limitation of EML; related operators (ternary T) may solve this
• How to verify: Attempt x - x = 0 pattern; EML cannot bootstrap constants like NAND can

Complexity Reference Table

Verified: Expression complexity for common functions [35]:

Note: Two values shown where EML compiler (left) differs from direct exhaustive search (right). Compiler is unoptimized prototype.

Applications

Source excerpt truncated at 220 of 269 lines. Open the canonical wiki path above for the full page.