eml-sr 0.2.2

Symbolic regression via the EML operator — find the math formula hidden in your data

VietNamese click here!

[!IMPORTANT] 🚀 Release v0.2.2 is out! This release introduces the SmartSearcher Output Transformation framework (Identity, Square, Log, Inverse) to resolve non-linear targets, adaptive beam width settings, and early-stop optimizations. Read our version updates for details:

• v0.2.2: Improvements | Issues & Solutions
• v0.2.1: Improvements | Issues & Solutions
• v0.2.0: Improvements | Issues & Solutions

eml_sr: Primitivizing Continuous Mathematics in Rust

System	Installation Command	Registry
Rust / Cargo	cargo add eml_sr	crates.io
Python / Pip	pip install eml_sr	pypi.org

Introduction

eml_sr is a high-performance Rust library built around one of the deepest structural discoveries in continuous mathematics: All elementary functions can be represented using the EML operator.

In the world of digital electronics, the NAND gate is the fundamental building block. Similarly, eml_sr provides the "EML operator" as a universal bridge for continuous mathematics. This library allows developers to represent complex formulas using either a uniform EML-only structure or a high-performance hybrid structure that combines EML with optimized standard operators.

Instead of relying solely on cumbersome Abstract Syntax Trees (AST), eml_sr gives you the power to streamline your mathematical architecture using EML as the unifying core.

Paradigm Shift with EML

eml_sr was not created to replace standard math libraries, but to provide a completely new approach to representing and discovering mathematical structures.

1. Data Structure Transformation: From Heterogeneous to Homogeneous

When building an Abstract Syntax Tree (AST) for a mathematical expression:

• Traditional Method (Heterogeneous AST): Uses many different node types (Add, Mul, Sin, Exp...).

  • Pros: Direct description and extremely fast computation on current hardware.
  • Challenges: When writing formula transformation algorithms (like auto-differentiation or expression simplification), developers must handle countless branch cases (switch-case) for each operator.

• The EML Approach (Homogeneous Binary Tree): Reduces the complexity of mathematical spaces by using EmlNode as a unifying structure.

  • Value Proposition: The diversity of mathematics is "compressed" into a streamlined graph structure. Whether using pure EML or optimized hybrids, your core code remains lean, predictable, and extremely safe.

2. Artificial Intelligence (Symbolic Regression): From Discrete Search to Continuous Optimization

In tasks where AI is required to automatically discover formulas from raw data:

• Traditional Method (Combinatorial Search): AI must choose and combine from a "dictionary" containing dozens of different base operators (Base Set) through genetic algorithms.

  • Characteristics: Effective for short expressions, but the search space explodes exponentially as complexity increases.

• The EML Approach (Continuous Optimization): Completely skips the function selection step. The AI is provided with a "Master Formula" – a massive EML tree containing all possibilities of elementary functions.

  • Value Proposition: EML turns the difficult "combinatorial search" problem into a smooth "Gradient Optimization" problem. By using standard optimizers (like Adam) on the tree branches and rounding weights (snapping), Neural Networks can automatically prune and reveal sharp, precise physical and mathematical laws, fundamentally solving the "black box" problem of AI.

3. The EML: Efficiency Meets Universality

To understand the unique value of eml_sr, think of the relationship between Standard Operators and the EML Operator:

• Standard Operators (Sin, Cos, Pi, E...) are like "Lego Bricks": They are pre-shaped components. If you want to build a standard house, using Lego is fast and efficient. These are our "High-Speed Shortcuts" for discovering known mathematical laws.
• The EML Operator is like "Clay": You can mold clay into any shape. While you can use clay to make a brick, its true power lies in creating complex, organic forms that no Lego brick could ever represent.

In eml_sr, we combine both. We provide standard constants and functions to ensure the engine is lightning-fast for common tasks. But we keep EML at the core to ensure the engine is never limited. When traditional mathematics encounters an unknown relationship, EML acts as the universal discovery engine to find laws that don't have a name yet.

[!NOTE] 💡 Note on Architecture & Trade-offs: The absolute uniformity of EML comes with trade-offs regarding expression tree depth and strict requirements for floating-point precision. To understand these issues better, please see my personal analysis and discussion in docs/WHATITHINK.txt.

Scientific Foundation and Authors

Andrzej Odrzywołek, a theoretical physicist at the Institute of Theoretical Physics at the Jagiellonian University (Krakow, Poland), is the author behind the groundbreaking discovery of the minimalism of continuous mathematics. Through personal research effort and a systematic exhaustive search method, he solved a problem that had no precedent: finding a single "atom" for all functions.

The core discovery of Andrzej Odrzywołek is the EML (Exp-Minus-Log) operator: eml(x, y) = e^(x) - ln(y) He has convincingly proven that this operator, when combined with only the constant 1, can reproduce the entire catalog of a standard scientific calculator. This includes:

• Basic arithmetic operations (+, -, x, /).
• All elementary functions (sin, cos, log, powers...).
• Fundamental constants of mathematics such as e, pi, and the imaginary unit i.

Andrzej Odrzywołek's vision does not stop at pure theory. He has established a rigorous verification process, using independent transcendental constants to prove that all mathematical expressions can be converted into a uniform binary tree structure of EML nodes. His work opens up massive potential applications in creating minimalist analog computing circuits and enhancing the explainability of artificial intelligence through symbolic regression.

Full reference documentation: All elementary functions from a single operator

Practical Applications of EML

The power of the EML operator lies not only in its theoretical elegance. Below are the areas where the eml_sr library can become the core engine for next-generation software systems.

1. Artificial Intelligence (Machine Learning & Symbolic Regression)

This is the largest and most practical application of EML in software today:

• Symbolic Regression: Instead of AI models searching over messy grammars containing many different operators, EML allows for the creation of a multi-parameter "master formula" using a binary tree structure. The entire search space is collapsed into weight optimization on a single uniform structure, instead of fumbling through billions of different structural combinations.

• Breaking the AI "Black Box": You can use standard optimization algorithms (like Adam) to train neural networks based on this EML tree. Upon successful training, the system can snap weights to exact values (0 or 1), helping the AI output a clear mathematical formula (closed-form expressions) instead of just predicted numbers. This is the key to turning AI from a "black box" into a tool that humans can read, understand, and trust.

2. Building Compilers and Virtual Machines

EML provides an ideal foundation for developers to build ultra-minimalist execution systems:

• EML Compiler: You can use the eml_sr library as a core engine to write compiler software capable of converting any mathematical formula (e.g., sin(x) + e^x) into pure EML form — a series of nested EML instructions containing only the constant 1.

• Single Instruction Stack Machine: This pure EML form can be executed on a simulated stack machine that has exactly one single instruction. Imagine an RPN (Reverse Polish Notation) calculator with exactly one button — that is the essence of an EML virtual machine. This extreme simplicity makes formal verification more feasible and easier than ever.

3. VLSI Design and Analog Computing

EML acts as a bridge between software engineers and hardware engineers:

• Because all elementary functions become uniform binary trees in EML notation, you can use the eml_sr library to write software that compiles formulas into circuit schematics.

• This is very useful in analog computing, where engineers can create multivariate function computing circuits by connecting a binary tree topology structure of identical EML elements. Instead of designing separate circuits for each operation (+, x, sin...), you can mass-produce a single type of EML component and connect them according to the tree diagram.

4. Data Structure Design and Parsing

EML brings radical simplicity to the processing of mathematical expressions in software:

• Instead of writing handling code for dozens of different operations (+, -, sin, cos...), your software only needs to handle one extremely simple context-free grammar: S -> 1|eml(S, S)

• This makes systems for storage, parsing, or formal processing of mathematical expressions incredibly efficient. Every expression — no matter how complex — can be reduced to a highly uniform structure, simplifying evaluation logic and reducing architectural overhead.

Quick Start

1. Installation

Python Users:

pip install eml_sr

Rust Users:

cargo add eml_sr

2. Basic Usage (Python)

Discover the hidden formula in your data using the Scikit-Learn compatible API:

from eml_sr import Searcher

# Your data
X = [[1.0], [2.0], [3.0]]
y = [2.5, 4.5, 6.5]  # f(x) = 2x + 0.5

# Search for the formula
searcher = Searcher()
result = searcher.fit(X, y)

print(f"Formula: {result.formula}")
# Output: Formula: (v_{0} * 2.0) + 0.5

3. Basic Usage (Rust)

use eml_sr::{Searcher, SearchConfig};

fn main() {
    let searcher = Searcher::new(SearchConfig::default());
    let xs = vec![1.0, 2.0, 3.0];
    let ys = vec![2.5, 4.5, 6.5];
    
    if let Ok(result) = searcher.find_function(&xs, &ys) {
        println!("Found formula: {}", result.formula);
    }
}

Project Status & Safety

For detailed information about current capabilities, supported platforms, and critical safety warnings regarding memory usage (OOM), please see docs/STATUS.md.

Development & Contributing

If you want to build from source, run benchmarks, or contribute to the core engine, please see docs/CONTRIBUTING.md.

---

Note: The eml_sr library is a production-ready implementation of the EML operator theory.