@hviana/sema 0.8.8 → 0.9.0

package/dist/src/meter.d.ts

@@ -184,6 +184,13 @@ export declare class Meter {
      *  route was priced out.  Counted where the fact happens (the `!canonBudget`
      *  refusal), not where the probe is called. */
     canonProbesDenied: number;
+    /** Spans the BLOOM claimed and the exact identity then refused — so `probe` used to
+     *  drop the span AND skip the decider.  `findFlatBranch` is bloom-gated on purpose (a
+     *  miss costs no database read), but a non-null answer means MAYBE; treating it as YES
+     *  is what made the canon route run only `if (flatProbe === null)`.  Counted where the
+     *  fact happens (a non-null bloom whose `resolveSpan` is null), so the price of letting
+     *  the canon route see those spans again is a measurement rather than a guess. */
+    bloomFalsePositives: number;
     /** The pipeline's remainder AT THE DECISION POINT, in bytes: what the grounded
      *  answer plus the pre-computed spans left unexplained, after the same W floor
      *  the fuse gate uses.  This is the quantity that licenses (or refuses) the

package/dist/src/meter.js

@@ -194,6 +194,13 @@ export class Meter {
      *  route was priced out.  Counted where the fact happens (the `!canonBudget`
      *  refusal), not where the probe is called. */
     canonProbesDenied = 0;
+    /** Spans the BLOOM claimed and the exact identity then refused — so `probe` used to
+     *  drop the span AND skip the decider.  `findFlatBranch` is bloom-gated on purpose (a
+     *  miss costs no database read), but a non-null answer means MAYBE; treating it as YES
+     *  is what made the canon route run only `if (flatProbe === null)`.  Counted where the
+     *  fact happens (a non-null bloom whose `resolveSpan` is null), so the price of letting
+     *  the canon route see those spans again is a measurement rather than a guess. */
+    bloomFalsePositives = 0;
     /** The pipeline's remainder AT THE DECISION POINT, in bytes: what the grounded
      *  answer plus the pre-computed spans left unexplained, after the same W floor
      *  the fuse gate uses.  This is the quantity that licenses (or refuses) the

package/dist/src/mind/recognition.js

@@ -518,7 +518,17 @@ function recogniseImpl(ctx, bytes) {
                 // emitted, so a caller can retry a trimmed edge on the miss path only.
                 if (end - start < W)
                     return false;
-                if (flatProbe(start, end) === null) {
+                // The byte-exact route is a BLOOM, so a non-null answer means MAYBE: it can neither
+                // decide (that is `resolveSpan`'s job) nor deny (that is `canonAdmits`').  Reading it
+                // as a YES made a false positive both drop the span and skip the decider, because the
+                // canon route ran only on a null.  Measured on the trained corpus: 280 spans where the
+                // bloom claimed and the identity refused.  A bloom HIT that resolves still emits
+                // without touching the canon route, which is what keeps the cheap path cheap.
+                const flat = flatProbe(start, end);
+                let id = flat === null ? null : resolveSpan(start, end);
+                if (id === null) {
+                    if (flat !== null && ctx.meter)
+                        ctx.meter.bloomFalsePositives++;
                     if (!canonBudget) {
                         if (ctx.meter)
                             ctx.meter.canonProbesDenied++;
@@ -526,8 +536,8 @@ function recogniseImpl(ctx, bytes) {
                     }
                     if (!canonAdmits(start, end))
                         return false;
+                    id = resolveSpan(start, end);
                 }
-                const id = resolveSpan(start, end);
                 if (id === null)
                     return false;
                 emit(start, end, id);
@@ -600,12 +610,21 @@ function recogniseImpl(ctx, bytes) {
             // keeps this off the quadratic path the budget note above describes (that
             // one had no span bound at all).
             {
-                // The span bound is W^2, the chain's own limit, PLUS the slack the endpoint set already grants: every endpoint
-                // sits within `radius` of a cut, so a pair that names one form may straddle cuts and still be a single form's
-                // span.  Measured on the composite fixture: W=4 (reach 16), radius 8, and the useful [7,32) is 25 bytes with its
-                // edges 2 bytes from cuts 5 and 30 — already IN `ordered`, and excluded only by the upper bound.  Both terms are
+                // The span bound is the chain's own limit PLUS the slack the endpoint set already grants: every endpoint sits
+                // within `radius` of a cut, so a pair that names one form may straddle cuts and still be a single form's span.
+                // Measured on the composite fixture: W=4 (reach 16), radius 8, and the useful [7,32) is 25 bytes with its edges
+                // 2 bytes from cuts 5 and 30 — already IN `ordered`, and excluded only by the upper bound.  Both terms are
                 // derived (W and the seat count); no new constant enters.
-                const reach = chainReach(W) + 2 * radius;
+                //
+                // The chain term is W^2 * W = W^4, for a form embedded in the MIDDLE of a longer query.  Measured on the
+                // trained corpus, the SAME real contexts in three positions: opening 12/17, MIDDLE 0/17, end 12/17.  The two
+                // edge scans reach only prefixes and suffixes, so the interior pass is the only tier that could name it, and
+                // at W^2 it could not.  WHAT KEEPS THIS LINEAR IS THE BOUND BEING A CONSTANT — each endpoint pairs only with
+                // the partners inside a fixed window, so the work stays O(n).  Measured against a cut-pair enumeration with
+                // ±W trims (an earlier, 43-line attempt): that one reached the same 136 B at 70 888 probes, this one at
+                // 84 169 (x1.19 more) — and BOTH pass test/14, which gates the CLASS (linear) and not the constant.  The
+                // simpler form won on that measurement.
+                const reach = chainReach(W) * W * W + 2 * radius;
                 if (ctx.meter)
                     ctx.meter.recogniseInteriorGaps += ordered.length;
                 for (const end of ordered) {

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.9.0",
   "exports": "./src/index.ts"
 }

package/package.json

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

package/src/meter.ts

@@ -252,6 +252,13 @@ export class Meter {
    *  route was priced out.  Counted where the fact happens (the `!canonBudget`
    *  refusal), not where the probe is called. */
   canonProbesDenied = 0;
+  /** Spans the BLOOM claimed and the exact identity then refused — so `probe` used to
+   *  drop the span AND skip the decider.  `findFlatBranch` is bloom-gated on purpose (a
+   *  miss costs no database read), but a non-null answer means MAYBE; treating it as YES
+   *  is what made the canon route run only `if (flatProbe === null)`.  Counted where the
+   *  fact happens (a non-null bloom whose `resolveSpan` is null), so the price of letting
+   *  the canon route see those spans again is a measurement rather than a guess. */
+  bloomFalsePositives = 0;
   /** The pipeline's remainder AT THE DECISION POINT, in bytes: what the grounded
    *  answer plus the pre-computed spans left unexplained, after the same W floor
    *  the fuse gate uses.  This is the quantity that licenses (or refuses) the

package/src/mind/recognition.ts

@@ -534,14 +534,23 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
         // pass below spends the same budget on those pairs.  Returns whether it
         // emitted, so a caller can retry a trimmed edge on the miss path only.
         if (end - start < W) return false;
-        if (flatProbe(start, end) === null) {
+        // The byte-exact route is a BLOOM, so a non-null answer means MAYBE: it can neither
+        // decide (that is `resolveSpan`'s job) nor deny (that is `canonAdmits`').  Reading it
+        // as a YES made a false positive both drop the span and skip the decider, because the
+        // canon route ran only on a null.  Measured on the trained corpus: 280 spans where the
+        // bloom claimed and the identity refused.  A bloom HIT that resolves still emits
+        // without touching the canon route, which is what keeps the cheap path cheap.
+        const flat = flatProbe(start, end);
+        let id = flat === null ? null : resolveSpan(start, end);
+        if (id === null) {
+          if (flat !== null && ctx.meter) ctx.meter.bloomFalsePositives++;
           if (!canonBudget) {
             if (ctx.meter) ctx.meter.canonProbesDenied++;
             return false;
           }
           if (!canonAdmits(start, end)) return false;
+          id = resolveSpan(start, end);
         }
-        const id = resolveSpan(start, end);
         if (id === null) return false;
         emit(start, end, id);
         return true;
@@ -610,12 +619,21 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
       // keeps this off the quadratic path the budget note above describes (that
       // one had no span bound at all).
       {
-        // The span bound is W^2, the chain's own limit, PLUS the slack the endpoint set already grants: every endpoint
-        // sits within `radius` of a cut, so a pair that names one form may straddle cuts and still be a single form's
-        // span.  Measured on the composite fixture: W=4 (reach 16), radius 8, and the useful [7,32) is 25 bytes with its
-        // edges 2 bytes from cuts 5 and 30 — already IN `ordered`, and excluded only by the upper bound.  Both terms are
+        // The span bound is the chain's own limit PLUS the slack the endpoint set already grants: every endpoint sits
+        // within `radius` of a cut, so a pair that names one form may straddle cuts and still be a single form's span.
+        // Measured on the composite fixture: W=4 (reach 16), radius 8, and the useful [7,32) is 25 bytes with its edges
+        // 2 bytes from cuts 5 and 30 — already IN `ordered`, and excluded only by the upper bound.  Both terms are
         // derived (W and the seat count); no new constant enters.
-        const reach = chainReach(W) + 2 * radius;
+        //
+        // The chain term is W^2 * W = W^4, for a form embedded in the MIDDLE of a longer query.  Measured on the
+        // trained corpus, the SAME real contexts in three positions: opening 12/17, MIDDLE 0/17, end 12/17.  The two
+        // edge scans reach only prefixes and suffixes, so the interior pass is the only tier that could name it, and
+        // at W^2 it could not.  WHAT KEEPS THIS LINEAR IS THE BOUND BEING A CONSTANT — each endpoint pairs only with
+        // the partners inside a fixed window, so the work stays O(n).  Measured against a cut-pair enumeration with
+        // ±W trims (an earlier, 43-line attempt): that one reached the same 136 B at 70 888 probes, this one at
+        // 84 169 (x1.19 more) — and BOTH pass test/14, which gates the CLASS (linear) and not the constant.  The
+        // simpler form won on that measurement.
+        const reach = chainReach(W) * W * W + 2 * radius;
         if (ctx.meter) ctx.meter.recogniseInteriorGaps += ordered.length;
         for (const end of ordered) {
           for (const start of ordered) {

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",
+  );
+});