What Happens When You Force All Math Through One Operator?

Biswajyoti Nath — Sun, 03 May 2026 01:56:25 +0000

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.