@hviana/sema 0.8.8 → 0.8.9

package/dist/src/mind/recognition.js

@@ -620,6 +620,59 @@ function recogniseImpl(ctx, bytes) {
                         spend(start, end);
                     }
                 }
+                // ── THE MIDDLE WAS BLIND: a CUT-PAIR probe, BOUNDED so it stays LINEAR ──────────────
+                // A stored form embedded in the MIDDLE of a longer query was named by NO tier: the two
+                // edge scans probe only prefixes and suffixes, and the loop above is capped at
+                // `reach` = W^2 + 2*radius.  Measured on the trained corpus, the SAME real contexts in
+                // three positions: opening 12/17, MIDDLE 0/17, end 12/17.  Both edges of such a form sit
+                // within `radius` of CUTS, so a cut pair plus a small trim names the form exactly
+                // (measured: a 64 B form at [27, 91) between cuts 26 and 90, trims +1/+1).
+                //
+                // THE BOUND IS WHAT KEEPS IT LINEAR.  An unbounded cut-pair scan is O(cuts^2) probes, and
+                // test/14 rejected exactly that (47 324 ms).  Bounded by a CONSTANT span it is
+                // O(cuts * const) = O(n), like the loop above — the constant is merely larger.  The bound
+                // is DERIVED, never pinned: `chainReach(W)` is W^2, "the deepest two-level composite the
+                // write side's windows can spell" (canonical.ts), so `chainReach(W) * W * W` is the
+                // four-level one; `chainReach(W) * W` is already used in bridge.ts.
+                //
+                // THE TRIMS ARE THE SAME DISCIPLINE THE EDGE SCANS USE — the suffix scan already probes
+                // `spend(s, bytes.length - 1)`, so ±W is a wider version of an existing rule, not a new
+                // threshold.  Measured price/reach; all four configurations pass test/14, which gates the
+                // CLASS (linear) and not the constant:
+                //   W^3 + ±1  -> 64 B,   8 068 probes (x2.02)
+                //   W^4 + ±W  -> 136 B, 70 888 probes (x6.06)   <- this one
+                //   W^3 + ±W and W^4 + ±1 are DOMINATED: each stops at the other parameter and costs more.
+                // The loop above stays, so no candidate that produces a site today is lost.  Suite
+                // 707/707, and a differential over 24 real corpus questions is byte-identical (0 answers
+                // changed, 0 new duplicate sites): the :258 warning that a wider bound can rediscover a
+                // smaller subtree's content as a second, overlapping site was read and measured, and it
+                // does not materialise here.
+                const deepReach = chainReach(W) * W * W;
+                for (let ci = 0; ci + 1 < startList.length; ci++) {
+                    for (let cj = ci + 1; cj < startList.length; cj++) {
+                        if (startList[cj] - startList[ci] > deepReach + 2 * radius)
+                            break;
+                        // The EXACT cut pair first.  Measured: with the 81 trims starting at -W the `spend`
+                        // pool ran dry (canonProbesDenied in the millions) and the canon route was then denied
+                        // to the candidates that needed it — including forms the byte-exact route SEES
+                        // (`flatProbe` true) that were still not named.  Probing (ci, cj) before any trim puts
+                        // the common case in front of the famine.
+                        if (ctx.meter)
+                            ctx.meter.recogniseInteriorPairs++;
+                        spend(startList[ci], startList[cj]);
+                        for (let dl = -W; dl <= W; dl++) {
+                            for (let dr = -W; dr <= W; dr++) {
+                                const a = startList[ci] + dl;
+                                const z = startList[cj] + dr;
+                                if (a < 0 || z > bytes.length || z - a < W)
+                                    continue;
+                                if (ctx.meter)
+                                    ctx.meter.recogniseInteriorPairs++;
+                                spend(a, z);
+                            }
+                        }
+                    }
+                }
             }
         }
     }

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://jsr.io/schema/config-file.v1.json",
   "name": "@hviana/sema",
-  "version": "0.8.8",
+  "version": "0.8.9",
   "exports": "./src/index.ts"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.8.8",
+  "version": "0.8.9",
   "description": "Sema: a non-parametric, instance-based reasoning system.",
   "repository": {
     "type": "git",

package/src/mind/recognition.ts

@@ -626,6 +626,55 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
             spend(start, end);
           }
         }
+        // ── THE MIDDLE WAS BLIND: a CUT-PAIR probe, BOUNDED so it stays LINEAR ──────────────
+        // A stored form embedded in the MIDDLE of a longer query was named by NO tier: the two
+        // edge scans probe only prefixes and suffixes, and the loop above is capped at
+        // `reach` = W^2 + 2*radius.  Measured on the trained corpus, the SAME real contexts in
+        // three positions: opening 12/17, MIDDLE 0/17, end 12/17.  Both edges of such a form sit
+        // within `radius` of CUTS, so a cut pair plus a small trim names the form exactly
+        // (measured: a 64 B form at [27, 91) between cuts 26 and 90, trims +1/+1).
+        //
+        // THE BOUND IS WHAT KEEPS IT LINEAR.  An unbounded cut-pair scan is O(cuts^2) probes, and
+        // test/14 rejected exactly that (47 324 ms).  Bounded by a CONSTANT span it is
+        // O(cuts * const) = O(n), like the loop above — the constant is merely larger.  The bound
+        // is DERIVED, never pinned: `chainReach(W)` is W^2, "the deepest two-level composite the
+        // write side's windows can spell" (canonical.ts), so `chainReach(W) * W * W` is the
+        // four-level one; `chainReach(W) * W` is already used in bridge.ts.
+        //
+        // THE TRIMS ARE THE SAME DISCIPLINE THE EDGE SCANS USE — the suffix scan already probes
+        // `spend(s, bytes.length - 1)`, so ±W is a wider version of an existing rule, not a new
+        // threshold.  Measured price/reach; all four configurations pass test/14, which gates the
+        // CLASS (linear) and not the constant:
+        //   W^3 + ±1  -> 64 B,   8 068 probes (x2.02)
+        //   W^4 + ±W  -> 136 B, 70 888 probes (x6.06)   <- this one
+        //   W^3 + ±W and W^4 + ±1 are DOMINATED: each stops at the other parameter and costs more.
+        // The loop above stays, so no candidate that produces a site today is lost.  Suite
+        // 707/707, and a differential over 24 real corpus questions is byte-identical (0 answers
+        // changed, 0 new duplicate sites): the :258 warning that a wider bound can rediscover a
+        // smaller subtree's content as a second, overlapping site was read and measured, and it
+        // does not materialise here.
+        const deepReach = chainReach(W) * W * W;
+        for (let ci = 0; ci + 1 < startList.length; ci++) {
+          for (let cj = ci + 1; cj < startList.length; cj++) {
+            if (startList[cj] - startList[ci] > deepReach + 2 * radius) break;
+            // The EXACT cut pair first.  Measured: with the 81 trims starting at -W the `spend`
+            // pool ran dry (canonProbesDenied in the millions) and the canon route was then denied
+            // to the candidates that needed it — including forms the byte-exact route SEES
+            // (`flatProbe` true) that were still not named.  Probing (ci, cj) before any trim puts
+            // the common case in front of the famine.
+            if (ctx.meter) ctx.meter.recogniseInteriorPairs++;
+            spend(startList[ci], startList[cj]);
+            for (let dl = -W; dl <= W; dl++) {
+              for (let dr = -W; dr <= W; dr++) {
+                const a = startList[ci] + dl;
+                const z = startList[cj] + dr;
+                if (a < 0 || z > bytes.length || z - a < W) continue;
+                if (ctx.meter) ctx.meter.recogniseInteriorPairs++;
+                spend(a, z);
+              }
+            }
+          }
+        }
       }
     }
   }

package/test/186-embedded-middle.test.mjs

@@ -0,0 +1,101 @@
+// 186-embedded-middle.test.mjs — the CUT-PAIR probe of `recognise`: a stored form in the MIDDLE of a query.
+//
+// THE CAPABILITY.  A stored form embedded in the MIDDLE of a longer question is named, and its continuation is
+// answered.  No tier reached it before: the two edge scans probe only prefixes and suffixes (`spend(0, prefixes[i])`,
+// `spend(s, bytes.length)`), and the interior pass was capped at `reach` = W^2 + 2*radius.  Measured on the trained
+// corpus, the SAME real contexts in three positions: opening 12/17, MIDDLE 0/17, end 12/17.
+//
+// HOW.  `startList` already holds the content-defined cuts, and both edges of such a form sit within `radius` of a
+// cut.  The probe therefore pairs CUTS — the exact pair first, then a ±W trim — under a constant span bound derived
+// from W (`chainReach(W) * W * W`, never a pinned number).  The bound is what keeps it linear: an unbounded cut-pair
+// scan is O(cuts^2) and test/14 rejects it.
+//
+// WHAT THIS FILE PINS: the recognition and the ANSWER at all three positions, that an unstored form is still refused
+// (the negative control that keeps the middle assertions from passing for the wrong reason), and the determinism of
+// the reading.  NOT magnitudes — those are a cost matter with its own measurement in test/14.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Mind } from "../dist/src/index.js";
+import { SQliteStore } from "../dist/src/store-sqlite.js";
+import { recognise } from "../dist/src/mind/recognition.js";
+
+const dec = new TextDecoder();
+// 64 B, so the form is TWICE `reach` (W^2 + 2*radius) — the dead zone the cut-pair probe exists to close.
+const FORM = "the painter was born in Verano and the river runs through Verano";
+const CONTINUATION = "that region is Calenta";
+const OTHER = "the harbour master";
+const OTHER_CONTINUATION = "the harbour is at Kestrel";
+
+async function mind() {
+  const m = new Mind({
+    seed: 7,
+    store: new SQliteStore({ path: ":memory:" }),
+    profile: true,
+  });
+  await m.ingest([
+    [FORM, CONTINUATION],
+    [OTHER, OTHER_CONTINUATION],
+  ]);
+  return m;
+}
+
+function named(m, query, form) {
+  const bytes = new TextEncoder().encode(query);
+  return recognise(m, bytes).sites.some((s) =>
+    dec.decode(bytes.subarray(s.start, s.end)) === form
+  );
+}
+
+test("recognise(): a stored form EMBEDDED IN THE MIDDLE of a longer query is named", async () => {
+  const m = await mind();
+  const query = `I ask: ${OTHER}, ${FORM}, and the note is filed.`;
+  assert.equal(named(m, query, FORM), true);
+});
+
+test("the middle form is ANSWERED with its own continuation, not the surrounding fact's", async () => {
+  const m = await mind();
+  const answer = String(
+    await m.respondText(
+      `I ask: ${OTHER}, ${FORM}, and the note is filed.`,
+      () => {},
+    ),
+  );
+  assert.match(answer, /Calenta/);
+});
+
+test("the same form at the OPENING and at the END is still named — the edge tiers did not regress", async () => {
+  const m = await mind();
+  assert.equal(named(m, `${FORM}, and the note is filed.`, FORM), true);
+  assert.equal(named(m, `I ask: ${OTHER}, and ${FORM}.`, FORM), true);
+});
+
+test("an UNSTORED form is still refused in the middle — the assertion above is not vacuous", async () => {
+  const m = await mind();
+  // Same LENGTH by construction (one word swapped), and never deposited: the middle assertions must not
+  // pass merely because some longer span happens to cover the region.
+  const unstored = FORM.replace("painter", "sculpto");
+  assert.equal(
+    unstored.length,
+    FORM.length,
+    "the control must be the same size as the form",
+  );
+  assert.notEqual(unstored, FORM);
+  assert.equal(
+    named(m, `I ask: ${OTHER}, ${unstored}, and the note is filed.`, unstored),
+    false,
+  );
+});
+
+test("the reading is deterministic, and the interior counter is wired", async () => {
+  const first = await mind();
+  const second = await mind();
+  const query = `I ask: ${OTHER}, ${FORM}, and the note is filed.`;
+  const a = String(await first.respondText(query, () => {}));
+  const b = String(await second.respondText(query, () => {}));
+  assert.equal(a, b);
+  const counters = first.lastCost?.counters ?? {};
+  assert.ok(
+    (counters.recogniseInteriorPairs ?? 0) > 0,
+    "recogniseInteriorPairs must be wired",
+  );
+});