@hviana/sema 0.1.7 → 0.1.9

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

@@ -1,208 +0,0 @@
-// kernel-nd.ts — the n-dimensional (list-processing) layer.
-//
-// The scalar kernels compute on single quantities; this layer computes on the
-// recursive `nd` container (see value.ts) — an ordered, ragged, heterogeneous
-// list whose elements are themselves Values of any domain, nested arbitrarily.
-//
-// It stands on a tiny irreducible CORE of three STRUCTURAL primitives, exactly
-// as logic stands on `nand` and the limit layer on `converge`:
-//
-//   • nd      — PACK its operands into a list value.           (construct)
-//   • length  — the top-level element count, as an int.        (measure)
-//   • at       — project the i-th element (negative = from end). (project)
-//
-// These three are the ONLY ops that read an nd's `items` directly.  Everything
-// else is a derivation that composes them with the scalar kernels:
-//
-//   map(xs, f)        = nd( f(at xs 0), f(at xs 1), … )          over length xs
-//   filter(xs, p)     = nd( the at xs i for which p(at xs i) )
-//   reduce(xs, f[,z]) = f(… f(f(z, at xs 0), at xs 1) …)
-//   find(xs, p)       = the first at xs i with p(at xs i), else the empty nd
-//   …concat / reverse / flatten / zip / range / shape / rank likewise.
-//
-// THE FUNCTION ARGUMENT IS ANY EXISTING OPERATION.  A higher-order op does not
-// take a bespoke callback enum; it takes an operation-denoting VALUE and resolves
-// it through {@link OpContext.resolveOp} — the SAME machinery every operator goes
-// through (a literal surface form, else its resonant meaning).  So `reduce(xs, +)`
-// is a sum, `reduce(xs, *)` a product, `reduce(xs, max)` the maximum,
-// `filter(xs, >0?)`… every scalar op the kernel already has becomes a fold /
-// map / predicate.  That is why this layer adds almost no operations of its own:
-// the scalar kernel IS the vocabulary, lifted over lists.  (And because reduce's
-// `f(acc, elem)` re-enters `apply`, folding a list of LISTS broadcasts — a column
-// sum is just `reduce(rows, +)`.)
-//
-// STRUCTURAL means broadcast-exempt: a reduce must see the whole list, not be
-// lifted across the elements it folds (see operation.ts).  Every SCALAR op is
-// non-structural and so broadcasts over an nd automatically — the two halves of
-// "all operations support nd" meet exactly here.
-import { asBit, asInt, int, isNd, nd } from "./value.js";
-/** The element list of an nd, or throw — so a structural op called on a non-list
- *  declines (the Alu facade maps the throw to "this rule does not fire"). */
-function listOf(v) {
-    if (!isNd(v))
-        throw new Error("nd op: operand is not an n-dimensional value");
-    return v.items;
-}
-/** Resolve an operation-value to a canonical name of the wanted arity, or throw
- *  (decline) when it names no known operation — the higher-order ops' shared
- *  front door, so an unrecognised function argument never silently no-ops. */
-function resolveFn(ctx, op, arity) {
-    const name = ctx.resolveOp(op, arity);
-    if (name === null)
-        throw new Error("nd op: unrecognised operation argument");
-    return name;
-}
-/** Register the n-dimensional layer into `r`.  All ops are STRUCTURAL. */
-export function registerNd(r) {
-    // ── core primitives (the only ops that touch `items`) ────────────────────
-    // nd: PACK operands into a list.  Variadic, so `nd(a, b, c)` = [a, b, c] and
-    // `nd()` = the empty list.  An operand that is itself a list nests (a matrix
-    // is `nd(row0, row1, …)`), so rank grows by composition, never a new type.
-    r.prim("nd", "variadic", ["nd", "list", "vector", "tuple", "array"], (args) => nd(args.slice()), { structural: true });
-    // length: the top-level element count, as an exact int.
-    r.prim("length", 1, ["length", "size", "len"], (args) => int(BigInt(listOf(args[0]).length)), { structural: true });
-    // at: project the i-th element.  A negative index counts from the end
-    // (−1 = last), Python-style; out of range throws (the rule declines).
-    r.prim("at", 2, ["at", "nth", "elem", "index"], (args) => {
-        const xs = listOf(args[0]);
-        let i = Number(asInt(args[1]));
-        if (i < 0)
-            i += xs.length;
-        if (i < 0 || i >= xs.length)
-            throw new Error("at: index out of range");
-        return xs[i];
-    }, { structural: true });
-    // ── derived: construction ────────────────────────────────────────────────
-    // range(n) = [0, 1, …, n−1]; range(a, b) = [a, a+1, …, b−1].  The index
-    // generator map/reduce iterate over when there is no input list yet.
-    r.derive("range", "variadic", ["range", "iota", "upto"], (args) => {
-        const lo = args.length >= 2 ? asInt(args[0]) : 0n;
-        const hi = args.length >= 2 ? asInt(args[1]) : asInt(args[0]);
-        const out = [];
-        for (let k = lo; k < hi; k++)
-            out.push(int(k));
-        return nd(out);
-    }, { structural: true });
-    // ── derived: the higher-order trio (op argument = any existing operation) ──
-    // map(xs, f): apply the UNARY op f to each element.  Built on at/length/nd; f
-    // is resolved by meaning, so `map(xs, negate)`, `map(xs, sqrt)`, `map(xs,
-    // inverse)` all work, and (via broadcast) map over a list of lists is fine.
-    r.derive("map", 2, ["map", "each"], (args, ctx) => {
-        const xs = listOf(args[0]);
-        const f = resolveFn(ctx, args[1], 1);
-        return nd(xs.map((e) => ctx.apply(f, [e])));
-    }, { structural: true });
-    // filter(xs, p): keep the elements for which the UNARY predicate p is truthy
-    // (its result read as a bit).  `filter(xs, isprime)`, `filter(xs, >0)`, … —
-    // any op that returns a truth value is a predicate.
-    r.derive("filter", 2, ["filter", "where", "keep"], (args, ctx) => {
-        const xs = listOf(args[0]);
-        const p = resolveFn(ctx, args[1], 1);
-        return nd(xs.filter((e) => asBit(ctx.apply(p, [e])) === 1));
-    }, { structural: true });
-    // reduce(xs, f) / reduce(xs, f, z): left-fold the BINARY op f across the list,
-    // optionally from a seed z.  `reduce(xs, +)` sums, `reduce(xs, *)` multiplies,
-    // `reduce(xs, max)` is the maximum, `reduce(xs, or)` is "any", … — the scalar
-    // kernel's whole binary vocabulary becomes a fold.  With no seed an empty list
-    // declines (nothing to fold); with a seed it returns the seed.
-    r.derive("reduce", "variadic", ["reduce", "fold", "accumulate"], (args, ctx) => {
-        if (args.length < 2) {
-            throw new Error("reduce: needs a list and an operation");
-        }
-        const xs = listOf(args[0]);
-        const f = resolveFn(ctx, args[1], 2);
-        const hasSeed = args.length >= 3;
-        let acc;
-        let start;
-        if (hasSeed) {
-            acc = args[2];
-            start = 0;
-        }
-        else {
-            if (xs.length === 0)
-                throw new Error("reduce: empty list, no seed");
-            acc = xs[0];
-            start = 1;
-        }
-        for (let i = start; i < xs.length; i++)
-            acc = ctx.apply(f, [acc, xs[i]]);
-        return acc;
-    }, { structural: true });
-    // find(xs, p): the FIRST element satisfying the unary predicate p, or the
-    // empty nd when none does (a graph-evidenced "nothing matched", never a guess).
-    r.derive("find", 2, ["find", "first", "search"], (args, ctx) => {
-        const xs = listOf(args[0]);
-        const p = resolveFn(ctx, args[1], 1);
-        for (const e of xs)
-            if (asBit(ctx.apply(p, [e])) === 1)
-                return e;
-        return nd([]);
-    }, { structural: true });
-    // ── derived: shape-preserving plumbing ────────────────────────────────────
-    // concat(a, b, …): join lists end to end into one list.
-    r.derive("concat", "variadic", ["concat", "append", "join"], (args) => {
-        const out = [];
-        for (const a of args)
-            for (const e of listOf(a))
-                out.push(e);
-        return nd(out);
-    }, { structural: true });
-    // reverse(xs): the list back to front.
-    r.derive("reverse", 1, ["reverse", "flip"], (args) => nd(listOf(args[0]).slice().reverse()), { structural: true });
-    // flatten(xs): splice one level — each nd element is spliced in, each scalar
-    // kept.  flatten ∘ flatten goes deeper; one level is the primitive step.
-    r.derive("flatten", 1, ["flatten", "flat"], (args) => {
-        const out = [];
-        for (const e of listOf(args[0])) {
-            if (isNd(e)) {
-                for (const sub of e.items)
-                    out.push(sub);
-            }
-            else
-                out.push(e);
-        }
-        return nd(out);
-    }, { structural: true });
-    // zip(a, b, …): the lists braided into a list of tuples; length = the shortest
-    // input (a ragged braid stops at the short one, never inventing elements).
-    r.derive("zip", "variadic", ["zip", "braid"], (args) => {
-        const lists = args.map(listOf);
-        if (lists.length === 0)
-            return nd([]);
-        const m = Math.min(...lists.map((l) => l.length));
-        const out = [];
-        for (let i = 0; i < m; i++)
-            out.push(nd(lists.map((l) => l[i])));
-        return nd(out);
-    }, { structural: true });
-    // rank(v): the nesting DEPTH — 0 for a scalar, 1 + the deepest element's rank
-    // for a list (so a vector is 1, a matrix 2, ragged depth taken as the max).
-    r.derive("rank", 1, ["rank", "depth", "ndim"], (args) => {
-        const rank = (v) => {
-            if (!isNd(v))
-                return 0n;
-            let m = 0n;
-            for (const e of v.items) {
-                const rr = rank(e);
-                if (rr > m)
-                    m = rr;
-            }
-            return m + 1n;
-        };
-        return int(rank(args[0]));
-    }, { structural: true });
-    // shape(v): the size along each axis, following the FIRST element down — the
-    // regular-tensor shape (a ragged list is reported by its top length, the
-    // recursion only descending the head).  Returns a list of ints.
-    r.derive("shape", 1, ["shape", "dims"], (args) => {
-        const dims = [];
-        let cur = args[0];
-        while (isNd(cur)) {
-            dims.push(int(BigInt(cur.items.length)));
-            if (cur.items.length === 0)
-                break;
-            cur = cur.items[0];
-        }
-        return nd(dims);
-    }, { structural: true });
-}

package/dist/src/alu/src/kernel-numeric.d.ts

@@ -1,54 +0,0 @@
-import type { OperationRegistry } from "./operation.js";
-/** The convergence primitive: iterate `step` from `x0` until successive iterates
- *  agree within `tol` (absolute, or relative for large magnitudes), or until
- *  `maxIter` is reached.  Returns the last iterate — the refinement's fixed
- *  point.  This is the single irreducible operator of the numerical layer. */
-export declare function converge(step: (x: number) => number, x0: number, tol: number, maxIter: number): number;
-/** Numerical derivative f′(a) by a central difference refined as h → 0 — a
- *  `converge` instance over shrinking step sizes (Richardson-style halving). */
-export declare function diff(f: (x: number) => number, a: number, tol: number, maxIter: number): number;
-/** 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 declare function solve(f: (x: number) => number, x0: number, tol: number, maxIter: number): number;
-/** Definite integral of f over [a, b], by composite Simpson refined until the
- *  estimate stops moving — a `converge` over partition count. */
-export declare function integrate(f: (x: number) => number, a: number, b: number, tol: number, maxIter: number): number;
-/** 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 declare function expSeries(x: number, tol: number, maxIter: number): number;
-/** 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 declare function logNewton(x: number, tol: number, maxIter: number): number;
-/** sin / cos by their Taylor series (a `converge` over partial sums), with
- *  argument reduction into [−π, π] for accuracy. */
-export declare function sinSeries(x: number, tol: number, maxIter: number): number;
-export declare function cosSeries(x: number, tol: number, maxIter: number): number;
-/** √x as the positive root of t² − x = 0 (Newton via {@link solve}). */
-export declare function sqrtNewton(x: number, tol: number, maxIter: number): number;
-/** A local minimum of f near x0: a root of f′ = 0 (optimize = solve(diff f)). */
-export declare function optimize(f: (x: number) => number, x0: number, tol: number, maxIter: number): number;
-/** 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 declare function odeSolve(f: (t: number, y: number) => number, t0: number, y0: number, t1: number, steps?: number): number;
-/** 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 declare function regress(xs: number[], ys: number[], deg: number): number[] | null;
-/** Linear interpolation of y at `xq` over sorted sample points (xs, ys). */
-export declare function interpolate(xs: number[], ys: number[], xq: number): number;
-/** 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 declare function powerEig(A: number[][], tol: number, maxIter: number): {
-    value: number;
-    vector: number[];
-};
-/** Largest singular value of A: √(dominant eigenvalue of AᵀA) — power iteration
- *  again, the prototypical `converge`. */
-export declare function topSingular(A: number[][], tol: number, maxIter: number): number;
-/** 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 declare function registerNumeric(r: OperationRegistry): void;

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

@@ -1,366 +0,0 @@
-// kernel-numeric.ts — the limit layer.
-//
-// A classical ALU stops at logic + arithmetic: exact, finite computation.  The
-// ONE thing that makes this a numerical engine is a single new primitive —
-// `converge(step, tol)`: iterate a refinement until successive results agree
-// within ε.  Everything else here is a `converge` instance or a derivation over
-// it plus the arithmetic already built:
-//
-//   diff       = converge a shrinking central difference (Richardson-style)
-//   solve      = Newton: converge on x − f(x)/f′(x)   (f′ via diff)
-//   integrate  = converge an adaptive partition (Simpson, refine until stable)
-//   sqrt       = solve t² − x = 0
-//   exp/log/sin/cos = converge their series / a Newton inverse
-//   optimize   = solve(diff f = 0)
-//   ode_solve  = step + (implicit) solve
-//   regress    = linsolve on the normal equations
-//   eig/svd    = power iteration = converge
-//
-// Direct methods (Gaussian elimination in kernel-arith.linsolve) are NOT new
-// primitives — they are arithmetic plus the control flow layer 1 gave us.  Only
-// convergence-to-tolerance is irreducible here.
-//
-// Scalar transcendentals are registered as ops (they have surface forms a query
-// can name); the matrix routines (regress, eig, svd, interpolate) are exported
-// pure functions, composed from the same primitives and tested directly, never
-// auto-fired from an arbitrary query span.
-import { asReal, real } from "./value.js";
-import { linsolve } from "./kernel-arith.js";
-/** The convergence primitive: iterate `step` from `x0` until successive iterates
- *  agree within `tol` (absolute, or relative for large magnitudes), or until
- *  `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;
-        x = next;
-    }
-    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;
-        prev = cur;
-        if (h < 1e-13)
-            break; // floor: finer steps amplify round-off
-    }
-    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;
-            if (Math.abs(d) < 1e-14)
-                return x;
-        }
-        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;
-        prev = cur;
-    }
-    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;
-    }
-    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);
-}
-/** 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;
-    }
-    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;
-    }
-    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);
-}
-/** 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);
-}
-/** 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;
-}
-/** 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];
-        }
-    }
-    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]);
-        }
-    }
-    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 };
-        }
-        lambda = lam;
-        v = vn;
-    }
-    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 { 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;
-        };
-        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)).
-}