OxiEML

All elementary functions from a single binary operator.

A Pure Rust crate that implements the EML operator eml(x, y) = exp(x) - ln(y) and builds uniform binary trees expressing all elementary functions using only this operator and the constant 1.

Based on arXiv:2603.21852 — "All elementary functions from a single binary operator" by Andrzej Odrzywolek (Jagiellonian University, Institute of Theoretical Physics).

Key Capabilities

1. Uniform Tree Representation — Every elementary function (exp, ln, sin, cos, +, -, *, /, ^, sqrt, abs, ...) is expressed via the grammar S -> 1 | eml(S, S).

2. Symbolic Regression — Discover closed-form mathematical formulas from input/output data using gradient-based search over EML tree topologies.

3. Lowering & Code Generation — Convert discovered EML trees to standard operation trees for efficient evaluation, pretty-printing, and Rust code emission.

4. CLI Tool — Parse, evaluate, and generate EML expressions from the command line.

5. SMT Integration — Constraint solving via EML tree interval narrowing (feature-gated for oxiz integration).

CLI Tool

The oxieml CLI can evaluate EML expressions, generate EML from function names, and verify claims about mathematical constants.

# Evaluate an EML expression
oxieml "E(1, 1)"
#=> MATCH: e (Euler's number) = 2.718281828459045

# Generate EML from a function/constant name
oxieml -g pi
#=> E(1,E(E(1,E(E(1,E(E(1,E(1,E(1,1))),1)),E(E(1,1),1))),1))
#=> MATCH: Im ~ pi (diff = 0.00e0)

oxieml -g e
#=> E(1,1)

oxieml -g sin x0=0.5
#=> Result: 0.4794255386042034

# Evaluate with variables
oxieml "E(x0, 1)" x0=2.0
#=> Result: 7.38905609893065  (= exp(2))

# Read from file
oxieml --file expression.txt

# List all available functions and constants
oxieml -l

# Show help / version
oxieml --help
oxieml --version

If the input is not a valid EML expression, the CLI auto-detects function names:

oxieml pi          # same as: oxieml -g pi
oxieml sin         # generates sin(x0) template

Quick Start (Library)

use oxieml::{EmlTree, Canonical, EvalCtx};

// Build exp(x) = eml(x, 1)
let x = EmlTree::var(0);
let exp_x = Canonical::exp(&x);

// Evaluate at x = 1.0 -> e
let ctx = EvalCtx::new(&[1.0]);
let result = exp_x.eval_real(&ctx).unwrap();
assert!((result - std::f64::consts::E).abs() < 1e-10);

// Euler's number: eml(1, 1) = exp(1) - ln(1) = e
let e = Canonical::euler();
println!("{}", e); // "eml(1, 1)"

// Negation, addition, multiplication — all from eml and 1
let y = EmlTree::var(1);
let sum = Canonical::add(&x, &y);
let product = Canonical::mul(&x, &y);

// Lower to standard operations for efficient evaluation
let lowered = exp_x.lower();
println!("{}", lowered.to_pretty()); // "exp(x0)"
let fast_result = lowered.eval(&[1.0]);

// Generate Rust source code
let code = oxieml::compile::compile_to_rust(&exp_x, "my_exp");
println!("{code}");

Parser

Parse EML expressions from strings and convert back:

use oxieml::parser::{parse, to_compact_string};

// Parse E(x, y) notation
let tree = parse("E(E(1, 1), 1)").unwrap();
assert_eq!(tree.depth(), 2);

// Also accepts eml(x, y) notation
let tree = parse("eml(E(1, x0), 1)").unwrap();

// Convert back to compact string
let compact = to_compact_string(&tree);
assert_eq!(parse(&compact).unwrap(), tree); // roundtrip

Symbolic Regression

use oxieml::symreg::{SymRegConfig, SymRegEngine};

// Generate data from an unknown function
let inputs: Vec<Vec<f64>> = (0..50).map(|i| vec![i as f64 * 0.1]).collect();
let targets: Vec<f64> = inputs.iter().map(|x| x[0].exp()).collect();

let config = SymRegConfig {
    max_depth: 2,
    learning_rate: 1e-2,
    tolerance: 1e-8,
    ..Default::default()
};

let engine = SymRegEngine::new(config);
let formulas = engine.discover(&inputs, &targets, 1).unwrap();

println!("Best formula: {}", formulas[0].pretty);
println!("MSE: {:.2e}", formulas[0].mse);

SMT / Constraint Solving

With the smt feature, oxieml integrates OxiZ 0.2 as a backend for deciding EML constraints. The solver uses interval propagation (EML-aware forward/backward rules for exp/ln) followed by linear relaxation (secant + tangent bounds) for OxiZ's LRA theory.

use oxieml::{EmlTree, Canonical, EmlConstraint, EmlSmtSolver, SmtResult};

// Constraint: exp(x) > 0 — trivially true for all x
let x = EmlTree::var(0);
let one = EmlTree::one();
let exp_x = EmlTree::eml(&x, &one);
let c = EmlConstraint::GtZero(exp_x);

let solver = EmlSmtSolver::new(vec![(-10.0, 10.0)]);
match solver.check_sat(&c).unwrap() {
    SmtResult::Sat(sol) => println!("SAT: x = {}", sol.assignments[0]),
    SmtResult::Unsat => println!("UNSAT — impossible"),
    SmtResult::Unknown => println!("unknown"),
}

The EmlSmtSolver can prove UNSAT for cases the legacy EmlNraSolver (interval bisection) cannot — e.g., ln(x) > 0 with x ∈ [-2, -1] (ln undefined for non-positive reals). It falls back to bisection on OxiZ-tightened bounds to extract concrete SAT witnesses, since extracting real-valued models from OxiZ 0.2 is not yet ergonomic.

Enable with:

[dependencies]
oxieml = { version = "0.1", features = ["smt"] }

The IntervalDomain type is always available (no feature) for lightweight propagation use-cases.

Canonical Constructions (Complete Phylogenetic Tree)

All functions from the paper's phylogenetic tree (Figure 1) are implemented:

Table 1: Basic Operations

Table 2: Arithmetic

Table 3: Trigonometric

Table 4: Inverse Trigonometric

Table 5: Hyperbolic

Table 6: Inverse Hyperbolic

Table 7: Other Functions & Constants

Architecture

Discovery Phase              Execution Phase
─────────────────           ──────────────────
EML tree space     lower()  Standard ops
S -> 1 | eml(S,S) -------> Add/Sub/Mul/Exp/Ln...
     |                           |
     | Adam optimizer            | to_pretty()
     | (symreg)                  | compile_to_rust()
     |                           | eval()
  DiscoveredFormula         Fast evaluation

     parse()                to_compact_string()
"E(1,1)" -----> EmlTree ---------> "E(1,1)"
                   |
                   | -g pi / -g sin
                   |
              CLI evaluation & constant matching

Module Overview

Features

[features]
default = []
smt = ["dep:oxiz", "dep:num-rational"]   # OxiZ 0.2 backend + interval propagation
simd = ["dep:oxiblas-core"]    # SIMD batch evaluation (F64x2/F64x4 via oxiblas-core 0.2)
parallel = ["dep:rayon"]       # Rayon-based parallel discovery & batch eval

Combine simd,parallel for SIMD-per-worker batch evaluation.

Performance

Measured on Apple M1 (8-core, NEON 128-bit), M1 MacBook Air, 2026-04:

Speedup from parallel feature (RAYON_NUM_THREADS=1 → 8):

Speedup from simd feature (10K-point batch, LoweredOp IR):

Parallelism helps most for coarse-grained work (symreg topology optimization). SIMD gives ~2.8× on batch evaluation regardless of batch size. Combining both scales near-linearly on large batches (100K+ points).

Design Decisions

• Arc<EmlNode> — O(1) subtree sharing during symbolic regression
• Stack-machine evaluator — Post-order traversal avoids recursion overflow on deep trees (sin alone needs 543 nodes)
• Complex64 internally — Trig functions and π require ln(-1) = iπ; complex eval is an internal detail, API is real-valued
• Discovery vs execution separation — EML trees for search, lowered ops for speed
• Parser roundtrip — parse(to_compact_string(tree)) == tree
• Pure Rust, zero FFI — Deps: num-complex, rand; optional: rayon (parallel), oxiblas-core (simd), oxiz + num-rational (smt)

Test Coverage

173 tests covering:

• All canonical constructions (Tables 1-7)
• Evaluation: real, complex, batch, error cases
• Parser: roundtrip, E/eml notation, error handling
• Symbolic regression: exp, constant, linear discovery
• Lowering + simplification: pattern matching, constant folding
• SIMD/parallel equivalence (scalar vs SIMD vs rayon results match to 1e-12)
• Integration: EML <-> lower <-> compile consistency
• SMT/constraint solving: interval propagation, OxiZ backend SAT/UNSAT, witness verification

cargo nextest run --all-features    # 173 tests
cargo clippy --all-targets --all-features -- -D warnings   # zero warnings
cargo bench --features simd,parallel                       # criterion benchmarks

References

• Paper: Andrzej Odrzywolek, "All elementary functions from a single binary operator", arXiv:2603.21852 (v2: 2026-04-04), Jagiellonian University, Institute of Theoretical Physics

COOLJAPAN Ecosystem

OxiEML is part of the COOLJAPAN Pure Rust Ecosystem — one of the largest pure-Rust sovereignty stacks in existence, comprising 660 crates, ~26M SLoC, and 350,000+ passing tests across 50+ production-grade libraries. All projects enforce fail0 + Clippy0 with zero C/Fortran dependencies by default.

Core Projects

Full project list & latest releases → cooljapan.tech · GitHub

Sponsorship

OxiEML is developed and maintained by COOLJAPAN OU (Team Kitasan).

The COOLJAPAN Ecosystem represents one of the largest Pure Rust scientific computing efforts in existence — spanning 50+ projects, 650+ crates, and millions of lines of Rust code across scientific computing, machine learning, quantum computing, geospatial analysis, legal technology, multimedia processing, and more. Every line is written and maintained by a small dedicated team committed to a C/Fortran-free future for scientific software.

If you find OxiEML or any COOLJAPAN project useful, please consider sponsoring to support continued development.

https://github.com/sponsors/cool-japan

Your sponsorship helps us:

• Maintain and expand the COOLJAPAN ecosystem (50+ projects, 650+ crates)
• Keep the entire stack 100% Pure Rust — no C/Fortran/system library dependencies
• Develop production-grade alternatives to OpenCV, FFmpeg, SciPy, NumPy, scikit-learn, PyTorch, TensorFlow, GDAL, and more
• Provide long-term support, security updates, and documentation
• Fund research into novel Rust-native algorithms and optimizations

License

Apache-2.0

2026 COOLJAPAN OU (Team KitaSan)