@hviana/sema 0.8.3 → 0.8.5

package/test/135-one-law-any-producer.test.mjs

@@ -0,0 +1,289 @@
+// 135-one-law-any-producer.test.mjs — the law over REAL states, from different
+// producers, with the same verdicts.
+//
+// THE CLAIM THE EXTRACTION HAS TO EARN, and the one test/133 and test/134 do not
+// reach: composition means a product is consumable by ANY transition the law
+// admits, and the law never asks who produced it.  133 shows that over synthetic
+// states and one provenance label each; 134 shows it against the engine's own
+// refusal on ONE fixture.  This file takes the states the ENGINE actually
+// produced, across five fixtures whose winners are DIFFERENT mechanisms, and asks
+// the law about them:
+//
+//   • the winners must really span several mechanisms — otherwise nothing here is
+//     exercised;
+//   • for every fixture, the state's own published fields (the remainder's spans
+//     and bytes, the supplied fixed point) decide every continuation, and the
+//     verdicts follow the law's clauses and nothing else;
+//   • and re-labelling a state with every other mechanism's provenance changes NO
+//     verdict — the invariant, over real states rather than synthetic ones.
+//
+// The observed behaviour is then read back through the same law: a fixture that
+// was extended took a step the law admits, one that was stopped had a supplied
+// fixed point (FIXED), and one that was never extended had no continuation
+// offered.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+const law = await import("../dist/src/mind/derivation.js");
+const { Mind, SQliteStore } = await import("../dist/src/index.js");
+const enc = (s) => new TextEncoder().encode(s);
+const dec = (b) => new TextDecoder().decode(b).replace(/\s+/g, " ").trim();
+
+const FIVE = [
+  {
+    name: "join chain (test/120)",
+    pairs: (() => {
+      const F = [
+        "The director of Eva is Gustaf Molander.",
+        "The country of Gustaf Molander is Sweden.",
+        "The capital of Sweden is Stockholm.",
+        "The mayor of Stockholm is Karin Wanngard.",
+        "The party of Karin Wanngard is the Social Democrats.",
+      ];
+      const K = [
+        ["eva director", 0],
+        ["gustaf molander country", 1],
+        ["sweden capital", 2],
+        ["stockholm mayor", 3],
+        ["karin wanngard party", 4],
+      ];
+      const out = [];
+      for (const [key, i] of K) {
+        out.push([key.split(" ").slice(0, -1).join(" "), F[i]], [key, F[i]]);
+      }
+      return out;
+    })(),
+    query: "eva director country capital mayor party",
+  },
+  {
+    name: "nested completion (test/98)",
+    pairs: [["a", "p q"], ["p", "r"], ["q", "s"], ["r s", "m n"]],
+    query: "a",
+  },
+  {
+    name: "the brake (test/110)",
+    pairs: [
+      ["What is the capital of France", "The capital of France is Paris"],
+      ["Paris", "Paris is famous for the Eiffel Tower"],
+      ["the Eiffel Tower", "the Eiffel Tower is in Paris"],
+    ],
+    query: "What is the capital of France famous for",
+  },
+  {
+    name: "declared fixed point (test/100)",
+    pairs: [
+      ["How do I compile hello.c?", "Run gcc hello.c"],
+      ["How do I compile server.c?", "Run gcc server.c"],
+      ["How do I compile parser.c?", "Run gcc parser.c"],
+    ],
+    query: "How do I compile program.c?",
+  },
+  {
+    name: "two topics",
+    pairs: [
+      ["What is the capital of France", "The capital of France is Paris"],
+      ["Paris", "Paris is famous for the Eiffel Tower"],
+      ["2+2", "2+2 equals 4"],
+      ["Gustaf Molander", "Gustaf Molander was a Swedish film director"],
+    ],
+    query: "What is the capital of France? And what is 2 + 2?",
+  },
+];
+
+const WALK = new Set([
+  "pivotStep",
+  "absorbForward",
+  "pivotRefused",
+  "fuseAttention",
+]);
+
+async function observe(f) {
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store, profile: true });
+  await mind.ingest(f.pairs);
+  const steps = [];
+  const answer = String(await mind.respondText(f.query, (s) => steps.push(s)))
+    .trim();
+  // The winner's provenance is read from the POST-GROUNDING step, which every
+  // response emits.  It is deliberately NOT read from the decision payload: that
+  // step is `narrowDecision` (which carries only a margin) when the market held
+  // one candidate, so reading it left the producer null on two of these five
+  // fixtures -- and a `Set` of producers then counted that null as a producer,
+  // which is how an earlier version of this file passed for the wrong reason.
+  const pg = steps.filter((s) => s.data && s.data.fixed !== undefined).pop()
+    ?.data;
+  const counters = mind.lastCost?.counters ?? {};
+  const observed = {
+    name: f.name,
+    query: f.query,
+    answer,
+    provenance: pg?.provenance ?? null,
+    remainderSpans: pg?.remainderSpans ?? 0,
+    remainderBytes: pg?.remainderBytes ?? 0,
+    fixed: pg?.fixed === true,
+    walk: steps.map((s) => s.mechanism.at(-1)).filter((m) => WALK.has(m)),
+    pivotSteps: counters.pivotSteps ?? 0,
+    W: mind.space.maxGroup,
+  };
+  await store.close();
+  return observed;
+}
+
+test("135. the law decides real states the same way, whoever produced them", async () => {
+  const seen = [];
+  for (const f of FIVE) seen.push(await observe(f));
+
+  // (1) THE FIXTURES MUST EXERCISE SEVERAL PRODUCERS, or nothing below is a test.
+  assert.ok(
+    seen.every((o) => o.provenance !== null),
+    `every fixture must report its winner: got ${
+      JSON.stringify(seen.map((o) => o.provenance))
+    }`,
+  );
+  const producers = new Set(seen.map((o) => o.provenance));
+  assert.ok(
+    producers.size >= 3,
+    `the fixtures' winners must span several mechanisms, got ${
+      JSON.stringify([...producers])
+    }`,
+  );
+  // (1b) AND THE BRANCHES BELOW MUST FIRE.  A test whose every fixture fell
+  // through the same branch would pass while pinning one clause.
+  assert.ok(seen.some((o) => o.fixed), "one fixture must supply a fixed point");
+  assert.ok(
+    seen.some((o) => o.walk.includes("pivotRefused")),
+    "one fixture must show a refusal",
+  );
+  assert.ok(
+    seen.some((o) => o.remainderBytes > 0 && !o.fixed),
+    "one fixture must owe material and not be fixed",
+  );
+  assert.ok(
+    seen.some((o) => o.remainderBytes === 0 && !o.fixed),
+    "one fixture must be closed with no supplied fixed point",
+  );
+
+  // (2) THE STATE'S OWN FIELDS DECIDE, over the same battery for every fixture.
+  const battery = (o) => {
+    const query = enc(o.query);
+    const alien = enc("qqqqqqqqqqqqqqqq");
+    return {
+      carries: { product: query, contains: true, cost: 1 },
+      moves: { product: alien, contains: true, reaches: true, cost: 1 },
+      plain: { product: alien, contains: true, cost: 1 },
+      alien: { product: alien, contains: false, cost: 1 },
+    };
+  };
+  const stateOf = (o) => {
+    // The remainder as the fixture's own published counts describe it: the
+    // grounding accounts for the query's head and owes its tail.
+    assert.ok(
+      o.remainderSpans <= 1,
+      `${o.name}: this construction assumes at most one owed span, got ${o.remainderSpans}`,
+    );
+    const remainder = o.remainderBytes === 0
+      ? []
+      : [[o.query.length - o.remainderBytes, o.query.length]];
+    return {
+      product: enc(o.answer),
+      accounted: [],
+      remainder,
+      cost: 0,
+      fixed: o.fixed,
+    };
+  };
+  for (const o of seen) {
+    const query = enc(o.query);
+    const state = stateOf(o);
+    const conts = battery(o);
+    const closed = state.remainder.length === 0;
+    // the law's clauses, per fixture, on the fixture's own state
+    for (const [cn, t] of Object.entries(conts)) {
+      const verdict = law.admissible(state, t, query, o.W);
+      if (o.fixed) {
+        assert.equal(
+          verdict,
+          null,
+          `${o.name}: a supplied fixed point stops ${cn}`,
+        );
+        continue;
+      }
+      if (cn === "alien") {
+        assert.equal(
+          verdict,
+          null,
+          `${o.name}: identity comes before progress`,
+        );
+        continue;
+      }
+      if (closed) {
+        assert.notEqual(
+          verdict,
+          null,
+          `${o.name}: a closed state admits ${cn}`,
+        );
+        continue;
+      }
+      if (cn === "carries" || cn === "moves") {
+        assert.notEqual(verdict, null, `${o.name}: ${cn} is progress`);
+      } else {
+        assert.equal(
+          verdict,
+          null,
+          `${o.name}: ${cn} is neither progress nor closed`,
+        );
+      }
+    }
+
+    // (2b) COST IS NOT A TERM.  The law says the ladder is the ORDER, not a
+    // clause; a state's verdict must not move when its cost does.
+    for (const c of [0, 1, 1e6]) {
+      for (const [cn, t] of Object.entries(conts)) {
+        assert.deepEqual(
+          law.admissible({ ...state, cost: c }, t, query, o.W),
+          law.admissible(state, t, query, o.W),
+          `${o.name} x ${cn}: the verdict moved with the cost (${c})`,
+        );
+      }
+    }
+
+    // (3) RE-LABELLING CHANGES NOTHING, over real states this time.
+    for (const label of producers) {
+      const labelled = { ...state, provenance: label };
+      for (const [cn, t] of Object.entries(conts)) {
+        assert.deepEqual(
+          law.admissible(labelled, t, query, o.W),
+          law.admissible(state, t, query, o.W),
+          `${o.name} x ${cn}: the verdict changed under the label "${label}"`,
+        );
+      }
+    }
+  }
+
+  // (4) AND THE ENGINE'S OBSERVED WALK IS THE LAW'S CONSEQUENCE.
+  for (const o of seen) {
+    if (o.fixed) {
+      assert.deepEqual(
+        o.walk,
+        [],
+        `${o.name}: a supplied fixed point must stop the walk (saw ${o.walk})`,
+      );
+      continue;
+    }
+    if (o.walk.includes("pivotStep") || o.walk.includes("absorbForward")) {
+      assert.ok(
+        o.pivotSteps >= 1 || o.walk.includes("absorbForward"),
+        `${o.name}: a taken step must be one the meter counts`,
+      );
+    }
+    // a refusal, where it happened, is a step the law declined — and the fixture
+    // that has one is the one whose remainder is not empty
+    if (o.walk.includes("pivotRefused")) {
+      assert.ok(
+        o.remainderBytes > 0,
+        `${o.name}: a refusal implies there was material left to engage`,
+      );
+    }
+  }
+});

package/test/136-the-two-named-limits.test.mjs

@@ -0,0 +1,205 @@
+// 136-the-two-named-limits.test.mjs — the two sites the extraction LEAVES ALONE,
+// pinned so that changing them requires the measurement the report says is
+// missing.
+//
+// The investigation found two places where the architecture's own reading and
+// the code's reading differ, and the plan's rule is: register, prove, decide
+// whether it is a bug, decide whether it is a consequence, and ONLY THEN propose
+// a change.  Neither has been proven a bug, so neither was changed -- and these
+// two assertions exist so that the next person cannot change them by accident,
+// believing they are tidying up:
+//
+//   136.1 THE FUSE GATE KEEPS ITS OWN READING.  It decides with the TOTAL
+//   unaccounted bytes against one quantum, while the state's `remainder` is
+//   per-span by construction.  The two readings AGREE unless every gap is below
+//   one quantum and their sum is at or above it -- and that construction is what
+//   nobody has built, so switching the gate to the state's own `closed` would
+//   change an answer no one has measured.  The assertion therefore pins both
+//   halves: that the two readings DO differ on that construction (so the reason
+//   lives in the test and not only in a comment), and that the gate still uses
+//   the total.
+//
+//   136.2 THE EXTENSION IS NOT PRICED.  The reasoner reports what its steps cost
+//   and what they accounted for, and the caller never folds that into the
+//   decided candidate: the candidate's weight is the ladder formula alone.  This
+//   is a DIVERGENCE between the documented intent and the implementation, on
+//   purpose un-fixed: pricing it would change which grounding wins, and that
+//   comparison has not been measured.  The assertion pins the current arithmetic
+//   on a fixture where the walk really takes a step (guarded), so folding the
+//   cost in breaks it and forces the measurement.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const law = await import("../dist/src/mind/derivation.js");
+const { STEP, PASS } = await import("../dist/src/mind/graph-search.js");
+const { Mind, SQliteStore } = await import("../dist/src/index.js");
+
+test("136.1 the fuse gate asks the LAW — one condition, one home, one less sum", async () => {
+  // THE DISCRIMINATING CONSTRUCTION, from the law's own functions: a query whose
+  // accounted spans leave only sub-quantum gaps, whose SUM is at or above one
+  // quantum.  The two READINGS differ here — that is why the register kept them
+  // apart — and the question is whether the difference can reach a real response.
+  const W = 4;
+  const len = 12;
+  const explained = [[0, 3], [6, 9]];
+  const gaps = law.unexplainedSpans(len, explained);
+  assert.deepEqual(
+    gaps,
+    [[3, 6], [9, 12]],
+    "the construction must leave exactly the two sub-quantum gaps",
+  );
+  const total = law.unaccountedBytes(gaps);
+  const perSpan = law.remainderOf(len, explained, W);
+  assert.ok(
+    total >= W,
+    `on the raw spans the total reading opens: ${total} >= ${W}`,
+  );
+  assert.deepEqual(
+    perSpan,
+    [],
+    "and the per-span reading closes — the difference is real at this level",
+  );
+
+  // AND IT CANNOT REACH A RESPONSE, which 136.3 measures: the ACCOUNTING applies
+  // the same W floor, so a sub-quantum gap never survives into `explained`.  The
+  // gate therefore asks the law, and that is an OPTIMISATION and not a tidy-up —
+  // `remainderOf` is already computed for the state, while the total the gate used
+  // to sum (`unaccounted(explained)`) was one more pass over the spans per
+  // response, for the same answer.
+  const src = await readFile(
+    join(here, "..", "src", "mind", "pipeline.ts"),
+    "utf8",
+  );
+  assert.match(
+    src,
+    /const fused = closed\(state\)/,
+    "the fuse gate must ask the law's `closed(state)` — the condition the state " +
+      "already carries.  If it went back to summing `unaccounted(explained)`, that " +
+      "is a second reading of one condition AND an extra sum per response: 136.3 " +
+      "measures the equivalence, so re-read it before restoring the total",
+  );
+  assert.ok(
+    !/const remainder = unaccounted\(explained\);/.test(src),
+    "the total-bytes sum is back: the gate has two readings of one condition again",
+  );
+});
+
+test("136.2 the extension is not priced — and it pays for itself", async () => {
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store, profile: true });
+  await mind.ingest([
+    ["What is the capital of France", "The capital of France is Paris"],
+    ["Paris", "Paris is famous for the Eiffel Tower"],
+    ["the Eiffel Tower", "the Eiffel Tower is in Paris"],
+  ]);
+  const steps = [];
+  await mind.respondText(
+    "What is the capital of France famous for",
+    (s) => steps.push(s),
+  );
+  const counters = mind.lastCost?.counters ?? {};
+  const dg = steps.filter((s) => Array.isArray(s.data?.candidates)).pop()?.data;
+  const winner = dg?.candidates.find((c) => c.decided);
+  await store.close();
+
+  // THE VACUITY GUARD: the walk must really have taken a step, or the equality
+  // below would hold for a response that never extended anything.
+  assert.ok(
+    (counters.reasonSteps ?? 0) >= 1,
+    `the fixture must take at least one extension step, got ${counters.reasonSteps}`,
+  );
+  assert.ok(winner, "the response must publish its decided candidate");
+  // AND THE EXTENSION PAYS FOR ITSELF, measured: the walk's steps are answered by
+  // the material its witnesses carried, by orders of magnitude (this fixture takes
+  // ONE extension: 1 step against 11 bytes carried — 1 against 11000 in the one
+  // currency).  That is why no price DECISION is added for the extension: its
+  // warrant is already the closure law's (a step must engage the remainder or
+  // move), its cost is counted and reported (`reasonSteps`), and a second,
+  // price-shaped admission would be a second home for the same decision — one that
+  // would refuse the IDENTITY steps the law admits, which is the documented
+  // failure of the (c) remedy (material lost: "hot" for "cold hot").
+  assert.ok(
+    (counters.reasonCarriedBytes ?? 0) * PASS >
+      (counters.reasonSteps ?? 0) * STEP,
+    "the extension is carrying less than its steps are worth — measured 11 bytes " +
+      "against 1 step here.  If this ever fails, the absent price comparison HAS " +
+      "teeth and the register's GAP 2 is real: measure what pricing the extension " +
+      "does to the suite before touching this",
+  );
+  assert.equal(
+    winner.weight,
+    STEP + PASS * winner.unexplainedBytes,
+    "the winning candidate's weight is now something other than the ladder " +
+      "formula on its own accounting — most likely the extension's cost was " +
+      "folded in.  That is a behaviour change: measure what pricing the " +
+      "extension does to the suite's answers and counters, then update this test",
+  );
+});
+
+test("136.3 the gate's total and the law's per-span reading agree — measured, not argued", async () => {
+  // GAP 1 of the §22 register.  The two readings WOULD diverge if a gap below one
+  // quantum could survive into the accounting — a total >= W while every gap < W —
+  // and the register kept that as an unmeasured limit.  It is measured here and it
+  // does not happen: on every construction below the response either reports NO
+  // remainder or one whose gaps are each >= W, because the ACCOUNTING applies the
+  // same W floor the gate does.  Sub-quantum material between recognised spans sits
+  // INSIDE the composed spans, so it never becomes a gap; and material the cover
+  // cannot compose stays unrecognised in runs the recognition's own floor already
+  // treats as non-evidence.  The gate's total reading is therefore not a second,
+  // laxer condition: it is the same condition, which is what makes 136.1's source
+  // pin safe rather than a hazard.
+  const { Mind, SQliteStore } = await import("../dist/src/index.js");
+  const corpus = [
+    ["What is 2 + 2?", "What is 2 + 2? 4"],
+    ["What is 3 + 3?", "What is 3 + 3? 6"],
+    ["Paris", "Paris is the capital of France"],
+    ["Hamlet", "Hamlet was written by Shakespeare"],
+    ["Romeo", "Romeo loves Juliet"],
+    ["Macbeth", "Macbeth is a Scottish play"],
+  ];
+  const queries = [
+    "Paris,Hamlet,Romeo,Macbeth", // four 1-byte gaps: total 4 = W
+    "Paris; Hamlet; Romeo; Macbeth", // four 2-byte gaps: total 8
+    "Paris - Hamlet - Romeo - Macbeth", // four 3-byte gaps: total 12
+    "2+2, 3+3, 4+4", // sub-quantum separators inside a composition
+    "Paris and Hamlet and Romeo and Macbeth", // 5-byte gaps: a genuine remainder
+  ];
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store, profile: true });
+  await mind.ingest(corpus);
+  const W = mind.space.maxGroup;
+  let closed = 0;
+  let open = 0;
+  for (const q of queries) {
+    const steps = [];
+    await mind.respondText(q, (s) => steps.push(s));
+    const pg = steps.filter((s) => s.data && s.data.fixed !== undefined).pop()
+      ?.data;
+    const spans = pg?.remainderSpans ?? 0;
+    const bytes = pg?.remainderBytes ?? 0;
+    assert.equal(
+      bytes >= W,
+      spans > 0,
+      `${JSON.stringify(q)}: the gate's total reading says ${
+        bytes >= W ? "open" : "closed"
+      } ` +
+        `(${bytes} bytes vs W=${W}) while the law's per-span reading says ` +
+        `${
+          spans > 0 ? "open" : "closed"
+        } (${spans} spans) — they diverged, so the ` +
+        `accounting no longer applies the W floor and the gate IS a laxer second reading`,
+    );
+    if (bytes > 0) open++;
+    else closed++;
+  }
+  assert.ok(
+    open > 0 && closed > 0,
+    `the set must exercise both sides, got open=${open} closed=${closed}`,
+  );
+  await store.close();
+});