Most symbolic systems rely on multiple primitives.
Addition, multiplication, exponentials, logarithms — each plays a different role in structuring expressions.
But what happens if you force everything through a single operator?
This idea becomes concrete with the EML operator:
eml(x, y) = exp(x) − ln(y)
In theory, this operator can express all elementary functions.
But theory doesn’t tell us what happens in practice.
The Experiment
I built a small Python framework to explore this idea.
Instead of chasing universality, the focus is on structure:
What changes when symbolic expressions are forced into a single nonlinear primitive?
The framework:
- rewrites SymPy expressions into EML trees
- evaluates them back into standard form
- measures structural complexity (depth, node count, nonlinear nodes)
- includes a simple symbolic regression experiment
What Actually Changes?
A few things become immediately obvious:
• expression trees become significantly deeper
• nonlinear structure increases due to repeated exp/log composition
• domain constraints (like log positivity) become unavoidable
So while the representation becomes more uniform, it introduces clear structural overhead.
The Key Insight
Same math. Different structure.
The interesting part isn’t whether one operator can represent everything.
It’s what that does to the structure of computation.
Code + Experiments
GitHub repo:
github.com/biswajyoti-nath/eml-framework
Includes:
- transformation system
- experiments
- figures
- paper
Closing Thought
This isn’t about replacing standard algebra.
It’s about understanding how representation shapes computation.
Curious how others think about this — especially what happens at larger tree depths.
Top comments (0)