laserbrain 1.1.0

package/laserbrain.js

@@ -0,0 +1,44 @@
+// #laserbrain
+
+// quadrize — gated Laplace diffusion kernel
+// blends each token with its neighbours via exponential decay
+// x: Float32Array of length ctx (1D) or ctx*d (2D flattened, pass d explicitly)
+
+function sigmoid(x) {
+  return 1 / (1 + Math.exp(-Math.max(-30, Math.min(30, x))));
+}
+
+function quadrize(x, k = 1.0, gate = -1.4, d = 1) {
+  const ctx = x.length / d;
+  const g = sigmoid(gate);
+
+  // build kernel K[i][j] = exp(-k * |i-j|), normalised
+  const K = [];
+  for (let i = 0; i < ctx; i++) {
+    const row = new Float32Array(ctx);
+    let sum = 0;
+    for (let j = 0; j < ctx; j++) {
+      row[j] = Math.exp(-Math.abs(k) * Math.abs(i - j));
+      sum += row[j];
+    }
+    for (let j = 0; j < ctx; j++) row[j] /= sum;
+    K.push(row);
+  }
+
+  // mixed = K @ x  (per embedding dimension)
+  const out = new Float32Array(x.length);
+  for (let i = 0; i < ctx; i++) {
+    for (let e = 0; e < d; e++) {
+      let v = 0;
+      for (let j = 0; j < ctx; j++) v += K[i][j] * x[j * d + e];
+      const idx = i * d + e;
+      out[idx] = x[idx] + g * (v - x[idx]);
+    }
+  }
+
+  return out;
+}
+
+quadrize.kernel = { name: 'phronesis', k: 1.0 };
+
+module.exports = { quadrize };

package/laserbrain.test.js

@@ -0,0 +1,90 @@
+// #laserbrain unit tests
+
+const { quadrize } = require('./laserbrain');
+
+let pass = 0, fail = 0;
+
+function assert(name, cond) {
+  if (cond) { console.log(`✓ ${name}`); pass++; }
+  else       { console.error(`✗ ${name}`); fail++; }
+}
+
+function approx(a, b, tol = 1e-5) {
+  return Math.abs(a - b) < tol;
+}
+
+// 1. output length matches input
+const x = new Float32Array([1, 2, 3, 4, 5]);
+const out = quadrize(x);
+assert('output length matches input', out.length === x.length);
+
+// 2. gate=0 → g=0.5 → edge elements are blended (not identity)
+const out2 = quadrize(x, 1.0, 0);
+assert('gate=0 blends edge elements', !approx(out2[0], x[0]));
+
+// 3. near-zero k → near-uniform kernel → all values converge to mean
+const out3 = quadrize(x, 0.001, 10.0);
+const mean = x.reduce((a, b) => a + b) / x.length;
+assert('low k collapses to mean', approx(out3[0], mean, 0.1));
+
+// 4. uniform input → quadrize is identity
+const flat = new Float32Array([3, 3, 3, 3, 3]);
+const out4 = quadrize(flat);
+assert('uniform input is unchanged', out4.every(v => approx(v, 3)));
+
+// 5. output is Float32Array
+assert('returns Float32Array', out instanceof Float32Array);
+
+// 6. kernel.name is phronesis
+assert('kernel.name is phronesis', quadrize.kernel.name === 'phronesis');
+
+// 6b. kernel.k is defined
+assert('kernel.k is defined', typeof quadrize.kernel.k === 'number');
+
+// 7. high k → narrow kernel → output near identity
+const out7 = quadrize(x, 100.0, 10.0);
+assert('high k preserves values', out7.every((v, i) => approx(v, x[i], 0.01)));
+
+// 8. very negative gate → g≈0 → output near identity
+const out8 = quadrize(x, 0.001, -30.0);
+assert('gate≈0 is near identity', out8.every((v, i) => approx(v, x[i], 1e-3)));
+
+// 9. symmetric input → symmetric output
+const sym = new Float32Array([1, 2, 3, 2, 1]);
+const out9 = quadrize(sym, 1.0, 0);
+assert('symmetric input → symmetric output', approx(out9[0], out9[4]) && approx(out9[1], out9[3]));
+
+// 10. blending pulls edges toward mean
+const out10 = quadrize(x, 0.5, 5.0);
+assert('edge pulled toward mean', out10[0] > x[0] && out10[4] < x[4]);
+
+// 11. negative values — center of [-3,-1,0,1,3] stays near 0
+const neg = new Float32Array([-3, -1, 0, 1, 3]);
+const out11 = quadrize(neg, 1.0, 0);
+assert('negative values: center near 0', approx(out11[2], 0, 0.1));
+
+// 12. length-1 input → unchanged
+const one = new Float32Array([7]);
+const out12 = quadrize(one);
+assert('length-1 input unchanged', approx(out12[0], 7));
+
+// 13. 2D: output length matches ctx*d
+const x2d = new Float32Array([1,0, 2,0, 3,0, 4,0, 5,0]); // ctx=5, d=2
+const out13 = quadrize(x2d, 1.0, 0, 2);
+assert('2D output length matches input', out13.length === x2d.length);
+
+// 14. 2D: uniform input unchanged
+const flat2d = new Float32Array([3,1, 3,1, 3,1, 3,1, 3,1]);
+const out14 = quadrize(flat2d, 1.0, 0, 2);
+assert('2D uniform input unchanged', out14.every((v, i) => approx(v, flat2d[i])));
+
+// 15. 2D: each embedding dimension diffuses independently
+const x2d_b = new Float32Array([1,10, 2,20, 3,30, 4,40, 5,50]);
+const out15 = quadrize(x2d_b, 0.5, 5.0, 2);
+// dim 0 (positions 0,2,4,6,8) should shift toward mean=3; dim 1 toward mean=30
+const d0_mean = (out15[0]+out15[2]+out15[4]+out15[6]+out15[8])/5;
+const d1_mean = (out15[1]+out15[3]+out15[5]+out15[7]+out15[9])/5;
+assert('2D dims diffuse independently', approx(d0_mean, 3, 0.5) && approx(d1_mean, 30, 5));
+
+console.log(`\n${pass} passed, ${fail} failed`);
+if (fail > 0) process.exit(1);

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "laserbrain",
+  "version": "1.1.0",
+  "description": "gated Laplace diffusion kernel — blends each position toward its neighbours with exponential decay and a learned gate",
+  "main": "laserbrain.js",
+  "scripts": {
+    "test": "node laserbrain.test.js"
+  },
+  "keywords": [
+    "diffusion",
+    "kernel",
+    "attention",
+    "lm",
+    "token",
+    "embedding",
+    "neural",
+    "signal",
+    "smooth",
+    "decay",
+    "field",
+    "love",
+    "nature"
+  ],
+  "author": "Claude (Anthropic)",
+  "contributors": [
+    "Diego Rincon"
+  ],
+  "license": "ISC",
+  "type": "commonjs"
+}