Upload web/test_ieee.js with huggingface_hub

web/test_ieee.js

@@ -78,6 +78,39 @@ function mulF32Spec(a, b) {
 // what WGSL `f32(s) * a * b` means: left-associative, rounded after every step
 const epiSpec = (s, a, b) => mulF32Spec(mulF32Spec(i32ToF32Spec(s), a), b);
 
+// ADDITION, same discipline: exact BigInt sum of the two scaled significands,
+// one rounding. An exact zero sum from nonzero operands is +0 under RNE;
+// -0 + -0 keeps its -0 (IEEE 754-2019 §6.3).
+function addF32Spec(a, b) {
+  if (a === 0 && b === 0) return (signbit(a) && signbit(b)) ? -0 : 0;
+  if (a === 0) return b;
+  if (b === 0) return a;
+  const A = decomposeF32(a), B = decomposeF32(b);
+  const e0 = Math.min(A.exp2, B.exp2);
+  const T = (A.neg ? -A.mant : A.mant) * (1n << BigInt(A.exp2 - e0))
+          + (B.neg ? -B.mant : B.mant) * (1n << BigInt(B.exp2 - e0));
+  if (T === 0n) return 0;
+  return roundToF32(T < 0n, T < 0n ? -T : T, e0);
+}
+
+// FUSED multiply-add: the product is NEVER rounded — exact BigInt product plus
+// the exact addend, ONE rounding. This is what a hardware FMA computes, and
+// (per neural-rdna2's fma golden, which this mirrors) the float64 shortcut
+// fround(a*b + c) double-rounds on rare ties and is NOT a valid reference in
+// general. Finite inputs only, like the rest of this oracle.
+function fmaF32Spec(a, b, c) {
+  const spNeg = signbit(a) !== signbit(b);
+  let P = 0n, ep = 0;
+  if (a !== 0 && b !== 0) { const A = decomposeF32(a), B = decomposeF32(b); P = A.mant * B.mant; ep = A.exp2 + B.exp2; }
+  let Cm = 0n, ec = 0;
+  const scNeg = signbit(c);
+  if (c !== 0) { const C = decomposeF32(c); Cm = C.mant; ec = C.exp2; }
+  const e0 = Math.min(ep, ec);
+  const T = (spNeg ? -P : P) * (1n << BigInt(ep - e0)) + (scNeg ? -Cm : Cm) * (1n << BigInt(ec - e0));
+  if (T === 0n) return (spNeg && scNeg) ? -0 : 0;   // exact zero: -0 only if both parts negative
+  return roundToF32(T < 0n, T < 0n ? -T : T, e0);
+}
+
 // ---- checks -----------------------------------------------------------------
 let pass = true;
 const ok = (c, msg) => { console.log(`${c ? "  ok  " : "  FAIL"}  ${msg}`); if (!c) pass = false; };
@@ -123,6 +156,94 @@ const asF32 = (x) => { f32buf[0] = x; return f32buf[0]; };
   ok(bad === 0, `mulF32Spec matches the correctly-rounded product on ${n} draws (subnormal..overflow)`);
 }
 
+// ---- addition: certify every fround(a+b) mirror step in the codebase --------
+// fround(a+b) is correctly rounded for f32 operands because f64 has >= 2p+2
+// bits of precision (53 >= 50, Figueroa's theorem) — double rounding is
+// innocuous for ADD. That claim guards every per-add rounding schedule we
+// ship, so it gets checked against the from-the-definition oracle, including
+// operand pairs with exponent gaps far beyond 53 bits.
+console.log("\naddF32Spec vs Math.fround(a+b), including extreme exponent gaps:");
+{
+  let bad = 0, n = 0;
+  const mags = [1, 1e-3, 1e-8, 1e-20, 1e-38, 1e-42, 3e38, 1e30, 0.5, 127];
+  for (let t = 0; t < 300000; t++) {
+    const a = asF32((Math.random() * 2 - 1) * mags[(Math.random() * mags.length) | 0]);
+    const b = asF32((Math.random() * 2 - 1) * mags[(Math.random() * mags.length) | 0]);
+    n++;
+    if (!Object.is(addF32Spec(a, b), f32(a + b))) {
+      if (bad++ < 3) console.log(`      ${a} + ${b}  spec=${addF32Spec(a, b)}  fround=${f32(a + b)}`);
+    }
+  }
+  ok(bad === 0, `addF32Spec matches fround(a+b) on ${n} draws — the per-add mirror schedule is the correctly-rounded sum`);
+  ok(Object.is(addF32Spec(-0, -0), -0) && Object.is(addF32Spec(asF32(1e-20), asF32(-1e-20)), 0),
+     "signed zero on sums: -0 + -0 = -0, exact cancellation = +0");
+}
+
+// ---- fused multiply-add ------------------------------------------------------
+console.log("\nfmaF32Spec: single rounding, cross-checked against an independent oracle:");
+{
+  // 1) fused must actually differ from the round-twice composition, or the
+  //    oracle proves nothing (cancellation is where they part ways)
+  let differ = 0, n = 0;
+  for (let t = 0; t < 100000; t++) {
+    const a = asF32((Math.random() * 2 - 1) * 1e3);
+    const b = asF32((Math.random() * 2 - 1) * 1e3);
+    const c = asF32(-(a * b));
+    n++;
+    if (!Object.is(fmaF32Spec(a, b, c), f32(f32(a * b) + c))) differ++;
+  }
+  ok(differ > 0, `fused differs from round-twice on ${differ}/${n} cancellation cases (single rounding is real)`);
+
+  // 2) cross-oracle: vectors generated by neural-rdna2's golden_fma_scalar
+  //    (verbatim, exact big-int, different codebase/author-time). Bit-for-bit
+  //    agreement means neither oracle was tuned to the other.
+  let vecs = null;
+  try { vecs = JSON.parse(fs.readFileSync(path.join(__dirname, "test_vectors_fma.json"), "utf8")); } catch (e) {}
+  if (vecs) {
+    const buf = new ArrayBuffer(4), dv = new DataView(buf);
+    const fromBits = (u) => { dv.setUint32(0, u); return dv.getFloat32(0); };
+    const toBits = (x) => { dv.setFloat32(0, x); return dv.getUint32(0); };
+    let bad = 0;
+    for (const [ah, bh, ch, rh] of vecs.vectors) {
+      const r = fmaF32Spec(fromBits(parseInt(ah, 16)), fromBits(parseInt(bh, 16)), fromBits(parseInt(ch, 16)));
+      if (toBits(r) !== parseInt(rh, 16)) {
+        if (bad++ < 3) console.log(`      ${ah},${bh},${ch}: js=${toBits(r).toString(16)} py=${rh}`);
+      }
+    }
+    ok(bad === 0, `agrees bit-for-bit with neural-rdna2's big-int fma golden on ${vecs.vectors.length} vectors (quantize-domain + cancellation + raw finite bits)`);
+  } else {
+    console.log("  note   test_vectors_fma.json not present — cross-oracle check skipped");
+  }
+
+  // 3) the b2b immunity scan's fused emulation, validated: on the quantize
+  //    domain (x >= 0, x*inv <= ~127.5, addend 0.5) the exact product spans
+  //    <= 53 bits including the 0.5, so fround(x*inv + 0.5) IS the true fma
+  //    there. That was an argument; this makes it a check.
+  let embad = 0, en = 0;
+  for (let t = 0; t < 300000; t++) {
+    const inv = asF32(0.25 + Math.random() * 500);
+    const x = asF32(Math.random() * 127.4 / inv);
+    en++;
+    if (!Object.is(f32(x * inv + 0.5), fmaF32Spec(x, inv, 0.5))) embad++;
+  }
+  ok(embad === 0, `on the quantize domain the f64 emulation equals the true fma (${en} draws) — test_b2b's immunity scan stands on a checked fact`);
+
+  // 4) and the immunity conclusion itself, re-run against the TRUE fma at the
+  //    binade edges: raw last-ulp differences exist, none survives floor()
+  let raw = 0, fl = 0;
+  for (let k = 1; k <= 7; k++) {
+    const u = Math.pow(2, k - 23);
+    for (let t = 0; t < 150000; t++) {
+      const inv = asF32(0.25 + Math.random() * 500);
+      const x = asF32((Math.pow(2, k) - 0.5 + (Math.random() * 8 - 6) * u) / inv);
+      if (!(x >= 0)) continue;
+      const two = f32(f32(x * inv) + 0.5), fused = fmaF32Spec(x, inv, 0.5);
+      if (!Object.is(two, fused)) { raw++; if (Math.floor(two) !== Math.floor(fused)) fl++; }
+    }
+  }
+  ok(raw > 0 && fl === 0, `true-fma immunity: ${raw} last-ulp diffs at binade edges, ${fl} floor-visible`);
+}
+
 // ---- the actual point: is Verified.epi the spec, or just agreeable? ---------
 console.log("\nVerified.epi vs the oracle, over the range the kernels produce:");
 let mism = 0, n = 0;