exp(−x) and the Five-Operator Barrier

The negative exponential appears in almost every physics law. It is blocked for 1-node construction in EML and four related operators. DEML is the operator that breaks through.

Correction (2026-09-13): the table defined EMN as exp(x) − ln(−y). On this site EMN is ln(y) − exp(x), the negation of EML (the census, /theorems T24 and the glossary); exp(x) − ln(−y) is EMLn, operator F2 on /framework. Neither gives exp(−x) in one node, so the verdict stands, and the table now checks both. The post also said EML alone contains exp(−x) at depth 3. No EML tree of depth at most 3 over {1, x} comes within 0.33 of it. The check is printed below.

Why exp(−x) matters

exp(−x) is not an exotic function. It is the backbone of physics:

• Radioactive decay: N(t) = N₀ · exp(−λt)
• Boltzmann distribution: P ∝ exp(−E/kT)
• Damped oscillation: A(t) = A₀ · exp(−γt)
• Gaussian: exp(−x²/2σ²)
• Heat equation kernel: exp(−x²/4t)

Under the EML operator eml(x, y) = exp(x) − ln(y), constructing exp(−x) in a single node requires presenting −x as input. But −x is not available from the grammar starting at {1} without spending nodes to negate first.

The five-operator check

We checked the five operators in the EML family, plus EMLn, for 1-node exp(−x) construction:

DEML: the complementary operator

deml(x, y) = exp(−x) − ln(y). Setting y = 1:

One node. Every decay law in physics expressible in a single EML-family operation.

DEML and EML are complementary operators. EML handles the forward exponential; DEML handles the decay direction. Together they cover the full exponential family without requiring negation as a separate node.

Expressiveness vs. efficiency

DEML adds efficiency, not expressiveness. By the published universality result (T01) some finite EML tree equals exp(−x), but none is small: no EML tree of depth at most 3 over {1, x} comes within 0.33 of it on [0.5, 3], and no smaller tree is written down. DEML gives it in one node. This is the motivation for the BEST routing system — choosing the cheapest operator for each primitive, rather than forcing everything through EML.

Reproduce

Every 1-node tree over the leaves 1 and x for each operator in the table, and every EML tree of depth at most 3, compared with exp(−x) on 26 points of [0.5, 3]:

import itertools, numpy as np                         # pip install numpy
np.seterr(all='ignore')
x = np.linspace(0.5, 3.0, 26); target = np.exp(-x)
ops = {'EML  exp(x) - ln(y)': lambda a, b: np.exp(a) - np.log(b), 'EDL  exp(x) / ln(y)': lambda a, b: np.exp(a) / np.log(b),
       'EXL  exp(x) * ln(y)': lambda a, b: np.exp(a) * np.log(b), 'EAL  exp(x) + ln(y)': lambda a, b: np.exp(a) + np.log(b),
       'EMN  ln(y) - exp(x)': lambda a, b: np.log(b) - np.exp(a), 'EMLn exp(x) - ln(-y)': lambda a, b: np.exp(a) - np.log(-b),
       'DEML exp(-x) - ln(y)': lambda a, b: np.exp(-a) - np.log(b)}
leaves = {'1': np.ones_like(x), 'x': x}
for name, f in ops.items():                            # every 1-node tree over the leaves 1 and x
    errs = [np.max(np.abs(f(a, b) - target)) for a in leaves.values() for b in leaves.values()]
    errs = [e for e in errs if np.isfinite(e)]
    print(f'{name}: best 1-node max error', f'{min(errs):.3g}' if errs else 'undefined')
pool = dict(leaves); seen = {tuple(np.round(v, 9)) for v in pool.values()}
for depth in range(3):                                 # EML trees of depth <= 3 over {1, x}
    for (ta, a), (tb, b) in itertools.product(list(pool.items()), repeat=2):
        v = np.exp(a) - np.log(b); k = tuple(np.round(v, 9))
        if np.all(np.isfinite(v)) and k not in seen:
            seen.add(k); pool[f'eml({ta},{tb})'] = v
err, tree = min((float(np.max(np.abs(v - target))), t) for t, v in pool.items())
print(f'EML trees of depth <= 3: {len(pool)} distinct; best max error {err:.3g}, by {tree}')

Output:

EML  exp(x) - ln(y): best 1-node max error 2.67
EDL  exp(x) / ln(y): best 1-node max error undefined
EXL  exp(x) * ln(y): best 1-node max error 0.607
EAL  exp(x) + ln(y): best 1-node max error 2.67
EMN  ln(y) - exp(x): best 1-node max error 3.32
EMLn exp(x) - ln(-y): best 1-node max error undefined
DEML exp(-x) - ln(y): best 1-node max error 0
EML trees of depth <= 3: 936 distinct; best max error 0.339, by eml(x,eml(eml(x,1),eml(1,x)))

Cite this work

Monogate Research (2026). "exp(−x) and the Five-Operator Barrier." monogate research blog. https://monogate.org/blog/negative-exponent

License

CC BY 4.0 — free to share and adapt with attribution. · Code: pip install monogate · Paper: arXiv:2603.21852