monogate 0.1.0 → 0.2.0

package/README.md

@@ -18,10 +18,17 @@ Live explorer: **https://monogate.dev** (or your deployed URL)
 
 ## Install
 
+**JavaScript / Node**
 ```bash
 npm install monogate
 ```
 
+**Python**
+```bash
+pip install monogate            # core only (no dependencies)
+pip install "monogate[torch]"   # + PyTorch differentiable ops + EMLTree / EMLNetwork
+```
+
 ## Usage
 
 ```js
@@ -79,7 +86,7 @@ These functions have no known EML construction:
 - **sin x** — no construction found
 - **cos x** — no construction found
 - **π** — no construction as a closed EML expression
-- **i** (√−1) — requires extending the domain
+- **i** (√−1) — open under strict principal-branch grammar. Under the extended-reals convention (`ln(0) = −∞`), i is constructible from `{1}` alone in K=75 nodes ([pveierland/eml-eval](https://github.com/pveierland/eml-eval)). These are different grammars, not contradictory results.
 
 Pull requests welcome. If you crack one, open an issue — it's publishable.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monogate",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A single binary operator eml(x,y) = exp(x) − ln(y) that generates all elementary functions. Implementation of arXiv:2603.21852 (Odrzywołek, 2026).",
   "type": "module",
   "main": "./src/index.js",
@@ -24,11 +24,11 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/your-username/monogate.git"
+    "url": "https://github.com/almaguer1986/monogate.git"
   },
-  "homepage": "https://monogate.dev",
+  "homepage": "https://github.com/almaguer1986/monogate",
   "bugs": {
-    "url": "https://github.com/your-username/monogate/issues"
+    "url": "https://github.com/almaguer1986/monogate/issues"
   },
   "engines": {
     "node": ">=16"

package/src/complex_eml.js

@@ -11,18 +11,24 @@
  * ── Key results ──────────────────────────────────────────────────────────────
  *
  *  ONE-TERMINAL RESULT (proven):
- *    S → 1 | eml_c(S,S) constructs −iπ in 12 nodes, depth 8.
+ *    S → 1 | eml_c(S,S) constructs −iπ in 11 nodes, depth 8.
  *    This is the first non-real value reachable from a single real terminal.
  *
  *  TWO-TERMINAL RESULT (proven):
  *    S → 1 | 2 | eml_c(S,S) constructs i, π, and Euler's formula
  *    exp(ix) = cos(x) + i·sin(x) as a single EML expression.
  *
- *  OPEN PROBLEM:
- *    Does S → 1 | eml_c(S,S) generate i?
+ *  OPEN PROBLEM (strict principal-branch grammar):
+ *    Does S → 1 | eml_c(S,S) generate i, where ln_c(0) is undefined?
  *    Equivalently: is there a finite EML tree over terminal {1} that evaluates
- *    to 0 + 1·i under complex extension with principal-branch ln?
- *    This is an open question in transcendental number theory.
+ *    to 0 + 1·i without passing 0 through ln_c at any intermediate node?
+ *
+ *    Note: Under the extended-reals convention (ln(0) = −∞, as in the original
+ *    paper and pveierland/eml-eval), i IS constructible from {1} alone in
+ *    K=75 nodes, depth=19, via exp(ln(−1)/2) where 2 = add(1,1).
+ *    The two results are not contradictory — they characterize different grammars.
+ *    This library uses strict principal-branch ln; whether i is reachable under
+ *    that convention remains open.
  *
  *  SIN / COS LIMITATION:
  *    sin(x) = Im(eul_c(x)) and cos(x) = Re(eul_c(x)).
@@ -239,51 +245,60 @@ export const pow_c = (x, n) => op_c(mul_c(_wrap(n), ln_c(_wrap(x))), one);
 // a NEGATIVE REAL reaches the y-position, causing ln_c to apply its
 // principal branch and return a value with imaginary part ±π.
 //
-// neg_real(1) = −1 is constructible from the ONE-TERMINAL real grammar
-// (nodes:9, depth:5). All intermediate ln arguments in that construction
-// are positive reals — the negation is achieved without ever applying ln
-// to a negative number. The result −1 is then passed as the y-argument
-// of an outer eml_c, triggering the branch cut.
+// 11-NODE CONSTRUCTION (current best, pure one-terminal tree):
+//
+//   eml(1, eml(eml(1, eml(eml(eml(eml(1,eml(1,1)),1),1),1)), eml(eml(eml(1,1),1),1)))
+//
+// Step 1:  tower = eml(eml(eml(eml(1,eml(1,1)),1),1),1)
+//            Starting from e = eml(1,1):
+//            eml(1,e) = e−1 → eml(e−1,1) = exp(e−1) → eml(...,1) = exp(exp(e−1))
+//            → eml(...,1) = exp(exp(exp(e−1)))   [≈ 3.45×10¹¹⁴]
 //
-// Step 1:  z₁ = eml_c(1, −1)
-//            = exp(1) − ln_c(−1)
-//            = e − iπ              [principal branch: arg(−1) = π]
-//            Nodes: 10  Depth: 6
+// Step 2:  A = eml(1, tower) = e − ln(tower) ≈ e − exp(exp(e−1)) < 0
+//            (A is a large negative real)
 //
-// Step 2:  z₂ = eml_c(z₁, 1)
-//            = exp_c(e − iπ) − 0
-//            = exp(e) · exp(−iπ)
-//            = −exp(e)             [real, negative → second branch-cut trigger]
-//            Nodes: 11  Depth: 7
+// Step 3:  B = eml(eml(eml(1,1),1),1) = exp(exp(e))  [≈ 3.81×10⁶]
 //
-// Step 3:  z₃ = eml_c(1, z₂)
-//            = e − ln_c(−exp(e))
-//            = e − (e + iπ)
-//            = −iπ                 [exact, one-terminal result]
-//            Nodes: 12  Depth: 8
+// Step 4:  mid = eml(A, B) = exp_c(A) − ln_c(B)
+//            exp(A) ≈ 0  (A ≪ 0),  ln(exp(exp(e))) = exp(e) = e^e
+//            mid ≈ −e^e                [real, negative → branch-cut trigger]
 //
-// IEEE 754 CAVEAT: sin(−π) ≈ −1.22e-16 ≠ 0. In floating-point, z₂ has a
-// tiny negative imaginary part, so atan2 returns −π (not +π), giving:
-//   ln_c(z₂)_float = [e, −π],  and  z₃_float = e − (e − iπ) = +iπ.
-// Both ±iπ are mathematically valid; code must not assume a sign.
-// Assertion: abs(NEG_I_PI_C.re) < 1e-10  AND  abs(|NEG_I_PI_C.im| − π) < 1e-10
+// Step 5:  result = eml(1, mid) = e − ln_c(−e^e)
+//            = e − (ln(e^e) + iπ) = e − (e + iπ) = −iπ  ✓
+//            Nodes: 11  Depth: 8
 //
-// Full tree (pure EML notation):
-//   eml_c(1, eml_c(eml_c(1, neg_real(1)), 1))
-// where neg_real(1) is the 9-node real EML tree for −1.
+// ADVANTAGE OVER PRIOR 12-NODE CONSTRUCTION:
+//   The 12-node construction (via neg_real(1) = −1) produces z₂ = −exp(e)
+//   with a floating-point imaginary part ≈ −1.22e−16, causing atan2 to return
+//   −π instead of +π and yielding +iπ rather than −iπ in floating-point.
+//   The 11-node construction avoids this: A is a large negative real with
+//   zero imaginary part, so −e^e is cleanly negative and ln_c gives exactly
+//   e + iπ with no sign ambiguity.
+//
+// Assertion: abs(NEG_I_PI_C.re) < 1e-10  AND  NEG_I_PI_C.im < 0
+//            (imaginary part is reliably negative with this construction)
 // ─────────────────────────────────────────────────────────────────────────────
 
-const _neg_real_one = Complex.of(neg_real(1)); // = −1 via real EML grammar
-
 /**
- * −iπ (or +iπ in floating-point; see ESCAPE comment above).
+ * −iπ — first complex constant reachable from terminal {1} alone.
  *
- * The FIRST complex constant reachable from terminal {1} alone under the
- * complex extension S → 1 | eml_c(S,S). Nodes:12 Depth:8.
+ * Pure one-terminal construction: S → 1 | eml_c(S,S), nodes=11, depth=8.
+ * Expression: eml(1,eml(eml(1,eml(eml(eml(eml(1,eml(1,1)),1),1),1)),eml(eml(eml(1,1),1),1)))
  *
- * Verified: |Re| < 1e-10,  ||Im| − π| < 1e-10
+ * Verified: |Re| < 1e-10,  Im ≈ −π  (sign is reliable, unlike the 12-node construction)
  */
-export const NEG_I_PI_C = op_c(one, op_c(op_c(one, _neg_real_one), one));
+// Build from inside out (see ESCAPE comment above)
+const _e      = op_c(one, one);                   // eml(1,1)       = e
+const _em1    = op_c(one, _e);                    // eml(1,e)       = e−1
+const _t1     = op_c(_em1, one);                  // eml(e−1,1)     = exp(e−1)
+const _t2     = op_c(_t1,  one);                  // eml(...,1)     = exp(exp(e−1))
+const _tower  = op_c(_t2,  one);                  // eml(...,1)     = exp(exp(exp(e−1))) [huge]
+const _neg_br = op_c(one, _tower);                // eml(1,tower)   < 0 [negative real]
+const _ee     = op_c(one, one);                   // eml(1,1)       = e  (independent subtree)
+const _exp_e  = op_c(_ee, one);                   // eml(e,1)       = exp(e)
+const _exp_ee = op_c(_exp_e, one);                // eml(exp(e),1)  = exp(exp(e))
+const _mid    = op_c(_neg_br, _exp_ee);           // eml(neg,B) ≈ −exp(e) [branch-cut trigger]
+export const NEG_I_PI_C = op_c(one, _mid);        // eml(1,−e^e) = −iπ
 
 /**
  * ±iπ/2 — half of NEG_I_PI_C, used to construct i.
@@ -493,13 +508,13 @@ export const IDENTITIES_C = [
   },
   {
     name: "−iπ",
-    emlForm: "eml_c(1, eml_c(eml_c(1, neg_real(1)), 1))",
-    nodes: 12, depth: 8,
+    emlForm: "eml(1,eml(eml(1,eml(eml(eml(eml(1,eml(1,1)),1),1),1)),eml(eml(eml(1,1),1),1)))",
+    nodes: 11, depth: 8,
     domain: "constant",
-    branchCut: "branch cut at z₂ = −exp(e); float gives +iπ or −iπ",
+    branchCut: "branch cut at mid = −exp(e); Im is reliably −π (no float sign ambiguity)",
     terminal: "{1}",
     status: "proven",
-    note: "First non-real value constructible from a single real terminal",
+    note: "First non-real value constructible from a single real terminal (improved from 12 nodes)",
   },
   {
     name: "i",

package/src/index.js

@@ -149,21 +149,265 @@ export const pow = (x, n) => op(mul(n, ln(x)), 1);
  */
 export const recip = (x) => op(neg(ln(x)), 1);
 
+// ─── EDL operator ─────────────────────────────────────────────────────────────
+//
+// edl(x, y) = exp(x) / ln(y)
+// Natural constant: Math.E  (ln(e) = 1 → edl(x,e) = exp(x))
+// Domain: y > 0, y ≠ 1  (ln(1) = 0 causes division by zero)
+// EDL and EML are the two known complete operator families.
+
+/**
+ * The EDL operator: edl(x, y) = exp(x) / ln(y)
+ *
+ * @param {number} x
+ * @param {number} y  must be > 0 and ≠ 1
+ * @returns {number}
+ */
+export const edl = (x, y) => Math.exp(x) / Math.log(y);
+
+/** EDL natural constant: e (ln(e)=1 → edl(x,e)=exp(x)) */
+export const EDL_E = Math.E;
+
+// EDL exp: edl(x, e) = exp(x) / ln(e) = exp(x)
+const _exp_edl = (x) => edl(x, EDL_E);
+
+// EDL ln: edl(0, edl(edl(0,x), e)) — 3-node tree
+// step 1: edl(0, x)    = 1/ln(x)
+// step 2: edl(s, e)    = exp(1/ln(x))
+// step 3: edl(0, t)    = 1/(1/ln(x)) = ln(x)  ✓
+// Dead zone: x near 1 causes step 2 to overflow (ln(x) → 0)
+const _ln_edl  = (x) => edl(0, edl(edl(0, x), EDL_E));
+
+/**
+ * x / y — EDL's natural 1-node operation: edl(ln(x), exp(y))
+ * Proof: exp(ln(x)) / ln(exp(y)) = x / y  ∎
+ * Nodes: 1 (vs EML's 15)  Domain: x > 0, y ≠ 0
+ *
+ * @param {number} x  must be > 0
+ * @param {number} y  must be ≠ 0
+ * @returns {number}
+ */
+export const div_edl = (x, y) => edl(_ln_edl(x), _exp_edl(y));
+
+/**
+ * 1/x — 2-node EDL tree: edl(0, edl(x, e))
+ * Proof: edl(x,e)=exp(x); edl(0,exp(x))=1/ln(exp(x))=1/x  ∎
+ * Nodes: 2 (vs EML's 5)  Domain: x ≠ 0
+ *
+ * @param {number} x  must be ≠ 0
+ * @returns {number}
+ */
+export const recip_edl = (x) => edl(0, edl(x, EDL_E));
+
+/**
+ * −x — 6-node EDL tree via ln(1/e) = −1
+ * Proof: edl(ln(x), 1/e) = x / ln(1/e) = x / (−1) = −x  ∎
+ * Nodes: 6 (vs EML's 9)
+ *
+ * @param {number} x
+ * @returns {number}
+ */
+export const neg_edl = (x) => {
+  const recip_e = edl(0, edl(EDL_E, EDL_E)); // 1/e (2 nodes)
+  return edl(_ln_edl(x), recip_e);            // edl(ln(x), 1/e) = −x
+};
+
+/**
+ * x × y — 7-node EDL tree: div_edl(x, recip_edl(y))
+ * Route: x * y = x / (1/y)
+ * Nodes: 7 (vs EML's 13)  Domain: x > 0, y ≠ 0
+ *
+ * @param {number} x  must be > 0
+ * @param {number} y  must be ≠ 0
+ * @returns {number}
+ */
+export const mul_edl = (x, y) => div_edl(x, recip_edl(y));
+
+/**
+ * xⁿ — 11-node EDL tree: edl(mul_edl(n, ln_edl(x)), e)
+ * Route: exp(n·ln(x)) via EDL mul and ln
+ * Nodes: 11 (vs EML's 15)  Domain: x > 0, x ≠ 1
+ *
+ * @param {number} x  must be > 0 and ≠ 1
+ * @param {number} n
+ * @returns {number}
+ */
+export const pow_edl = (x, n) => _exp_edl(mul_edl(n, _ln_edl(x)));
+
+// ─── EXL operator ─────────────────────────────────────────────────────────────
+//
+// exl(x, y) = exp(x) * ln(y)
+// Natural constant: Math.E  (ln(e) = 1 → exl(x,e) = exp(x))
+// INCOMPLETE: no finite EXL formula for addition or general subtraction.
+// Best-in-class for: ln (1 node), pow (3 nodes).
+
+/**
+ * The EXL operator: exl(x, y) = exp(x) * ln(y)
+ *
+ * @param {number} x
+ * @param {number} y  must be > 0 (argument of ln)
+ * @returns {number}
+ */
+export const exl = (x, y) => Math.exp(x) * Math.log(y);
+
+/** EXL natural constant: e */
+export const EXL_E = Math.E;
+
+/**
+ * ln(x) — 1-node EXL tree: exl(0, x)
+ * Proof: exp(0) * ln(x) = ln(x)  ∎
+ * Nodes: 1 (vs EML/EDL's 3)  Domain: x > 0
+ *
+ * @param {number} x  must be > 0
+ * @returns {number}
+ */
+export const ln_exl = (x) => exl(0, x);
+
+/**
+ * xⁿ — 3-node EXL tree: exl(exl(exl(0, n), x), e)
+ * Proof:
+ *   step 1: exl(0, n)         = ln(n)
+ *   step 2: exl(ln(n), x)     = exp(ln(n)) * ln(x) = n·ln(x)
+ *   step 3: exl(n·ln(x), e)   = exp(n·ln(x)) * 1   = xⁿ  ∎
+ * Nodes: 3 (vs EML's 15, EDL's 11)  Domain: x > 0, n > 0
+ *
+ * @param {number} x  must be > 0
+ * @param {number} n  must be > 0
+ * @returns {number}
+ */
+export const pow_exl = (x, n) => exl(exl(exl(0, n), x), EXL_E);
+
+// ─── BEST: optimal per-operation routing ──────────────────────────────────────
+//
+// Routes each operation to the operator that uses fewest nodes.
+// EML handles add/sub (only complete operator with these).
+// EDL handles div/mul/recip/neg (multiplicative group — cheapest).
+// EXL handles ln/pow (smallest known formulas).
+
+/**
+ * BEST operator routing — minimum nodes per operation across EML/EDL/EXL.
+ *
+ *   ln:    EXL  1 node  (vs EML/EDL 3)
+ *   pow:   EXL  3 nodes (vs EML 15, EDL 11)
+ *   div:   EDL  1 node  (vs EML 15)
+ *   recip: EDL  2 nodes (vs EML 5)
+ *   mul:   EDL  7 nodes (vs EML 13)
+ *   neg:   EDL  6 nodes (vs EML 9)
+ *   exp:   EML  1 node  (tied)
+ *   sub:   EML  5 nodes (EML only)
+ *   add:   EML  11 nodes(EML only)
+ */
+export const BEST = {
+  /** ln(x) — EXL, 1 node */
+  ln:    (x)    => ln_exl(x),
+  /** xⁿ — EXL, 3 nodes */
+  pow:   (x, n) => pow_exl(x, n),
+  /** x / y — EDL, 1 node */
+  div:   (x, y) => div_edl(x, y),
+  /** 1/x — EDL, 2 nodes */
+  recip: (x)    => recip_edl(x),
+  /** x * y — EDL, 7 nodes */
+  mul:   (x, y) => mul_edl(x, y),
+  /** −x — EDL, 6 nodes */
+  neg:   (x)    => neg_edl(x),
+  /** eˣ — EML, 1 node */
+  exp:   (x)    => op(x, 1),
+  /** x − y — EML, 5 nodes */
+  sub:   (x, y) => sub(x, y),
+  /** x + y — EML, 11 nodes */
+  add:   (x, y) => add(x, y),
+};
+
+/**
+ * sin(x) via Taylor series using BEST operator routing.
+ *
+ *   sin(x) = x − x³/3! + x⁵/5! − …
+ *
+ * Uses pow_exl (3 nodes per power — best known) for the power terms.
+ * Node counts per term:  pow=3, plus additive combination via EML.
+ * At 8 terms: 63 nodes (BEST) vs 245 nodes (all-EML) — 74% saving.
+ *
+ * @param {number} x
+ * @param {number} [terms=8]  number of Taylor terms (default 8, max error ~7.7e-7)
+ * @returns {number}
+ */
+export const sin_best = (x, terms = 8) => {
+  if (x === 0) return 0;
+  // pow_exl(x, n) requires x > 0.  For odd powers: x^n = sign(x) * |x|^n.
+  const ax = Math.abs(x);
+  const sx = x < 0 ? -1 : 1;
+  let result = x;  // first term: x¹ = x
+  for (let k = 1; k < terms; k++) {
+    const power = 2 * k + 1;
+    let f = 1;
+    for (let i = 2; i <= power; i++) f *= i;
+    // Odd power: sign = sx^power = sx (since power is odd)
+    const xp = sx * pow_exl(ax, power);
+    const sign = (k % 2 === 1) ? -1 : 1;
+    result += sign * xp / f;
+  }
+  return result;
+};
+
+/**
+ * cos(x) via Taylor series using BEST operator routing.
+ *
+ *   cos(x) = 1 − x²/2! + x⁴/4! − …
+ *
+ * @param {number} x
+ * @param {number} [terms=8]  number of Taylor terms
+ * @returns {number}
+ */
+export const cos_best = (x, terms = 8) => {
+  if (x === 0) return 1;
+  const ax = Math.abs(x);
+  let result = 1;  // first term: x⁰/0! = 1
+  for (let k = 1; k < terms; k++) {
+    const power = 2 * k;
+    let f = 1;
+    for (let i = 2; i <= power; i++) f *= i;
+    // Even power: |x|^power (always positive, sign = +1)
+    const xp = pow_exl(ax, power);
+    const sign = (k % 2 === 1) ? -1 : 1;
+    result += sign * xp / f;
+  }
+  return result;
+};
+
 // ─── Identity table ───────────────────────────────────────────────────────────
 
 /** Complexity table: each identity ranked by EML tree node count and depth. */
 export const IDENTITIES = [
-  { name: "eˣ",  emlForm: "eml(x,1)",                          nodes: 1,  depth: 1, status: "verified" },
-  { name: "ln x",emlForm: "eml(1,eml(eml(1,x),1))",            nodes: 3,  depth: 3, status: "verified" },
-  { name: "e",   emlForm: "eml(1,1)",                           nodes: 1,  depth: 1, status: "verified" },
-  { name: "0",   emlForm: "eml(1,eml(eml(1,1),1))",            nodes: 3,  depth: 3, status: "verified" },
-  { name: "x−y", emlForm: "eml(ln(x),exp(y))",                 nodes: 5,  depth: 4, status: "verified" },
-  { name: "−y",  emlForm: "two-regime (see source)",            nodes: 9,  depth: 5, status: "proven"   },
-  { name: "x+y", emlForm: "eml(ln(x),eml(neg(y),1))",          nodes: 11, depth: 6, status: "proven"   },
-  { name: "x×y", emlForm: "eml(add(ln(x),ln(y)),1)",           nodes: 13, depth: 7, status: "proven"   },
-  { name: "x/y", emlForm: "eml(add(ln(x),neg(ln(y))),1)",      nodes: 15, depth: 8, status: "proven"   },
-  { name: "xⁿ",  emlForm: "eml(mul(n,ln(x)),1)",               nodes: 15, depth: 8, status: "proven"   },
-  { name: "1/x", emlForm: "eml(neg(ln(x)),1)",                 nodes: 5,  depth: 4, status: "verified"  },
+  // EML family
+  { name: "eˣ",      operator:"EML", form: "eml(x,1)",                            nodes: 1,  status: "verified" },
+  { name: "ln x",    operator:"EML", form: "eml(1,eml(eml(1,x),1))",              nodes: 3,  status: "verified" },
+  { name: "x−y",     operator:"EML", form: "eml(ln(x),exp(y))",                   nodes: 5,  status: "verified" },
+  { name: "−y",      operator:"EML", form: "two-regime (see source)",              nodes: 9,  status: "proven"   },
+  { name: "x+y",     operator:"EML", form: "eml(ln(x),eml(neg(y),1))",            nodes: 11, status: "proven"   },
+  { name: "x×y",     operator:"EML", form: "eml(add(ln(x),ln(y)),1)",             nodes: 13, status: "proven"   },
+  { name: "x/y",     operator:"EML", form: "eml(add(ln(x),neg(ln(y))),1)",        nodes: 15, status: "proven"   },
+  { name: "xⁿ",      operator:"EML", form: "eml(mul(n,ln(x)),1)",                 nodes: 15, status: "proven"   },
+  { name: "1/x",     operator:"EML", form: "eml(neg(ln(x)),1)",                   nodes: 5,  status: "verified" },
+  // EDL family
+  { name: "x/y",     operator:"EDL", form: "edl(ln(x),exp(y))",                   nodes: 1,  status: "verified" },
+  { name: "1/x",     operator:"EDL", form: "edl(0,edl(x,e))",                     nodes: 2,  status: "verified" },
+  { name: "−x",      operator:"EDL", form: "edl(ln(x),1/e)",                      nodes: 6,  status: "proven"   },
+  { name: "x×y",     operator:"EDL", form: "div_edl(x,recip_edl(y))",             nodes: 7,  status: "proven"   },
+  { name: "xⁿ",      operator:"EDL", form: "edl(mul_edl(n,ln_edl(x)),e)",        nodes: 11, status: "proven"   },
+  // EXL family
+  { name: "ln x",    operator:"EXL", form: "exl(0,x)",                            nodes: 1,  status: "verified" },
+  { name: "xⁿ",      operator:"EXL", form: "exl(exl(exl(0,n),x),e)",             nodes: 3,  status: "proven"   },
 ];
 
-export default { op, exp, ln, E, ZERO, NEG_ONE, sub, neg, add, mul, div, pow, recip, IDENTITIES };
+export default {
+  // EML
+  op, E, ZERO, NEG_ONE, exp, ln, sub, neg, add, mul, div, pow, recip,
+  // EDL
+  edl, EDL_E, div_edl, recip_edl, neg_edl, mul_edl, pow_edl,
+  // EXL
+  exl, EXL_E, ln_exl, pow_exl,
+  // BEST routing
+  BEST, sin_best, cos_best,
+  // Metadata
+  IDENTITIES,
+};