What Happens When You Force All Math Through One Operator?

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.