@hviana/sema 0.1.5 → 0.1.6

package/dist/src/alu/src/kernel-numeric.js

@@ -31,408 +31,336 @@ import { linsolve } from "./kernel-arith.js";
  *  `maxIter` is reached.  Returns the last iterate — the refinement's fixed
  *  point.  This is the single irreducible operator of the numerical layer. */
 export function converge(step, x0, tol, maxIter) {
-  let x = x0;
-  for (let i = 0; i < maxIter; i++) {
-    const next = step(x);
-    const scale = Math.max(1, Math.abs(next), Math.abs(x));
-    if (Math.abs(next - x) <= tol * scale) {
-      return next;
+    let x = x0;
+    for (let i = 0; i < maxIter; i++) {
+        const next = step(x);
+        const scale = Math.max(1, Math.abs(next), Math.abs(x));
+        if (Math.abs(next - x) <= tol * scale)
+            return next;
+        x = next;
     }
-    x = next;
-  }
-  return x;
+    return x;
 }
 /** Numerical derivative f′(a) by a central difference refined as h → 0 — a
  *  `converge` instance over shrinking step sizes (Richardson-style halving). */
 export function diff(f, a, tol, maxIter) {
-  let h = Math.max(1e-2, Math.abs(a) * 1e-2) || 1e-2;
-  let prev = (f(a + h) - f(a - h)) / (2 * h);
-  for (let i = 0; i < maxIter; i++) {
-    h /= 2;
-    const cur = (f(a + h) - f(a - h)) / (2 * h);
-    const scale = Math.max(1, Math.abs(cur), Math.abs(prev));
-    if (Math.abs(cur - prev) <= tol * scale) {
-      return cur;
+    let h = Math.max(1e-2, Math.abs(a) * 1e-2) || 1e-2;
+    let prev = (f(a + h) - f(a - h)) / (2 * h);
+    for (let i = 0; i < maxIter; i++) {
+        h /= 2;
+        const cur = (f(a + h) - f(a - h)) / (2 * h);
+        const scale = Math.max(1, Math.abs(cur), Math.abs(prev));
+        if (Math.abs(cur - prev) <= tol * scale)
+            return cur;
+        prev = cur;
+        if (h < 1e-13)
+            break; // floor: finer steps amplify round-off
     }
-    prev = cur;
-    if (h < 1e-13) {
-      break; // floor: finer steps amplify round-off
-    }
-  }
-  return prev;
+    return prev;
 }
 /** A root of f near x0, by Newton's method: converge x − f(x)/f′(x), with f′
  *  from {@link diff}.  Falls back to a secant step if the derivative vanishes. */
 export function solve(f, x0, tol, maxIter) {
-  return converge(
-    (x) => {
-      const fx = f(x);
-      let d = diff(f, x, tol, maxIter);
-      if (Math.abs(d) < 1e-14) {
-        // Derivative ~0: nudge with a secant over a small offset.
-        const h = 1e-6 * (Math.abs(x) + 1);
-        d = (f(x + h) - fx) / h;
+    return converge((x) => {
+        const fx = f(x);
+        let d = diff(f, x, tol, maxIter);
         if (Math.abs(d) < 1e-14) {
-          return x;
+            // Derivative ~0: nudge with a secant over a small offset.
+            const h = 1e-6 * (Math.abs(x) + 1);
+            d = (f(x + h) - fx) / h;
+            if (Math.abs(d) < 1e-14)
+                return x;
         }
-      }
-      return x - fx / d;
-    },
-    x0,
-    tol,
-    maxIter,
-  );
+        return x - fx / d;
+    }, x0, tol, maxIter);
 }
 /** Definite integral of f over [a, b], by composite Simpson refined until the
  *  estimate stops moving — a `converge` over partition count. */
 export function integrate(f, a, b, tol, maxIter) {
-  const simpson = (n) => {
-    const h = (b - a) / n;
-    let s = f(a) + f(b);
-    for (let i = 1; i < n; i++) {
-      s += (i % 2 === 0 ? 2 : 4) * f(a + i * h);
-    }
-    return (s * h) / 3;
-  };
-  let n = 2;
-  let prev = simpson(n);
-  for (let i = 0; i < maxIter; i++) {
-    n *= 2;
-    const cur = simpson(n);
-    const scale = Math.max(1, Math.abs(cur), Math.abs(prev));
-    if (Math.abs(cur - prev) <= tol * scale) {
-      return cur;
+    const simpson = (n) => {
+        const h = (b - a) / n;
+        let s = f(a) + f(b);
+        for (let i = 1; i < n; i++)
+            s += (i % 2 === 0 ? 2 : 4) * f(a + i * h);
+        return (s * h) / 3;
+    };
+    let n = 2;
+    let prev = simpson(n);
+    for (let i = 0; i < maxIter; i++) {
+        n *= 2;
+        const cur = simpson(n);
+        const scale = Math.max(1, Math.abs(cur), Math.abs(prev));
+        if (Math.abs(cur - prev) <= tol * scale)
+            return cur;
+        prev = cur;
     }
-    prev = cur;
-  }
-  return prev;
+    return prev;
 }
 /** e^x by its Taylor series, summed until a term is below tolerance — a
  *  `converge` over partial sums.  (Range-reduction-free; adequate for the
  *  arguments a query produces, and exact in the limit.) */
 export function expSeries(x, tol, maxIter) {
-  let term = 1;
-  let sum = 1;
-  for (let n = 1; n < maxIter; n++) {
-    term *= x / n;
-    sum += term;
-    if (Math.abs(term) <= tol * Math.max(1, Math.abs(sum))) {
-      break;
+    let term = 1;
+    let sum = 1;
+    for (let n = 1; n < maxIter; n++) {
+        term *= x / n;
+        sum += term;
+        if (Math.abs(term) <= tol * Math.max(1, Math.abs(sum)))
+            break;
     }
-  }
-  return sum;
+    return sum;
 }
 /** ln(x), x > 0, as the root of e^t − x = 0 (Newton via {@link solve}, with a
  *  good initial guess from the host log to keep iteration counts low). */
 export function logNewton(x, tol, maxIter) {
-  if (x <= 0) {
-    return NaN;
-  }
-  return solve(
-    (t) => expSeries(t, tol, maxIter) - x,
-    Math.log(x),
-    tol,
-    maxIter,
-  );
+    if (x <= 0)
+        return NaN;
+    return solve((t) => expSeries(t, tol, maxIter) - x, Math.log(x), tol, maxIter);
 }
 /** sin / cos by their Taylor series (a `converge` over partial sums), with
  *  argument reduction into [−π, π] for accuracy. */
 export function sinSeries(x, tol, maxIter) {
-  const TWO_PI = 2 * Math.PI;
-  let a = x % TWO_PI;
-  if (a > Math.PI) {
-    a -= TWO_PI;
-  }
-  if (a < -Math.PI) {
-    a += TWO_PI;
-  }
-  let term = a;
-  let sum = a;
-  for (let n = 1; n < maxIter; n++) {
-    term *= (-a * a) / ((2 * n) * (2 * n + 1));
-    sum += term;
-    if (Math.abs(term) <= tol) {
-      break;
+    const TWO_PI = 2 * Math.PI;
+    let a = x % TWO_PI;
+    if (a > Math.PI)
+        a -= TWO_PI;
+    if (a < -Math.PI)
+        a += TWO_PI;
+    let term = a;
+    let sum = a;
+    for (let n = 1; n < maxIter; n++) {
+        term *= (-a * a) / ((2 * n) * (2 * n + 1));
+        sum += term;
+        if (Math.abs(term) <= tol)
+            break;
     }
-  }
-  return sum;
+    return sum;
 }
 export function cosSeries(x, tol, maxIter) {
-  const TWO_PI = 2 * Math.PI;
-  let a = x % TWO_PI;
-  if (a > Math.PI) {
-    a -= TWO_PI;
-  }
-  if (a < -Math.PI) {
-    a += TWO_PI;
-  }
-  let term = 1;
-  let sum = 1;
-  for (let n = 1; n < maxIter; n++) {
-    term *= (-a * a) / ((2 * n - 1) * (2 * n));
-    sum += term;
-    if (Math.abs(term) <= tol) {
-      break;
+    const TWO_PI = 2 * Math.PI;
+    let a = x % TWO_PI;
+    if (a > Math.PI)
+        a -= TWO_PI;
+    if (a < -Math.PI)
+        a += TWO_PI;
+    let term = 1;
+    let sum = 1;
+    for (let n = 1; n < maxIter; n++) {
+        term *= (-a * a) / ((2 * n - 1) * (2 * n));
+        sum += term;
+        if (Math.abs(term) <= tol)
+            break;
     }
-  }
-  return sum;
+    return sum;
 }
 /** √x as the positive root of t² − x = 0 (Newton via {@link solve}). */
 export function sqrtNewton(x, tol, maxIter) {
-  if (x < 0) {
-    return NaN;
-  }
-  if (x === 0) {
-    return 0;
-  }
-  return solve((t) => t * t - x, Math.max(x, 1), tol, maxIter);
+    if (x < 0)
+        return NaN;
+    if (x === 0)
+        return 0;
+    return solve((t) => t * t - x, Math.max(x, 1), tol, maxIter);
 }
 /** A local minimum of f near x0: a root of f′ = 0 (optimize = solve(diff f)). */
 export function optimize(f, x0, tol, maxIter) {
-  return solve((x) => diff(f, x, tol, maxIter), x0, tol, maxIter);
+    return solve((x) => diff(f, x, tol, maxIter), x0, tol, maxIter);
 }
 /** Integrate an ODE y′ = f(t, y) from (t0, y0) to t1 by classical RK4 stepping
  *  — explicit stepping is the layer's other use of refinement (here a fixed
  *  fine step; an implicit step would close with {@link solve}). */
 export function odeSolve(f, t0, y0, t1, steps = 1000) {
-  const h = (t1 - t0) / steps;
-  let t = t0;
-  let y = y0;
-  for (let i = 0; i < steps; i++) {
-    const k1 = f(t, y);
-    const k2 = f(t + h / 2, y + (h / 2) * k1);
-    const k3 = f(t + h / 2, y + (h / 2) * k2);
-    const k4 = f(t + h, y + h * k3);
-    y += (h / 6) * (k1 + 2 * k2 + 2 * k3 + k4);
-    t += h;
-  }
-  return y;
+    const h = (t1 - t0) / steps;
+    let t = t0;
+    let y = y0;
+    for (let i = 0; i < steps; i++) {
+        const k1 = f(t, y);
+        const k2 = f(t + h / 2, y + (h / 2) * k1);
+        const k3 = f(t + h / 2, y + (h / 2) * k2);
+        const k4 = f(t + h, y + h * k3);
+        y += (h / 6) * (k1 + 2 * k2 + 2 * k3 + k4);
+        t += h;
+    }
+    return y;
 }
 /** Least-squares polynomial regression of degree `deg` over (x, y) samples:
  *  build the normal equations and solve them with {@link linsolve} — regression
  *  reduces to structured arithmetic.  Returns coefficients constant-first. */
 export function regress(xs, ys, deg) {
-  const m = deg + 1;
-  // Vandermonde-style normal matrix AᵀA and vector Aᵀy.
-  const ata = Array.from({ length: m }, () => new Array(m).fill(0));
-  const aty = new Array(m).fill(0);
-  for (let s = 0; s < xs.length; s++) {
-    const pows = new Array(2 * deg + 1);
-    pows[0] = 1;
-    for (let p = 1; p <= 2 * deg; p++) {
-      pows[p] = pows[p - 1] * xs[s];
-    }
-    for (let i = 0; i < m; i++) {
-      for (let j = 0; j < m; j++) {
-        ata[i][j] += pows[i + j];
-      }
-      aty[i] += pows[i] * ys[s];
+    const m = deg + 1;
+    // Vandermonde-style normal matrix AᵀA and vector Aᵀy.
+    const ata = Array.from({ length: m }, () => new Array(m).fill(0));
+    const aty = new Array(m).fill(0);
+    for (let s = 0; s < xs.length; s++) {
+        const pows = new Array(2 * deg + 1);
+        pows[0] = 1;
+        for (let p = 1; p <= 2 * deg; p++)
+            pows[p] = pows[p - 1] * xs[s];
+        for (let i = 0; i < m; i++) {
+            for (let j = 0; j < m; j++)
+                ata[i][j] += pows[i + j];
+            aty[i] += pows[i] * ys[s];
+        }
     }
-  }
-  return linsolve(ata, aty);
+    return linsolve(ata, aty);
 }
 /** Linear interpolation of y at `xq` over sorted sample points (xs, ys). */
 export function interpolate(xs, ys, xq) {
-  if (xq <= xs[0]) {
-    return ys[0];
-  }
-  const n = xs.length;
-  if (xq >= xs[n - 1]) {
-    return ys[n - 1];
-  }
-  for (let i = 0; i < n - 1; i++) {
-    if (xq >= xs[i] && xq <= xs[i + 1]) {
-      const t = (xq - xs[i]) / (xs[i + 1] - xs[i]);
-      return ys[i] + t * (ys[i + 1] - ys[i]);
+    if (xq <= xs[0])
+        return ys[0];
+    const n = xs.length;
+    if (xq >= xs[n - 1])
+        return ys[n - 1];
+    for (let i = 0; i < n - 1; i++) {
+        if (xq >= xs[i] && xq <= xs[i + 1]) {
+            const t = (xq - xs[i]) / (xs[i + 1] - xs[i]);
+            return ys[i] + t * (ys[i + 1] - ys[i]);
+        }
     }
-  }
-  return ys[n - 1];
+    return ys[n - 1];
 }
 /** Dominant eigenpair of a (preferably symmetric) matrix by POWER ITERATION —
  *  the canonical "iteration = converge" of this layer.  Returns the eigenvalue
  *  (Rayleigh quotient) and its unit eigenvector. */
 export function powerEig(A, tol, maxIter) {
-  const n = A.length;
-  // Start from a normalised all-ones vector: deterministic (no PRNG), and
-  // generically NOT aligned with any single eigenvector of a diagonal/symmetric
-  // matrix, so iteration is not trapped on a non-dominant axis (a unit basis
-  // vector would be, e.g. e₀ is fixed under diag(9,16) and converges to the
-  // wrong eigenvalue).
-  let v = new Array(n).fill(1 / Math.sqrt(n));
-  let lambda = 0;
-  for (let it = 0; it < maxIter; it++) {
-    // w = A v
-    const w = A.map((row) => row.reduce((s, a, j) => s + a * v[j], 0));
-    const norm = Math.sqrt(w.reduce((s, x) => s + x * x, 0)) || 1;
-    const vn = w.map((x) => x / norm);
-    // Rayleigh quotient vᵀAv.
-    const Av = A.map((row) => row.reduce((s, a, j) => s + a * vn[j], 0));
-    const lam = vn.reduce((s, x, i) => s + x * Av[i], 0);
-    if (Math.abs(lam - lambda) <= tol * Math.max(1, Math.abs(lam))) {
-      return { value: lam, vector: vn };
+    const n = A.length;
+    // Start from a normalised all-ones vector: deterministic (no PRNG), and
+    // generically NOT aligned with any single eigenvector of a diagonal/symmetric
+    // matrix, so iteration is not trapped on a non-dominant axis (a unit basis
+    // vector would be, e.g. e₀ is fixed under diag(9,16) and converges to the
+    // wrong eigenvalue).
+    let v = new Array(n).fill(1 / Math.sqrt(n));
+    let lambda = 0;
+    for (let it = 0; it < maxIter; it++) {
+        // w = A v
+        const w = A.map((row) => row.reduce((s, a, j) => s + a * v[j], 0));
+        const norm = Math.sqrt(w.reduce((s, x) => s + x * x, 0)) || 1;
+        const vn = w.map((x) => x / norm);
+        // Rayleigh quotient vᵀAv.
+        const Av = A.map((row) => row.reduce((s, a, j) => s + a * vn[j], 0));
+        const lam = vn.reduce((s, x, i) => s + x * Av[i], 0);
+        if (Math.abs(lam - lambda) <= tol * Math.max(1, Math.abs(lam))) {
+            return { value: lam, vector: vn };
+        }
+        lambda = lam;
+        v = vn;
     }
-    lambda = lam;
-    v = vn;
-  }
-  return { value: lambda, vector: v };
+    return { value: lambda, vector: v };
 }
 /** Largest singular value of A: √(dominant eigenvalue of AᵀA) — power iteration
  *  again, the prototypical `converge`. */
 export function topSingular(A, tol, maxIter) {
-  const n = A[0].length;
-  // AᵀA (n×n).
-  const ata = Array.from({ length: n }, () => new Array(n).fill(0));
-  for (let i = 0; i < n; i++) {
-    for (let j = 0; j < n; j++) {
-      let s = 0;
-      for (let r = 0; r < A.length; r++) {
-        s += A[r][i] * A[r][j];
-      }
-      ata[i][j] = s;
+    const n = A[0].length;
+    // AᵀA (n×n).
+    const ata = Array.from({ length: n }, () => new Array(n).fill(0));
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+            let s = 0;
+            for (let r = 0; r < A.length; r++)
+                s += A[r][i] * A[r][j];
+            ata[i][j] = s;
+        }
     }
-  }
-  const { value } = powerEig(ata, tol, maxIter);
-  return Math.sqrt(Math.max(0, value));
+    const { value } = powerEig(ata, tol, maxIter);
+    return Math.sqrt(Math.max(0, value));
 }
 /** Register the scalar transcendentals as ops (they have surface forms).  The
  *  matrix routines stay exported functions — there is no infix surface for a
  *  matrix, and auto-firing them from query spans is neither wanted nor safe. */
 export function registerNumeric(r) {
-  const one = (name, forms, f) => {
-    r.derive(
-      name,
-      1,
-      forms,
-      (args, ctx) => real(f(asReal(args[0]), ctx.rt.tol, ctx.rt.maxIter)),
-    );
-  };
-  one("exp", ["exp", "e^"], expSeries);
-  // ── named constants ───────────────────────────────────────────────────────
-  // Nullary ops, so a constant is RESOLVED like any operation (registry forms),
-  // never special-cased by a parser: the expression grammar reads "an arity-0
-  // op" as "a constant" generically.
-  r.derive("pi", 0, ["pi", "π"], () => real(Math.PI));
-  r.derive("euler", 0, ["e"], () => real(Math.E));
-  one("log", ["log", "ln"], logNewton);
-  one("sin", ["sin"], sinSeries);
-  one("cos", ["cos"], cosSeries);
-  one("sqrt", ["sqrt", "√"], sqrtNewton);
-  // ── operations over an EXPRESSION (the recursive-call case) ───────────────
-  // A derivative, an integral, a limit, an optimisation — these act on a
-  // FUNCTION, given as a symbol (the expression's bytes) plus point/bounds.  The
-  // function is sampled by ctx.evalExpr, which evaluates the expression by a
-  // RECURSIVE application of the same ALU (see expr.ts).  Their surface `forms`
-  // are CONCEPT forms — words a query might literally carry ("derivative",
-  // "integral", "limit") — but the GENERIC, modality-agnostic recognition is by
-  // resonance over these same concepts (pipeline.ts's recogniseOp), so an operation
-  // the bytes do not spell at all is still recognised by meaning.  These ops
-  // decline (return their first operand unchanged is wrong; instead they throw,
-  // which the Alu facade maps to "rule does not fire") when no evaluator is
-  // wired or the expression is unparseable — synthesis stays evidence-based.
-  const exprOf = (v) => {
-    if (v.domain === "symbol") {
-      return v.bytes;
-    }
-    // A bare number is a constant expression — encode it back to bytes so the
-    // evaluator sees a literal.
-    throw new Error("expression operand expected");
-  };
-  const evalAt = (ctx, expr, vbl, at) => {
-    if (!ctx.evalExpr) {
-      throw new Error("no expression evaluator");
-    }
-    const y = ctx.evalExpr(expr, vbl, at);
-    if (y === null || !Number.isFinite(y)) {
-      throw new Error("expression failed");
-    }
-    return y;
-  };
-  // diff: derivative of f at a point.  args = [expr, at].
-  r.derive(
-    "diff",
-    2,
-    ["derivative", "differentiate", "d/dx", "diff"],
-    (args, ctx) => {
-      const expr = exprOf(args[0]);
-      const at = asReal(args[1]);
-      return real(
-        diff((x) => evalAt(ctx, expr, "", x), at, ctx.rt.tol, ctx.rt.maxIter),
-      );
-    },
-    { expression: true },
-  );
-  // integrate: definite integral of f over [a, b].  args = [expr, a, b].
-  r.derive("integrate", 3, ["integral", "integrate", "∫"], (args, ctx) => {
-    const expr = exprOf(args[0]);
-    const a = asReal(args[1]);
-    const b = asReal(args[2]);
-    return real(
-      integrate(
-        (x) => evalAt(ctx, expr, "", x),
-        a,
-        b,
-        ctx.rt.tol,
-        ctx.rt.maxIter,
-      ),
-    );
-  }, { expression: true });
-  // solve: a root of f near a guess.  args = [expr, guess].
-  r.derive("solve", 2, ["solve", "root", "zero"], (args, ctx) => {
-    const expr = exprOf(args[0]);
-    const guess = asReal(args[1]);
-    return real(
-      solve((x) => evalAt(ctx, expr, "", x), guess, ctx.rt.tol, ctx.rt.maxIter),
-    );
-  }, { expression: true });
-  // limit: the value f approaches as its variable → a, estimated by sampling
-  // ever closer from both sides and converging (a limit IS a converge instance).
-  r.derive("limit", 2, ["limit", "lim"], (args, ctx) => {
-    const expr = exprOf(args[0]);
-    const a = asReal(args[1]);
-    const sample = (h) => {
-      // average of the two one-sided samples, skirting the point itself
-      const left = evalAt(ctx, expr, "", a - h);
-      const right = evalAt(ctx, expr, "", a + h);
-      return (left + right) / 2;
+    const one = (name, forms, f) => {
+        r.derive(name, 1, forms, (args, ctx) => real(f(asReal(args[0]), ctx.rt.tol, ctx.rt.maxIter)));
     };
-    let h = 0.1;
-    let prev = sample(h);
-    for (let i = 0; i < ctx.rt.maxIter; i++) {
-      h /= 2;
-      const cur = sample(h);
-      const scale = Math.max(1, Math.abs(cur), Math.abs(prev));
-      if (Math.abs(cur - prev) <= ctx.rt.tol * scale) {
-        return real(cur);
-      }
-      prev = cur;
-      if (h < 1e-13) {
-        break;
-      }
-    }
-    return real(prev);
-  }, { expression: true });
-  // optimize: a local minimiser of f near a guess (= solve(diff f)).  args =
-  // [expr, guess].
-  r.derive(
-    "optimize",
-    2,
-    ["minimize", "minimise", "optimize", "argmin"],
-    (args, ctx) => {
-      const expr = exprOf(args[0]);
-      const guess = asReal(args[1]);
-      return real(
-        optimize(
-          (x) => evalAt(ctx, expr, "", x),
-          guess,
-          ctx.rt.tol,
-          ctx.rt.maxIter,
-        ),
-      );
-    },
-    { expression: true },
-  );
-  // converge and the matrix routines (regress, eig, svd, interpolate) take
-  // FUNCTION or ARRAY operands with no flat infix surface; they are offered
-  // through the pure exports above and used internally (e.g. sqrt = solve(t²−x),
-  // optimize = solve(diff f)).
+    one("exp", ["exp", "e^"], expSeries);
+    // ── named constants ───────────────────────────────────────────────────────
+    // Nullary ops, so a constant is RESOLVED like any operation (registry forms),
+    // never special-cased by a parser: the expression grammar reads "an arity-0
+    // op" as "a constant" generically.
+    r.derive("pi", 0, ["pi", "π"], () => real(Math.PI));
+    r.derive("euler", 0, ["e"], () => real(Math.E));
+    one("log", ["log", "ln"], logNewton);
+    one("sin", ["sin"], sinSeries);
+    one("cos", ["cos"], cosSeries);
+    one("sqrt", ["sqrt", "√"], sqrtNewton);
+    // ── operations over an EXPRESSION (the recursive-call case) ───────────────
+    // A derivative, an integral, a limit, an optimisation — these act on a
+    // FUNCTION, given as a symbol (the expression's bytes) plus point/bounds.  The
+    // function is sampled by ctx.evalExpr, which evaluates the expression by a
+    // RECURSIVE application of the same ALU (see expr.ts).  Their surface `forms`
+    // are CONCEPT forms — words a query might literally carry ("derivative",
+    // "integral", "limit") — but the GENERIC, modality-agnostic recognition is by
+    // resonance over these same concepts (pipeline.ts's recogniseOp), so an operation
+    // the bytes do not spell at all is still recognised by meaning.  These ops
+    // decline (return their first operand unchanged is wrong; instead they throw,
+    // which the Alu facade maps to "rule does not fire") when no evaluator is
+    // wired or the expression is unparseable — synthesis stays evidence-based.
+    const exprOf = (v) => {
+        if (v.domain === "symbol")
+            return v.bytes;
+        // A bare number is a constant expression — encode it back to bytes so the
+        // evaluator sees a literal.
+        throw new Error("expression operand expected");
+    };
+    const evalAt = (ctx, expr, vbl, at) => {
+        if (!ctx.evalExpr)
+            throw new Error("no expression evaluator");
+        const y = ctx.evalExpr(expr, vbl, at);
+        if (y === null || !Number.isFinite(y))
+            throw new Error("expression failed");
+        return y;
+    };
+    // diff: derivative of f at a point.  args = [expr, at].
+    r.derive("diff", 2, ["derivative", "differentiate", "d/dx", "diff"], (args, ctx) => {
+        const expr = exprOf(args[0]);
+        const at = asReal(args[1]);
+        return real(diff((x) => evalAt(ctx, expr, "", x), at, ctx.rt.tol, ctx.rt.maxIter));
+    }, { expression: true });
+    // integrate: definite integral of f over [a, b].  args = [expr, a, b].
+    r.derive("integrate", 3, ["integral", "integrate", "∫"], (args, ctx) => {
+        const expr = exprOf(args[0]);
+        const a = asReal(args[1]);
+        const b = asReal(args[2]);
+        return real(integrate((x) => evalAt(ctx, expr, "", x), a, b, ctx.rt.tol, ctx.rt.maxIter));
+    }, { expression: true });
+    // solve: a root of f near a guess.  args = [expr, guess].
+    r.derive("solve", 2, ["solve", "root", "zero"], (args, ctx) => {
+        const expr = exprOf(args[0]);
+        const guess = asReal(args[1]);
+        return real(solve((x) => evalAt(ctx, expr, "", x), guess, ctx.rt.tol, ctx.rt.maxIter));
+    }, { expression: true });
+    // limit: the value f approaches as its variable → a, estimated by sampling
+    // ever closer from both sides and converging (a limit IS a converge instance).
+    r.derive("limit", 2, ["limit", "lim"], (args, ctx) => {
+        const expr = exprOf(args[0]);
+        const a = asReal(args[1]);
+        const sample = (h) => {
+            // average of the two one-sided samples, skirting the point itself
+            const left = evalAt(ctx, expr, "", a - h);
+            const right = evalAt(ctx, expr, "", a + h);
+            return (left + right) / 2;
+        };
+        let h = 0.1;
+        let prev = sample(h);
+        for (let i = 0; i < ctx.rt.maxIter; i++) {
+            h /= 2;
+            const cur = sample(h);
+            const scale = Math.max(1, Math.abs(cur), Math.abs(prev));
+            if (Math.abs(cur - prev) <= ctx.rt.tol * scale)
+                return real(cur);
+            prev = cur;
+            if (h < 1e-13)
+                break;
+        }
+        return real(prev);
+    }, { expression: true });
+    // optimize: a local minimiser of f near a guess (= solve(diff f)).  args =
+    // [expr, guess].
+    r.derive("optimize", 2, ["minimize", "minimise", "optimize", "argmin"], (args, ctx) => {
+        const expr = exprOf(args[0]);
+        const guess = asReal(args[1]);
+        return real(optimize((x) => evalAt(ctx, expr, "", x), guess, ctx.rt.tol, ctx.rt.maxIter));
+    }, { expression: true });
+    // converge and the matrix routines (regress, eig, svd, interpolate) take
+    // FUNCTION or ARRAY operands with no flat infix surface; they are offered
+    // through the pure exports above and used internally (e.g. sqrt = solve(t²−x),
+    // optimize = solve(diff f)).
 }