gdp-wired 0.10.0 → 0.11.0

package/dist/kernel/prove.js

@@ -1,5 +1,5 @@
-import { add, k, scale, solve, sub, v } from "../core/solver.js";
-import { assumed, canon, columnTerm, decided, stepZone, check, checkLaws, checkStepLaws, historyMachine, leafConstraints, linear, livenessHelpful, livenessParts, obligations, plainKey, progressObligations, stepLawObligations, trueC, truth, unreachable, withProducts } from "./kernel.js";
+import { add, k, refuteFast, scale, solve, sub, v } from "../core/solver.js";
+import { assumed, canon, canonFlip, columnTerm, decided, stepZone, check, checkLaws, checkStepLaws, historyMachine, leafConstraints, leafConstraintsReusing, reusing, linear, livenessHelpful, livenessParts, obligations, plainKey, progressObligations, stepLawObligations, trueC, truth, unreachable, withProducts } from "./kernel.js";
 // The atoms the path leaves open, in evaluation order: deciding any of them makes progress.
 function openE(e, path, out) {
     switch (e.op) {
@@ -38,17 +38,18 @@ function openC(c, path, out) {
         return openC(c.x, path, out);
     if (c.op === 'and' || c.op === 'or')
         return c.xs.forEach(y => openC(y, path, out));
-    openE(c.a, path, out), openE(c.b, path, out);
-    const a = linear(c.a, path), b = linear(c.b, path);
+    const a = linear(c.a, path), b = linear(c.b, path), own = [];
     if (a && b) {
         const d = sub(a, b);
         if (c.op === '<=')
-            out.push(d);
+            own.push(d);
         else if (c.op === '<')
-            out.push(add(d, k(1)));
+            own.push(add(d, k(1)));
         else
-            out.push(d, scale(d, -1));
+            own.push(d, scale(d, -1));
     }
+    openE(c.a, path, out), openE(c.b, path, out);
+    out.push(...own);
 }
 // A hypothesis is settled when it gives facts that are all its content: here, when its truth is decided, or it is a
 // conjunction of settled parts / a linear comparison. A disjunction is settled only once one disjunct is left open and
@@ -85,7 +86,7 @@ function openCells(rows, path) {
             if (p.slice(0, p.indexOf('[')) !== q.slice(0, q.indexOf('[')))
                 continue;
             const d = sub(parse(keyText(p)), parse(keyText(q)));
-            const dec = (lin) => path.get(canon(lin))?.holds ?? (path.has(canon(add(k(1), scale(lin, -1)))) ? !path.get(canon(add(k(1), scale(lin, -1)))).holds : undefined);
+            const dec = (lin) => path.get(canon(lin))?.holds ?? (path.has(canonFlip(lin)) ? !path.get(canonFlip(lin)).holds : undefined);
             const a = dec(d), b = dec(scale(d, -1));
             if (a === undefined)
                 out.push(d);
@@ -113,9 +114,40 @@ function parse(text) {
     }
     return out;
 }
+// Where a goal's time goes, when asked (research/perf/prover-bench.ts): each root goal's time, nodes, solver calls and
+// the time in the solver and in building rows. Off unless `profile.on`; the counters cost nothing then.
+export const profile = { on: false, goals: [], solves: 0, solveMs: 0, rowsMs: 0, nodes: 0 };
+const timed = (f, add) => { if (!profile.on)
+    return f(); const t = performance.now(); try {
+    return f();
+}
+finally {
+    add(performance.now() - t);
+} };
+export const solveKinds = {};
+const solveP = (rows, maxRows) => {
+    if (!profile.on)
+        return solve(rows, maxRows);
+    const t = performance.now(), out = solve(rows, maxRows), ms = performance.now() - t;
+    profile.solves++;
+    profile.solveMs += ms;
+    const s = (solveKinds[out.kind] ??= { n: 0, ms: 0, rows: 0 });
+    s.n++;
+    s.ms += ms;
+    s.rows += rows.length;
+    return out;
+};
 // The budget: 200,000 nodes and, by default, a second per hypothesis (at least 20 seconds) per goal; past either the goal
 // is left `unknown`. A goal with many instances (a law about two keys at its pairs) has that many more rows per leaf.
 export function grow(goal, path = new Map(), budget = { nodes: 0, until: performance.now() + Math.max(20_000, 1_000 * goal.hyps.length) }) {
+    if (!profile.on || path.size || budget.nodes)
+        return growRoot(goal, path, budget);
+    const t = performance.now(), s0 = profile.solves, m0 = profile.solveMs, r0 = profile.rowsMs, n0 = profile.nodes;
+    const out = growRoot(goal, path, budget);
+    profile.goals.push({ name: goal.name, ms: performance.now() - t, nodes: profile.nodes - n0, solves: profile.solves - s0, solveMs: profile.solveMs - m0, rowsMs: profile.rowsMs - r0, proven: 'tree' in out });
+    return out;
+}
+function growRoot(goal, path, budget) {
     // At the root: plainly first; where the cases multiply past a budget, through cuts. The plain budget halves with each
     // two open choices (what a plain search's cases grow by), so a long run's steps reach the cuts early.
     if (path.size === 0 && budget.nodes === 0) {
@@ -132,24 +164,47 @@ export function grow(goal, path = new Map(), budget = { nodes: 0, until: perform
 function growPlain(goal, path, budget) {
     if (budget.cap !== undefined && budget.nodes >= budget.cap)
         return { stuck: 'unknown', path, why: 'cap' };
+    if (profile.on)
+        profile.nodes++;
     if (++budget.nodes > 200_000 || (budget.until !== undefined && performance.now() > budget.until))
         return { stuck: 'unknown', path, why: outOfBudget(goal, budget.nodes > 200_000 ? 'nodes' : 'time', path.size) };
     // Rows that read a term column only once a cut has put one on the path; before, the rows a choice-free search uses
     // (what it saw before term columns), renumbered to the whole leaf's when a leaf is found.
-    const full = leafConstraints(goal, path);
+    const full = timed(() => leafConstraintsReusing(goal, path), ms => { profile.rowsMs += ms; });
     const columns = [...path.values()].some(a => Object.keys(a.lin).some(key => key.startsWith('⟦')));
     const idx = full.flatMap((r, i) => (columns || !Object.keys(r.lin).some(key => key.startsWith('⟦')) ? [i] : []));
     const rows = idx.map(i => full[i]), at = (i) => (i < rows.length ? idx[i] : full.length + i - rows.length);
     const leafOf = (steps, products) => ({ leaf: steps.map(st => (st.kind === 'input' ? { ...st, index: at(st.index) } : st)), ...(products ? { products: products.map(([i, j]) => [at(i), at(j)]) } : {}) });
-    const verdict = solve(rows);
-    if (verdict.kind === 'refuted')
-        return { tree: leafOf(verdict.steps), nodes: budget.nodes };
+    // The conclusion's own atoms first (the goal's last hypothesis is the law refuted): a case it doesn't read is often
+    // one no refutation needs, and splitting it first multiplies every case after it.
     const open = [];
-    for (const h of goal.hyps)
-        openH(h, path, open);
+    const hyps = goal.hyps, last = hyps.length - 1;
+    let byHyp = openSeen.get(goal);
+    if (!byHyp)
+        openSeen.set(goal, (byHyp = new Map()));
+    const openOf = (h) => { let seen = byHyp.get(h); if (!seen)
+        byHyp.set(h, (seen = [])); return reusing(seen, path, p => { const out = []; openH(h, p, out); return out; }); };
+    if (last >= 0)
+        open.push(...openOf(hyps[last]));
+    for (const [i, h] of hyps.entries())
+        if (i !== last)
+            open.push(...openOf(h));
     open.push(...openCells(rows, path));
-    let split = open.find(lin => Object.keys(lin).some(key => key !== '1') && !path.has(canon(lin)) && !path.has(canon(add(k(1), scale(lin, -1)))))
-        ?? (verdict.kind === 'unknown' ? bisect(rows, path) ?? fractional(verdict.point, path) : undefined);
+    const next = open.find(lin => Object.keys(lin).some(key => key !== '1') && !path.has(canon(lin)) && !path.has(canonFlip(lin)));
+    // With a case still to split, only "refuted or not" matters (a witness here goes unused): a large system is tried by
+    // its Farkas rows alone, and left to the split if they don't refute it. Elimination to the last variable, which a
+    // satisfiable system needs to say so, is kept for small systems and for the leaves, where its answer is the outcome.
+    // Past the Farkas rows, elimination still runs, bounded (a refutation the rationals miss is an integer one, which
+    // elimination's cuts find early; a satisfiable system grows past the bound and is left to the split).
+    if (next && rows.length > 60) {
+        const fast = timed(() => refuteFast(rows), ms => { profile.solves++; profile.solveMs += ms; });
+        if (fast?.kind === 'refuted')
+            return { tree: leafOf(fast.steps), nodes: budget.nodes };
+    }
+    const verdict = next && rows.length > 60 ? solveP(rows, 2 * rows.length) : solveP(rows);
+    if (verdict.kind === 'refuted')
+        return { tree: leafOf(verdict.steps), nodes: budget.nodes };
+    let split = next ?? (verdict.kind === 'unknown' ? bisect(rows, path) ?? fractional(verdict.point, path) : undefined);
     // Products: with monomials about, try every pair of rows multiplied; failing that, split a factor at zero.
     const monomials = rows.some(r => Object.keys(r.lin).some(key => key.includes('*')));
     // A witness that multiplies out (each monomial's value is its factors' product) is a real model: nothing to refute.
@@ -184,7 +239,7 @@ function growPlain(goal, path, budget) {
                 return { tree: leafOf(third.steps, [...sq, ...cubes]), nodes: budget.nodes };
         }
         const factors = [...new Set(rows.flatMap(r => Object.keys(r.lin).filter(key => key.includes('*')).flatMap(key => key.split('*'))))];
-        const fresh = (lin) => !path.has(canon(lin)) && !path.has(canon(add(k(1), scale(lin, -1))));
+        const fresh = (lin) => !path.has(canon(lin)) && !path.has(canonFlip(lin));
         // Split a factor at zero, else two factors against each other (so (x - y)² >= 0 becomes a product of rows).
         const zero = factors.find(f => fresh({ [f]: 1 }));
         const apart = factors.flatMap((f, i) => factors.slice(i + 1).map(g => ({ [f]: 1, [g]: -1 }))).find(fresh);
@@ -199,11 +254,62 @@ function growPlain(goal, path, budget) {
     const yes = growPlain(goal, new Map(path).set(id, { lin: split, holds: true }), budget);
     if (!('tree' in yes))
         return yes;
+    // A refutation of the yes side that never reads the split refutes the case as it stands: the other side is skipped.
+    const lifted = lift(goal, yes.tree, new Map(path).set(id, { lin: split, holds: true }), path);
+    if (lifted)
+        return { tree: lifted, nodes: budget.nodes };
     const no = growPlain(goal, new Map(path).set(id, { lin: split, holds: false }), budget);
     if (!('tree' in no))
         return no;
     return { tree: { split, yes: yes.tree, no: no.tree }, nodes: budget.nodes };
 }
+// A tree found under one more decision (`from`, the path with it) as a tree under the path without it (`to`), if no
+// leaf reads the decision: each leaf's rows found again among the rows the shorter path gives (the same rows, renumbered:
+// the decision's own row, and any row only it makes, are not there), every split kept. The derivations are the same
+// arithmetic over the same rows, and the kernel checks the whole tree in the end. Undefined at the first leaf that
+// needs the decision.
+function lift(goal, tree, from, to) {
+    const own = to.size; // the decision's row: the last of `from`'s path rows, below every later split's
+    const reads = (t) => ('leaf' in t ? t.leaf.some(st => st.kind === 'input' && st.index === own) || (t.products ?? []).some(([i, j]) => i === own || j === own) : reads(t.yes) || reads(t.no));
+    if (reads(tree))
+        return undefined;
+    const go = (t, a, b) => {
+        if (!('leaf' in t)) {
+            const sid = canon(t.split);
+            if (b.has(sid) || b.has(canonFlip(t.split)))
+                return undefined;
+            const yes = go(t.yes, new Map(a).set(sid, { lin: t.split, holds: true }), new Map(b).set(sid, { lin: t.split, holds: true }));
+            const no = yes && go(t.no, new Map(a).set(sid, { lin: t.split, holds: false }), new Map(b).set(sid, { lin: t.split, holds: false }));
+            return yes && no ? { split: t.split, yes, no } : undefined;
+        }
+        const ra = leafConstraintsReusing(goal, a), rb = leafConstraintsReusing(goal, b), at = new Map();
+        rb.forEach((r, i) => { const key = canon(r.lin); if (!at.has(key))
+            at.set(key, i); });
+        const map = (i) => (i < ra.length ? at.get(canon(ra[i].lin)) : undefined);
+        const leaf = [];
+        for (const st of t.leaf) {
+            if (st.kind !== 'input') {
+                leaf.push(st);
+                continue;
+            }
+            const j = map(st.index);
+            if (j === undefined)
+                return undefined;
+            leaf.push({ ...st, index: j });
+        }
+        const products = [];
+        for (const [i, j] of t.products ?? []) {
+            const pi = map(i), pj = map(j);
+            if (pi === undefined || pj === undefined)
+                return undefined;
+            products.push([pi, pj]);
+        }
+        return { leaf, ...(t.products ? { products } : {}) };
+    };
+    return go(tree, from, to);
+}
+// Each hypothesis' open atoms, as at an earlier path that decided the same atoms it reads (kernel.ts's reusing).
+const openSeen = new WeakMap();
 // What ran out, for a goal left unknown: its size, how deep the case splits went, and the two shapes that usually cause it.
 function outOfBudget(goal, limit, depth) {
     const steps = Number(/@(\d+) steps/.exec(goal.name)?.[1] ?? 1);
@@ -259,7 +365,7 @@ function topAtoms(c, path) {
     if (!a || !b)
         return [];
     const atoms = c.op === '<=' ? [sub(a, b)] : c.op === '<' ? [add(sub(a, b), k(1))] : [sub(a, b), sub(b, a)];
-    return atoms.filter(l => Object.keys(l).some(key => key !== '1') && !path.has(canon(l)) && !path.has(canon(add(k(1), scale(l, -1)))));
+    return atoms.filter(l => Object.keys(l).some(key => key !== '1') && !path.has(canon(l)) && !path.has(canonFlip(l)));
 }
 // A refutation that splits only on these atoms (a cut's failing side), within a small budget.
 function growFocused(goal, path, focus, budget, near = focus) {
@@ -268,7 +374,7 @@ function growFocused(goal, path, focus, budget, near = focus) {
     const verdict = solveNear(leafConstraints(goal, path), [...near, ...[...path.values()].slice(-1).map(a => a.lin)]);
     if (verdict.kind === 'refuted')
         return { tree: { leaf: verdict.steps }, nodes: budget.nodes };
-    const split = focus.find(l => !path.has(canon(l)) && !path.has(canon(add(k(1), scale(l, -1)))));
+    const split = focus.find(l => !path.has(canon(l)) && !path.has(canonFlip(l)));
     if (!split)
         return { stuck: verdict.kind === 'sat' ? 'sat' : 'unknown', path };
     const id = canon(split);
@@ -319,7 +425,7 @@ function bisect(rows, path) {
         const mid = Math.floor((lo + hi) / 2);
         for (const c of lo === hi ? [lo, lo - 1] : [mid]) {
             const lin = c === 0 ? { [x]: 1 } : { [x]: 1, 1: -c };
-            if (!path.has(canon(lin)) && !path.has(canon(add(k(1), scale(lin, -1)))))
+            if (!path.has(canon(lin)) && !path.has(canonFlip(lin)))
                 return lin;
         }
     }
@@ -331,7 +437,7 @@ function fractional(point, path) {
         if (Math.abs(value - Math.round(value)) < 1e-9 || x.includes('*'))
             continue;
         const c = Math.floor(value), lin = c === 0 ? { [x]: 1 } : { [x]: 1, 1: -c };
-        if (!path.has(canon(lin)) && !path.has(canon(add(k(1), scale(lin, -1)))))
+        if (!path.has(canon(lin)) && !path.has(canonFlip(lin)))
             return lin;
     }
     return undefined;
@@ -616,7 +722,7 @@ function proveLawsAsGiven(m, laws) {
     // Each law's two goals (start and step) get their own instances, seeded with its own keys.
     const keys = [...readKeys(m, laws), ...witnesses(m)], instances = {};
     laws.forEach((law, i) => {
-        instances[law.name] = instancesFor(m, laws, inst => obligations(m, laws, { ...instances, [law.name]: inst }).slice(2 * i, 2 * i + 2), {
+        instances[law.name] = instancesFor(m, laws, inst => obligations(m, laws, { ...instances, [law.name]: inst }, i), {
             seed: [...keys, ...(law.forall ? [{ op: 'var', name: `${law.forall}#` }] : []), ...(law.keys ?? []).map((name) => ({ op: 'var', name }))],
             focus: [...(law.forall ? [`${law.forall}#`] : []), ...(law.keys ?? [])],
         });

package/dist/lean-kernel/emit.js

@@ -105,12 +105,19 @@ export function encode(ex, tamper = false, dropStep = true, globalVars, globalMa
                 else if (key.includes('*'))
                     monos.add(key);
             }
+        // Each cell a hypothesis reads under the path, kept or not: two reads of one cell cancel in a row (T − T), yet
+        // Lean's linear form of each still needs the cell's column to see the comparison decided.
         for (const h of goal.hyps)
-            for (const e of subterms(h))
+            for (const e of subterms(h)) {
                 if (e.op === 'prod')
                     for (const key of Object.keys(linear(e, path) ?? {}))
                         if (key.includes('*'))
                             monos.add(key);
+                if (e.op === 'get')
+                    for (const key of Object.keys(linear(e, path) ?? {}))
+                        if (key.includes('['))
+                            addCell(key);
+            }
     });
     const depth = (name) => name.split('[').length;
     // Term columns (open choices, each standing for its term's value) before the cells, whose keys may read them.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdp-wired",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "An automatic prover for stateful rules (budgets, caps, windows, workflows, policies): laws proven with no proof to write, checked again in Lean, counterexamples found on the GPU, the rule shipped as code",
   "keywords": [
     "verification",
@@ -89,7 +89,7 @@
     "build": "bun scripts/build.ts",
     "prepublishOnly": "bun scripts/build.ts",
     "smoke": "sh scripts/smoke.sh",
-    "test": "bun scripts/gen-lean-library.ts --check && cd core && bun test solver.test.ts dsl.test.ts conformance.test.ts compose.test.ts quantifiers.test.ts functions.test.ts keyterms.test.ts lists.test.ts liveness.test.ts sizes.test.ts values.test.ts builders.test.ts gdp.test.ts datatypes.test.ts lemmas.test.ts invoices.test.ts folds.test.ts && cd ../kernel && bun test tamper.test.ts refusals.test.ts steplaw.test.ts sets.test.ts && cd ../examples && bun test examples.test.ts && cd .. && bun examples/readme.ts && bun examples/composition.ts && bun examples/sets.ts && bun examples/quantifiers.ts && bun examples/functions.ts && bun examples/datatypes.ts && bun examples/lemmas.ts && bun examples/invoices.ts && bun examples/folds.ts && bun examples/lists.ts && bun examples/sizes.ts && bun examples/liveness.ts && bun examples/budget.ts && bun examples/gdp.ts && bun examples/steps.ts && bun examples/jev-fabric/run.ts"
+    "test": "bun scripts/gen-lean-library.ts --check && cd core && bun test solver.test.ts dsl.test.ts conformance.test.ts compose.test.ts quantifiers.test.ts functions.test.ts keyterms.test.ts lists.test.ts liveness.test.ts sizes.test.ts values.test.ts builders.test.ts gdp.test.ts datatypes.test.ts lemmas.test.ts invoices.test.ts folds.test.ts trees.test.ts && cd ../kernel && bun test tamper.test.ts refusals.test.ts steplaw.test.ts sets.test.ts && cd ../examples && bun test examples.test.ts && cd .. && bun examples/readme.ts && bun examples/composition.ts && bun examples/sets.ts && bun examples/quantifiers.ts && bun examples/functions.ts && bun examples/datatypes.ts && bun examples/lemmas.ts && bun examples/invoices.ts && bun examples/folds.ts && bun examples/trees.ts && bun examples/lists.ts && bun examples/sizes.ts && bun examples/liveness.ts && bun examples/budget.ts && bun examples/gdp.ts && bun examples/steps.ts && bun examples/jev-fabric/run.ts"
   },
   "devDependencies": {
     "@gdp-ts/core": "0.1.0",