@hviana/sema 0.1.9 → 0.2.1

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

@@ -0,0 +1,264 @@
+// kernel-arith.ts — the field-and-order layer.
+//
+// Identities 0 and 1, then the six primitives the field stands on — add,
+// negate, multiply, reciprocal, sign (plus floor / mod for integer number
+// theory).  Everything else is a derivation:
+//
+//   subtract  = add ∘ negate
+//   divide    = multiply ∘ reciprocal
+//   every comparison = sign ∘ subtract        (−1 / 0 / +1 → a truth bit)
+//   abs(x)    = multiply(sign x, x)            (no branch needed)
+//   min / max = select on compare             (control flow from layer 1)
+//   power     = repeated multiply (integer) | exp(e·log b) (real, layer 3)
+//   gcd       = Euclid via mod
+//
+// The arithmetic primitives are POLYMORPHIC over the numeric domains: when every
+// operand is exact (bit/int) they run on bigint, so the result is exact past
+// 2^53 and AGREES with the nand bootstrap (kernel-bits.ts); the moment a real
+// operand appears the whole expression lifts to IEEE doubles, which is what the
+// limit layer needs.  This is the hybrid: the bit-vector derivation is the
+// proof, native bigint is the exact hot path, native doubles back the reals.
+//
+// Vector / matrix / polynomial routines (dot, matmul, polyEval, linsolve) take
+// JS arrays rather than the flat Value list an infix operator would, because a
+// matrix has no sensible two-operand surface form; they are exported as pure
+// functions, composed from the same scalar primitives, and tested directly.
+// `linsolve` is Gaussian elimination — structured arithmetic, not a new
+// primitive.
+import { asInt, asReal, bit, int, joinDomain, real, } from "./value.js";
+/** Reduce numeric operands in their join domain: exact bigint when all are
+ *  bit/int, native double once any is real.  `bigOp` and `realOp` are the same
+ *  fold expressed in each carrier. */
+function reduceNumeric(args, identityBig, bigOp, realOp) {
+    const d = joinDomain(args);
+    if (d === "real") {
+        let acc = Number(identityBig);
+        let first = true;
+        for (const a of args) {
+            const x = asReal(a);
+            acc = first ? x : realOp(acc, x);
+            first = false;
+        }
+        return real(acc);
+    }
+    let acc = identityBig;
+    let first = true;
+    for (const a of args) {
+        const n = asInt(a);
+        acc = first ? n : bigOp(acc, n);
+        first = false;
+    }
+    return int(acc);
+}
+// The infix binding tiers of arithmetic notation, loosest to tightest.  These
+// are declared ONCE, here, next to the ops they describe; the expression
+// grammar (expr.ts) reads them off the registry, so no parser hardcodes an
+// operator table.  Comparisons deliberately declare NO infix binding: a
+// statement like "2+2=4" is a learnt FACT (true/false lives in the corpus),
+// not a computation the ALU should evaluate over the learner's head.
+const ADDITIVE = { precedence: 1 };
+const MULTIPLICATIVE = { precedence: 2 };
+const EXPONENT = { precedence: 3, rightAssoc: true };
+/** Register the arithmetic layer into `r`. */
+export function registerArith(r) {
+    // ── identities ──────────────────────────────────────────────────────────
+    r.prim("zero", 0, ["0"], () => int(0n));
+    r.prim("one", 0, ["1"], () => int(1n));
+    // ── primitives ──────────────────────────────────────────────────────────
+    // add / multiply are variadic folds (so "sum"/"product" of many is one call);
+    // the infix path calls them with exactly two operands.
+    r.prim("add", "variadic", ["+", "plus", "sum", "add", "total"], (args) => reduceNumeric(args, 0n, (a, b) => a + b, (a, b) => a + b), { infix: ADDITIVE });
+    r.prim("multiply", "variadic", [
+        "*",
+        "×",
+        "·",
+        "times",
+        "multiply",
+        "product",
+    ], (args) => reduceNumeric(args, 1n, (a, b) => a * b, (a, b) => a * b), {
+        infix: MULTIPLICATIVE,
+    });
+    r.prim("negate", 1, ["-", "negate", "neg"], (args) => {
+        const v = args[0];
+        return v.domain === "real" ? real(-v.x) : int(-asInt(v));
+    });
+    // reciprocal lives in the reals: 1/2 = 0.5, so it lifts to a double (an int
+    // result like 1/1 still formats cleanly through the codec).
+    r.prim("reciprocal", 1, ["reciprocal", "recip"], (args) => real(1 / asReal(args[0])));
+    // sign ∈ {−1, 0, +1}, returned exact (int) so comparisons are exact.
+    r.prim("sign", 1, ["sign", "sgn"], (args) => {
+        const v = args[0];
+        if (v.domain === "real")
+            return int(v.x > 0 ? 1n : v.x < 0 ? -1n : 0n);
+        const n = asInt(v);
+        return int(n > 0n ? 1n : n < 0n ? -1n : 0n);
+    });
+    // floor / mod — the optional integer-number-theory primitives.
+    r.prim("floor", 1, ["floor"], (args) => {
+        const v = args[0];
+        return v.domain === "real" ? int(BigInt(Math.floor(v.x))) : int(asInt(v));
+    });
+    // ── derived: the field ─────────────────────────────────────────────────
+    r.derive("subtract", 2, ["-", "minus", "subtract", "difference", "less"], (args, ctx) => ctx.apply("add", [args[0], ctx.apply("negate", [args[1]])]), { infix: ADDITIVE });
+    r.derive("divide", 2, ["/", "÷", "divide", "over"], (args, ctx) => ctx.apply("multiply", [args[0], ctx.apply("reciprocal", [args[1]])]), { infix: MULTIPLICATIVE });
+    // Euclidean-style remainder.  Exact for ints; native % for reals.
+    r.derive("mod", 2, ["mod", "%", "modulo"], (args, ctx) => {
+        void ctx;
+        const d = joinDomain(args);
+        if (d === "real")
+            return real(asReal(args[0]) % asReal(args[1]));
+        return int(asInt(args[0]) % asInt(args[1]));
+    }, { infix: MULTIPLICATIVE });
+    // ── derived: order (every comparison = sign ∘ subtract → a truth bit) ────
+    const cmpSign = (args, ctx) => asInt(ctx.apply("sign", [ctx.apply("subtract", [args[0], args[1]])]));
+    r.derive("eq", 2, ["=", "==", "equals", "eq"], (args, ctx) => bit(cmpSign(args, ctx) === 0n ? 1 : 0));
+    r.derive("ne", 2, ["!=", "≠", "ne"], (args, ctx) => bit(cmpSign(args, ctx) !== 0n ? 1 : 0));
+    r.derive("lt", 2, ["<", "lt"], (args, ctx) => bit(cmpSign(args, ctx) < 0n ? 1 : 0));
+    r.derive("le", 2, ["<=", "≤", "le"], (args, ctx) => bit(cmpSign(args, ctx) <= 0n ? 1 : 0));
+    r.derive("gt", 2, [">", "gt"], (args, ctx) => bit(cmpSign(args, ctx) > 0n ? 1 : 0));
+    r.derive("ge", 2, [">=", "≥", "ge"], (args, ctx) => bit(cmpSign(args, ctx) >= 0n ? 1 : 0));
+    // ── derived: magnitude / extremes ────────────────────────────────────────
+    // abs(x) = sign(x)·x — branch-free.
+    r.derive("abs", 1, ["abs", "|x|"], (args, ctx) => ctx.apply("multiply", [ctx.apply("sign", [args[0]]), args[0]]));
+    // min / max select on the comparison — the control flow layer 1 provides.
+    r.derive("min", 2, ["min"], (args, ctx) => cmpSign(args, ctx) <= 0n ? args[0] : args[1]);
+    r.derive("max", 2, ["max"], (args, ctx) => cmpSign(args, ctx) >= 0n ? args[0] : args[1]);
+    // ── derived: power ───────────────────────────────────────────────────────
+    // Integer exponent → repeated multiply (exact); non-integer or real → fall to
+    // the limit layer's exp(e·log b) when it is registered.
+    r.derive("power", 2, ["^", "**", "pow", "power"], (args, ctx) => {
+        const base = args[0];
+        const e = args[1];
+        // An INTEGER-VALUED exponent → repeated multiply (exact), even if it arrived
+        // as a real that happens to be whole (a derived call may hand a real 2.0).
+        // This keeps b^2 exact and avoids exp(e·ln b), which is approximate and
+        // undefined for a negative base (ln(−3) = NaN).  Only a genuinely fractional
+        // exponent falls to the limit layer.
+        const eInt = e.domain !== "real"
+            ? asInt(e)
+            : Number.isInteger(e.x)
+                ? BigInt(e.x)
+                : null;
+        if (eInt !== null) {
+            let n = eInt;
+            const neg = n < 0n;
+            if (neg)
+                n = -n;
+            let acc = int(1n);
+            for (let i = 0n; i < n; i++)
+                acc = ctx.apply("multiply", [acc, base]);
+            return neg ? ctx.apply("reciprocal", [acc]) : acc;
+        }
+        // Fractional exponent: b^e = exp(e·ln b), needing the limit layer.
+        if (ctx.has("exp") && ctx.has("log")) {
+            return ctx.apply("exp", [
+                ctx.apply("multiply", [e, ctx.apply("log", [base])]),
+            ]);
+        }
+        return real(Math.pow(asReal(base), asReal(e)));
+    }, { infix: EXPONENT });
+    // gcd via Euclid (mod) — number theory standing on the integer primitives.
+    r.derive("gcd", 2, ["gcd"], (args, ctx) => {
+        let a = asInt(args[0]);
+        let b = asInt(args[1]);
+        a = a < 0n ? -a : a;
+        b = b < 0n ? -b : b;
+        while (b !== 0n) {
+            const t = asInt(ctx.apply("mod", [int(a), int(b)]));
+            a = b;
+            b = t < 0n ? -t : t;
+        }
+        return int(a);
+    });
+    // ── polymorphic inverse (the bridge to the symbol domain) ────────────────
+    // The additive inverse of a NUMBER is its negation; the inverse of a SYMBOL is
+    // its RESONANT OPPOSITE — found by the host's resonance and pre-resolved into
+    // ctx.resonance (see resonance.ts).  One op, dispatched on the operand's
+    // domain: this is "inverse of 3 is −3, inverse of <a learned form> is its
+    // opposite", in any modality.  A bit inverts as logical not.
+    r.derive("inverse", 1, ["inverse", "opposite", "invert"], (args, ctx) => {
+        const v = args[0];
+        if (v.domain === "symbol") {
+            const opp = ctx.resonance.opposite(v.bytes);
+            // No known opposite → leave the form unchanged rather than fabricate one
+            // (faithfulness: ALU never invents meaning resonance did not supply).
+            return opp ? { domain: "symbol", bytes: opp } : v;
+        }
+        if (v.domain === "bit")
+            return ctx.apply("not", [v]);
+        return ctx.apply("negate", [v]);
+    });
+    // reciprocal already registered as the multiplicative inverse primitive.
+}
+// ── exported array routines (derivations whose natural shape is arrays) ──────
+/** Horner evaluation of a polynomial whose coefficients run constant-first
+ *  (`coeffs[0]` is the constant term).  Pure arithmetic over add/multiply. */
+export function polyEval(coeffs, x) {
+    let acc = 0;
+    for (let i = coeffs.length - 1; i >= 0; i--)
+        acc = acc * x + coeffs[i];
+    return acc;
+}
+/** Dot product of two equal-length vectors — a fold of add over multiply. */
+export function dot(a, b) {
+    if (a.length !== b.length)
+        throw new Error("dot: length mismatch");
+    let s = 0;
+    for (let i = 0; i < a.length; i++)
+        s += a[i] * b[i];
+    return s;
+}
+/** Matrix · vector. */
+export function matVec(m, v) {
+    return m.map((row) => dot(row, v));
+}
+/** Matrix · matrix. */
+export function matMul(a, b) {
+    const n = a.length;
+    const k = b.length;
+    const p = b[0].length;
+    const out = Array.from({ length: n }, () => new Array(p).fill(0));
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < p; j++) {
+            let s = 0;
+            for (let t = 0; t < k; t++)
+                s += a[i][t] * b[t][j];
+            out[i][j] = s;
+        }
+    }
+    return out;
+}
+/** Solve A·x = b by Gaussian elimination with partial pivoting — structured
+ *  arithmetic (add / multiply / divide / compare for the pivot), not a new
+ *  primitive.  Returns x, or null if A is singular to tolerance `tol`. */
+export function linsolve(A, b, tol = 1e-12) {
+    const n = A.length;
+    // Work on an augmented copy so the inputs are untouched.
+    const M = A.map((row, i) => [...row, b[i]]);
+    for (let col = 0; col < n; col++) {
+        // Partial pivot: the row with the largest |value| in this column.
+        let piv = col;
+        for (let r = col + 1; r < n; r++) {
+            if (Math.abs(M[r][col]) > Math.abs(M[piv][col]))
+                piv = r;
+        }
+        if (Math.abs(M[piv][col]) < tol)
+            return null; // singular
+        [M[col], M[piv]] = [M[piv], M[col]];
+        // Eliminate below.
+        for (let r = col + 1; r < n; r++) {
+            const f = M[r][col] / M[col][col];
+            for (let c = col; c <= n; c++)
+                M[r][c] -= f * M[col][c];
+        }
+    }
+    // Back-substitute.
+    const x = new Array(n).fill(0);
+    for (let i = n - 1; i >= 0; i--) {
+        let s = M[i][n];
+        for (let j = i + 1; j < n; j++)
+            s -= M[i][j] * x[j];
+        x[i] = s / M[i][i];
+    }
+    return x;
+}

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

@@ -0,0 +1,19 @@
+import type { OpContext, OperationRegistry } from "./operation.js";
+/** Exact addition through the ripple of full_adders. */
+export declare function addBits(ctx: OpContext, a: bigint, b: bigint): bigint;
+/** Exact two's-complement negation. */
+export declare function negateBits(ctx: OpContext, a: bigint): bigint;
+/** Exact shift-add multiplication: for each set bit i of b, add (a << i) to the
+ *  accumulator.  The per-bit gate is an AND mask of the shifted a with bᵢ; the
+ *  accumulation is rippleAdd — so multiply traces entirely to nand. */
+export declare function mulBits(ctx: OpContext, a: bigint, b: bigint): bigint;
+/** Sign of an integer as {-1, 0, 1}: zero when every bit is zero, −1 when the
+ *  two's-complement sign bit is set, +1 otherwise — read off the bit array. */
+export declare function signBits(ctx: OpContext, a: bigint): bigint;
+/** Compare via sign(subtract): −1 if a<b, 0 if a=b, +1 if a>b, where subtract is
+ *  add ∘ negate — so comparison is structured arithmetic, not a new primitive. */
+export declare function compareBits(ctx: OpContext, a: bigint, b: bigint): bigint;
+/** Register the bit-bootstrap ops (int domain) into `r`.  They have no surface
+ *  forms — they are an internal exhibit, exercised by the tests and by anyone
+ *  who wants to walk the nand→arithmetic chain, not matched from a query. */
+export declare function registerBits(r: OperationRegistry): void;

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

@@ -0,0 +1,152 @@
+// kernel-bits.ts — the "everything derives from nand" bootstrap, made exact.
+//
+// This is the EXHIBIT that proves the kernel's central claim: arithmetic is not
+// a new primitive, it is a derivation over the logic layer.  Here `full_adder`
+// is built from the xor/and/or exposed in kernel-logic.ts (themselves derived
+// from nand alone), and from one full_adder the whole integer field follows:
+//
+//   full_adder → ripple add → two's-complement negate → shift-add multiply
+//             → sign → compare → (and, with control flow, everything else).
+//
+// It operates on EXACT integers (bigint) so the proof holds past 2^53 where a
+// double would round.  Every gate call goes through ctx.apply, so the dependency
+// edges back to nand are literal, runnable source — the tests cross-check each
+// op against native bigint, and the integration arithmetic (kernel-arith.ts)
+// uses native bigint on the hot path, having been proven equal to this here.
+//
+// These ops are registered under a "bits." namespace, distinct from the
+// polymorphic arithmetic of kernel-arith.ts, precisely so the bootstrap is an
+// inspectable, separately-tested artifact and never silently the substrate of a
+// real-number computation.
+import { asInt, bit, int } from "./value.js";
+/** Width-bounded two's-complement little-endian bit array (index 0 = LSB).
+ *  Width is chosen by the caller wide enough that the signed result cannot
+ *  overflow, so interpreting the top bit as the sign is always correct. */
+function toBits(n, width) {
+    const mod = 1n << BigInt(width);
+    let u = ((n % mod) + mod) % mod; // two's-complement representation
+    const bits = new Array(width);
+    for (let i = 0; i < width; i++) {
+        bits[i] = Number(u & 1n);
+        u >>= 1n;
+    }
+    return bits;
+}
+/** Interpret a two's-complement little-endian bit array as a signed bigint. */
+function fromBits(bits) {
+    const width = bits.length;
+    let u = 0n;
+    for (let i = 0; i < width; i++)
+        if (bits[i])
+            u |= 1n << BigInt(i);
+    const signBitSet = bits[width - 1] === 1;
+    return signBitSet ? u - (1n << BigInt(width)) : u;
+}
+/** Bits needed to hold |n| (at least 1). */
+function magnitudeBits(n) {
+    const a = n < 0n ? -n : n;
+    return a === 0n ? 1 : a.toString(2).length;
+}
+/** A single full adder built from the logic gates: sum = a⊕b⊕cin, carry =
+ *  (a∧b) ∨ (cin ∧ (a⊕b)).  Every gate goes through ctx.apply → nand. */
+function fullAdder(ctx, a, b, cin) {
+    const A = bit(a), B = bit(b), C = bit(cin);
+    const axb = ctx.apply("xor", [A, B]);
+    const sum = ctx.apply("xor", [axb, C]);
+    const cout = ctx.apply("or", [
+        ctx.apply("and", [A, B]),
+        ctx.apply("and", [C, axb]),
+    ]);
+    return {
+        sum: sum.domain === "bit" ? sum.b : 0,
+        cout: cout.domain === "bit" ? cout.b : 0,
+    };
+}
+/** Ripple-carry add of two two's-complement bit arrays (equal width). */
+function rippleAdd(ctx, x, y) {
+    const width = x.length;
+    const out = new Array(width);
+    let carry = 0;
+    for (let i = 0; i < width; i++) {
+        const { sum, cout } = fullAdder(ctx, x[i], y[i], carry);
+        out[i] = sum;
+        carry = cout;
+    }
+    return out;
+}
+/** Bitwise NOT of a bit array, via the not gate. */
+function notBits(ctx, x) {
+    return x.map((b) => {
+        const r = ctx.apply("not", [bit(b)]);
+        return (r.domain === "bit" ? r.b : 0);
+    });
+}
+/** Two's-complement negate: invert every bit, then add one. */
+function negateBitsArr(ctx, x) {
+    const width = x.length;
+    const one = toBits(1n, width);
+    return rippleAdd(ctx, notBits(ctx, x), one);
+}
+// ── public pure functions (used by the tests and the explicit ops) ──────────
+/** Exact addition through the ripple of full_adders. */
+export function addBits(ctx, a, b) {
+    const width = Math.max(magnitudeBits(a), magnitudeBits(b)) + 2;
+    return fromBits(rippleAdd(ctx, toBits(a, width), toBits(b, width)));
+}
+/** Exact two's-complement negation. */
+export function negateBits(ctx, a) {
+    const width = magnitudeBits(a) + 2;
+    return fromBits(negateBitsArr(ctx, toBits(a, width)));
+}
+/** Exact shift-add multiplication: for each set bit i of b, add (a << i) to the
+ *  accumulator.  The per-bit gate is an AND mask of the shifted a with bᵢ; the
+ *  accumulation is rippleAdd — so multiply traces entirely to nand. */
+export function mulBits(ctx, a, b) {
+    const width = magnitudeBits(a) + magnitudeBits(b) + 2;
+    const aBits = toBits(a, width);
+    const bBits = toBits(b, width);
+    let acc = toBits(0n, width);
+    for (let i = 0; i < width; i++) {
+        if (bBits[i] === 0)
+            continue;
+        // a shifted left by i (within width), masked by bᵢ (= 1 here).
+        const shifted = new Array(width);
+        for (let k = 0; k < width; k++) {
+            const src = k - i >= 0 ? aBits[k - i] : 0;
+            const m = ctx.apply("and", [bit(src), bit(bBits[i])]);
+            shifted[k] = (m.domain === "bit" ? m.b : 0);
+        }
+        acc = rippleAdd(ctx, acc, shifted);
+    }
+    return fromBits(acc);
+}
+/** Sign of an integer as {-1, 0, 1}: zero when every bit is zero, −1 when the
+ *  two's-complement sign bit is set, +1 otherwise — read off the bit array. */
+export function signBits(ctx, a) {
+    if (a === 0n)
+        return 0n;
+    const width = magnitudeBits(a) + 2;
+    const bits = toBits(a, width);
+    return bits[width - 1] === 1 ? -1n : 1n;
+}
+/** Compare via sign(subtract): −1 if a<b, 0 if a=b, +1 if a>b, where subtract is
+ *  add ∘ negate — so comparison is structured arithmetic, not a new primitive. */
+export function compareBits(ctx, a, b) {
+    return signBits(ctx, addBits(ctx, a, negateBits(ctx, b)));
+}
+/** Register the bit-bootstrap ops (int domain) into `r`.  They have no surface
+ *  forms — they are an internal exhibit, exercised by the tests and by anyone
+ *  who wants to walk the nand→arithmetic chain, not matched from a query. */
+export function registerBits(r) {
+    // full_adder exposed as a 3-bit op returning the 2-bit {sum, carry} as an int
+    // 0..3 (carry in bit 1, sum in bit 0) so it is callable/testable on its own.
+    r.derive("bits.fullAdder", 3, [], (args, ctx) => {
+        const s = fullAdder(ctx, asInt(args[0]) === 0n ? 0 : 1, asInt(args[1]) === 0n ? 0 : 1, asInt(args[2]) === 0n ? 0 : 1);
+        return int(BigInt(s.sum) | (BigInt(s.cout) << 1n));
+    });
+    r.derive("bits.add", 2, [], (args, ctx) => int(addBits(ctx, asInt(args[0]), asInt(args[1]))));
+    r.derive("bits.negate", 1, [], (args, ctx) => int(negateBits(ctx, asInt(args[0]))));
+    r.derive("bits.multiply", 2, [], (args, ctx) => int(mulBits(ctx, asInt(args[0]), asInt(args[1]))));
+    r.derive("bits.sign", 1, [], (args, ctx) => int(signBits(ctx, asInt(args[0]))));
+    r.derive("bits.compare", 2, [], (args, ctx) => int(compareBits(ctx, asInt(args[0]), asInt(args[1]))));
+}

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

@@ -0,0 +1,4 @@
+import type { OperationRegistry } from "./operation.js";
+/** Register the logic layer into `r`.  Idempotent in effect (re-registering
+ *  overwrites with the same definitions). */
+export declare function registerLogic(r: OperationRegistry): void;

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

@@ -0,0 +1,60 @@
+// kernel-logic.ts — the completeness layer.
+//
+// One primitive: nand.  It is functionally complete on its own, so EVERY other
+// gate is a derivation over it, registered with `derive` and composing only
+// through ctx.apply — the dependency edges are the literal source.  This is the
+// irreducible root of the whole library: arithmetic's bit bootstrap
+// (kernel-bits.ts) builds full_adder from the xor/and/or exposed here, and from
+// there add → multiply → everything.
+//
+//   not(a)        = nand(a, a)
+//   and(a, b)     = not(nand(a, b))
+//   or(a, b)      = nand(not a, not b)            (De Morgan)
+//   nor(a, b)     = not(or(a, b))
+//   xor(a, b)     = or(and(a, not b), and(not a, b))
+//   xnor(a, b)    = not(xor(a, b))
+//   implies(a, b) = or(not a, b)
+//   iff(a, b)     = xnor(a, b)
+//   mux(s, a, b)  = or(and(not s, a), and(s, b))  — select b when s, else a;
+//                   the bridge to control flow (conditional selection).
+//
+// `not`, `and`, `or` are exposed for ergonomics but are themselves derived —
+// only nand is primitive.
+import { asBit, bit } from "./value.js";
+/** Register the logic layer into `r`.  Idempotent in effect (re-registering
+ *  overwrites with the same definitions). */
+export function registerLogic(r) {
+    // The one irreducible gate.  ¬(a ∧ b).
+    r.prim("nand", 2, [], (args) => {
+        const a = asBit(args[0]);
+        const b = asBit(args[1]);
+        return bit(a & b ? 0 : 1);
+    });
+    // Exposed-but-derived basic gates.
+    r.derive("not", 1, ["not", "!", "~", "¬"], (args, ctx) => ctx.apply("nand", [args[0], args[0]]));
+    r.derive("and", 2, ["and", "&", "&&", "∧"], (args, ctx) => ctx.apply("not", [ctx.apply("nand", [args[0], args[1]])]));
+    r.derive("or", 2, ["or", "|", "||", "∨"], (args, ctx) => {
+        const na = ctx.apply("not", [args[0]]);
+        const nb = ctx.apply("not", [args[1]]);
+        return ctx.apply("nand", [na, nb]);
+    });
+    // Fully derived gates.
+    r.derive("nor", 2, ["nor", "⊽"], (args, ctx) => ctx.apply("not", [ctx.apply("or", [args[0], args[1]])]));
+    r.derive("xor", 2, ["xor", "^", "⊕"], (args, ctx) => {
+        const a = args[0], b = args[1];
+        const left = ctx.apply("and", [a, ctx.apply("not", [b])]);
+        const right = ctx.apply("and", [ctx.apply("not", [a]), b]);
+        return ctx.apply("or", [left, right]);
+    });
+    r.derive("xnor", 2, ["xnor", "⊙"], (args, ctx) => ctx.apply("not", [ctx.apply("xor", [args[0], args[1]])]));
+    r.derive("implies", 2, ["implies", "=>", "→", "⇒"], (args, ctx) => ctx.apply("or", [ctx.apply("not", [args[0]]), args[1]]));
+    r.derive("iff", 2, ["iff", "<=>", "↔", "⇔"], (args, ctx) => ctx.apply("xnor", [args[0], args[1]]));
+    // mux(s, a, b): select a when s = 0, b when s = 1.  The bridge to control
+    // flow — conditional selection, and (with recursion in the caller) looping.
+    r.derive("mux", 3, ["mux", "select", "?:"], (args, ctx) => {
+        const s = args[0], a = args[1], b = args[2];
+        const lo = ctx.apply("and", [ctx.apply("not", [s]), a]);
+        const hi = ctx.apply("and", [s, b]);
+        return ctx.apply("or", [lo, hi]);
+    });
+}

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

@@ -0,0 +1,3 @@
+import type { OperationRegistry } from "./operation.js";
+/** Register the n-dimensional layer into `r`.  All ops are STRUCTURAL. */
+export declare function registerNd(r: OperationRegistry): void;