@hviana/sema 0.1.3 → 0.1.5

package/dist/src/vec.d.ts

@@ -14,17 +14,21 @@ export declare function normalize(v: Vec): Vec;
 export declare function cosine(a: Vec, b: Vec): number;
 /** Set vector epsilon thresholds. Called once by Mind at construction. */
 export declare function setVecConfig(cfg: {
-    normalizeEpsilon?: number;
-    cosineEpsilon?: number;
+  normalizeEpsilon?: number;
+  cosineEpsilon?: number;
 }): void;
 export interface Permutation {
-    fwd: Uint32Array;
-    inv: Uint32Array;
+  fwd: Uint32Array;
+  inv: Uint32Array;
 }
 /** The keyring: one independent permutation per seat.
  *  Independent keys do not commute, so an address in a tree is the
  *  path itself — "seat 2 inside seat 1" ≠ "seat 1 inside seat 2". */
-export declare function makeKeyring(D: number, seats: number, rand: () => number): Permutation[];
+export declare function makeKeyring(
+  D: number,
+  seats: number,
+  rand: () => number,
+): Permutation[];
 /** Apply permutation: out[i] = v[table[i]]. */
 export declare function permute(v: Vec, table: Uint32Array): Vec;
 /** Permute into existing buffer — zero allocation. */

package/dist/src/vec.js

@@ -4,44 +4,49 @@
 // No weights. No gradients.
 /** Deterministic PRNG (32-bit mixer). */
 export function rng(seed) {
-    let s = seed >>> 0;
-    return () => {
-        s = (s + 0x6d2b79f5) >>> 0;
-        let t = s;
-        t = Math.imul(t ^ (t >>> 15), t | 1);
-        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
-        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-    };
+  let s = seed >>> 0;
+  return () => {
+    s = (s + 0x6d2b79f5) >>> 0;
+    let t = s;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
 }
 /** Standard normal sample (Box–Muller). */
 function gaussian(rand) {
-    let u = 0, v = 0;
-    while (u === 0)
-        u = rand();
-    while (v === 0)
-        v = rand();
-    return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+  let u = 0, v = 0;
+  while (u === 0) {
+    u = rand();
+  }
+  while (v === 0) {
+    v = rand();
+  }
+  return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
 }
 export const zeros = (D) => new Float32Array(D);
 export const copy = (v) => new Float32Array(v);
 /** Random point on the unit sphere. */
 export function randomUnit(D, rand) {
-    const v = zeros(D);
-    for (let i = 0; i < D; i++)
-        v[i] = gaussian(rand);
-    return normalize(v);
+  const v = zeros(D);
+  for (let i = 0; i < D; i++) {
+    v[i] = gaussian(rand);
+  }
+  return normalize(v);
 }
 /** target += src * scale (in place). */
 export function addInto(target, src, scale = 1) {
-    for (let i = 0; i < target.length; i++)
-        target[i] += src[i] * scale;
-    return target;
+  for (let i = 0; i < target.length; i++) {
+    target[i] += src[i] * scale;
+  }
+  return target;
 }
 export function dot(a, b) {
-    let s = 0;
-    for (let i = 0; i < a.length; i++)
-        s += a[i] * b[i];
-    return s;
+  let s = 0;
+  for (let i = 0; i < a.length; i++) {
+    s += a[i] * b[i];
+  }
+  return s;
 }
 const norm = (v) => Math.sqrt(dot(v, v));
 // Epsilon thresholds (settable once via setVecConfig).
@@ -49,61 +54,68 @@ let _normalizeEpsilon = 1e-12;
 let _cosineEpsilon = 1e-12;
 /** In-place normalization. */
 export function normalize(v) {
-    const n = norm(v);
-    if (n > _normalizeEpsilon) {
-        for (let i = 0; i < v.length; i++)
-            v[i] /= n;
+  const n = norm(v);
+  if (n > _normalizeEpsilon) {
+    for (let i = 0; i < v.length; i++) {
+      v[i] /= n;
     }
-    return v;
+  }
+  return v;
 }
 /** Resonance: 1 = same, 0 = unrelated. */
 export function cosine(a, b) {
-    const na = norm(a), nb = norm(b);
-    return na > _cosineEpsilon && nb > _cosineEpsilon ? dot(a, b) / (na * nb) : 0;
+  const na = norm(a), nb = norm(b);
+  return na > _cosineEpsilon && nb > _cosineEpsilon ? dot(a, b) / (na * nb) : 0;
 }
 /** Set vector epsilon thresholds. Called once by Mind at construction. */
 export function setVecConfig(cfg) {
-    if (cfg.normalizeEpsilon !== undefined) {
-        _normalizeEpsilon = cfg.normalizeEpsilon;
-    }
-    if (cfg.cosineEpsilon !== undefined)
-        _cosineEpsilon = cfg.cosineEpsilon;
+  if (cfg.normalizeEpsilon !== undefined) {
+    _normalizeEpsilon = cfg.normalizeEpsilon;
+  }
+  if (cfg.cosineEpsilon !== undefined) {
+    _cosineEpsilon = cfg.cosineEpsilon;
+  }
 }
 /** One fixed random permutation (Fisher–Yates). */
 function makePermutation(D, rand) {
-    const fwd = new Uint32Array(D);
-    for (let i = 0; i < D; i++)
-        fwd[i] = i;
-    for (let i = D - 1; i > 0; i--) {
-        const j = Math.floor(rand() * (i + 1));
-        const t = fwd[i];
-        fwd[i] = fwd[j];
-        fwd[j] = t;
-    }
-    const inv = new Uint32Array(D);
-    for (let i = 0; i < D; i++)
-        inv[fwd[i]] = i;
-    return { fwd, inv };
+  const fwd = new Uint32Array(D);
+  for (let i = 0; i < D; i++) {
+    fwd[i] = i;
+  }
+  for (let i = D - 1; i > 0; i--) {
+    const j = Math.floor(rand() * (i + 1));
+    const t = fwd[i];
+    fwd[i] = fwd[j];
+    fwd[j] = t;
+  }
+  const inv = new Uint32Array(D);
+  for (let i = 0; i < D; i++) {
+    inv[fwd[i]] = i;
+  }
+  return { fwd, inv };
 }
 /** The keyring: one independent permutation per seat.
  *  Independent keys do not commute, so an address in a tree is the
  *  path itself — "seat 2 inside seat 1" ≠ "seat 1 inside seat 2". */
 export function makeKeyring(D, seats, rand) {
-    const ring = [];
-    for (let s = 0; s < seats; s++)
-        ring.push(makePermutation(D, rand));
-    return ring;
+  const ring = [];
+  for (let s = 0; s < seats; s++) {
+    ring.push(makePermutation(D, rand));
+  }
+  return ring;
 }
 /** Apply permutation: out[i] = v[table[i]]. */
 export function permute(v, table) {
-    const out = new Float32Array(v.length);
-    for (let i = 0; i < v.length; i++)
-        out[i] = v[table[i]];
-    return out;
+  const out = new Float32Array(v.length);
+  for (let i = 0; i < v.length; i++) {
+    out[i] = v[table[i]];
+  }
+  return out;
 }
 /** Permute into existing buffer — zero allocation. */
 export function permuteInto(out, v, table) {
-    for (let i = 0; i < v.length; i++)
-        out[i] = v[table[i]];
-    return out;
+  for (let i = 0; i < v.length; i++) {
+    out[i] = v[table[i]];
+  }
+  return out;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hviana/sema",
-  "version": "0.1.3",
-  "description": "An elementary, recursive, weight-free multimodal mind: one structure, two verbs, one memory. Zero runtime dependencies, pure web standards.",
+  "version": "0.1.5",
+  "description": "Sema: a non-parametric, instance-based reasoning system.",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",

package/src/sema.ts

@@ -0,0 +1,102 @@
+import {
+  addInto,
+  normalize,
+  Permutation,
+  permute,
+  permuteInto,
+  randomUnit,
+  rng,
+  Vec,
+  zeros,
+} from "./vec.js";
+
+/** The one structure. A node's vector is the gist of its whole subtree; it also
+ *  carries the structure the DAG store interns — its leaf bytes, or its kids. */
+export interface Sema {
+  v: Vec;
+  leaf: Uint8Array | null;
+  kids: Sema[] | null;
+}
+
+export const sema = (
+  v: Vec,
+  leaf: Uint8Array | null = null,
+  kids: Sema[] | null = null,
+): Sema => ({ v, leaf, kids });
+
+/** Whether a node is a CHUNK — a leaf-parent whose children are ALL leaves,
+ *  the perception tree's smallest grouped unit.  The one predicate behind
+ *  region collection, canonical segmentation seams, and sub-span indexing;
+ *  named here beside the type so no consumer restates the shape inline. */
+export const isChunk = (n: Sema): n is Sema & { kids: Sema[] } =>
+  n.kids !== null && n.kids.every((k) => k.kids === null);
+
+/** The medium: dimension, keyring, and noise source. */
+export interface Space {
+  D: number;
+  seats: Permutation[];
+  rand: () => number;
+  maxGroup: number;
+}
+
+// Reusable permute buffer for fold.
+let _foldBuf: Vec | null = null;
+
+/** Bind one vector into a seat — the elementary half of fold. Used to index an
+ *  episode from either side and to pour a partner into a form's halo. */
+export const bindSeat = (space: Space, v: Vec, seat: number): Vec =>
+  permute(v, space.seats[seat].fwd);
+
+// ── Company signatures ──────────────────────────────────────────────────
+//
+// A halo is a superposition of EPISODE SIGNATURES: it answers "who does this
+// form keep company with", and two forms share a concept when they keep the
+// SAME company (the same partner nodes).  Pouring the partner's raw GIST was
+// an approximation of that: it worked while the hierarchical fold decorrelated
+// unrelated gists quickly, but any byte-overlap between partners leaks CONTENT
+// similarity into COMPANY similarity, silently shifting the halo null model
+// that conceptThreshold's derivation (unrelated halos ⇒ cosine 0 ± 1/√D)
+// depends on.  A signature makes the semantics exact and fold-independent:
+// a deterministic unit vector derived from the partner's IDENTITY, so two
+// halos correlate exactly as much as their company overlaps — never because
+// their partners merely contain similar bytes.
+//
+// Seeded by node id: ids are content-addressed mint order, stable for a given
+// corpus (including checkpoint/resume, which re-derives identical ids), and
+// halos are per-store training artifacts that are never compared across
+// stores.
+
+const _sigCache = new WeakMap<Space, Map<number, Vec>>();
+const SIG_CACHE_MAX = 65_536;
+
+/** The company signature of node `id` — the halo's pour unit (see above). */
+export function companySignature(space: Space, id: number): Vec {
+  let cache = _sigCache.get(space);
+  if (!cache) _sigCache.set(space, cache = new Map());
+  const hit = cache.get(id);
+  if (hit) return hit;
+  const v = randomUnit(space.D, rng((id ^ 0x9e3779b9) >>> 0));
+  if (cache.size >= SIG_CACHE_MAX) cache.clear(); // flat cap; regeneration is cheap
+  cache.set(id, v);
+  return v;
+}
+
+/** fold — combine ordered children into one gist.
+ *  Each child is turned with its seat's own key, superposed, normalized. */
+export function fold(space: Space, kids: Vec[]): Vec {
+  if (kids.length > space.seats.length) {
+    throw new Error(
+      `fold: ${kids.length} children but the keyring has only ${space.seats.length} seats`,
+    );
+  }
+  const out = zeros(space.D);
+  if (!_foldBuf || _foldBuf.length !== space.D) {
+    _foldBuf = new Float32Array(space.D);
+  }
+  const buf = _foldBuf;
+  for (let i = 0; i < kids.length; i++) {
+    permuteInto(buf, kids[i], space.seats[i].fwd);
+    addInto(out, buf);
+  }
+  return normalize(out);
+}