gdp-wired 0.16.0 → 0.18.0

package/dist/kernel/prove.js

@@ -1,5 +1,7 @@
 import { add, k, refuteFast, scale, solve, sub, v } from "../core/solver.js";
-import { assumed, boundOf, canon, canonFlip, columnTerm, decided, factorsOf, isCell, isMonomial, stepZone, check, checkLaws, checkStepLaws, historyMachine, leafConstraints, leafConstraintsReusing, reusing, linear, livenessHelpful, livenessParts, obligations, plainKey, progressObligations, stepLawObligations, trueC, truth, unreachable, witnessesOf, withProducts } from "./kernel.js";
+import { checkRefutation } from "../core/check.js";
+import { crossCyclic, cyclicMachine, cyclicOn, machineNodes, proveCyclic } from "../core/cyclic.js";
+import { assumed, atomOf, boundOf, canon, canonFlip, columnTerm, decided, factorsOf, isCell, isMonomial, stepZone, check, checkLaws, checkStepLaws, historyMachine, leafConstraints, leafConstraintsReusing, reusing, linear, livenessHelpful, livenessParts, obligations, plainKey, progressObligations, stepLawObligations, trueC, truth, unreachable, witnessesOf, 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) {
@@ -76,7 +78,10 @@ function openH(c, path, out, positive = true) {
     if (out.length === before && !positive && c.op === '=' && truth(c, path) === undefined)
         openC(c, path, out);
 }
-// Pairs of reads of one map whose keys the path doesn't yet compare.
+// Pairs of reads of one map whose keys the path doesn't yet compare. With `pairedKeys.skip` (core/data.ts), reads at
+// keys a pairing builds ((a + b)² + b, keys whose difference has monomials) are left uncompared: that encoding states
+// their congruence as facts, and comparing their keys only brings products into leaves its linear rows decide.
+export const pairedKeys = { skip: false };
 function openCells(rows, path) {
     const names = [...new Set(rows.flatMap(r => Object.keys(r.lin)))].filter(isCell);
     const out = [];
@@ -86,7 +91,27 @@ 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)));
+            if (pairedKeys.skip && Object.keys(d).some(isMonomial))
+                continue;
             const dec = (lin) => path.get(canon(lin))?.holds ?? (path.has(canonFlip(lin)) ? !path.get(canonFlip(lin)).holds : undefined);
+            // Two cells of a run's map (core/cyclic.ts: time u and key k at u + k·Ω) at keys k·Ω and k'·Ω: k = k' first, a
+            // linear atom; the keys' own difference only where k = k' (its other side then refuted by (k − k')·Ω = 0, a product).
+            const q0 = cellProducts.on ? quotient(d) : undefined;
+            if (q0) {
+                const qa = dec(q0), qb = dec(scale(q0, -1));
+                if (qa === undefined) {
+                    out.push(q0);
+                    continue;
+                }
+                if (qa === true && qb === undefined) {
+                    out.push(scale(q0, -1));
+                    continue;
+                }
+                if (!(qa && qb))
+                    continue;
+                cellDiffs.set(canon(d), q0);
+                cellDiffs.set(canon(scale(d, -1)), scale(q0, -1));
+            }
             const a = dec(d), b = dec(scale(d, -1));
             if (a === undefined)
                 out.push(d);
@@ -95,6 +120,24 @@ function openCells(rows, path) {
         }
     return out;
 }
+// A key difference q·F over monomials that share one factor F (Ω), with no other part: q, else undefined.
+const quotient = (d) => {
+    const keys = Object.keys(d);
+    if (!keys.length || keys.some(key => key === '1' || !isMonomial(key)))
+        return undefined;
+    const shared = factorsOf(keys[0]).find(f => keys.every(key => factorsOf(key).includes(f)));
+    if (!shared)
+        return undefined;
+    const out = {};
+    for (const key of keys) {
+        const fs = [...factorsOf(key)];
+        fs.splice(fs.indexOf(shared), 1);
+        out[fs.join('*')] = (out[fs.join('*')] ?? 0) + d[key];
+    }
+    return out;
+};
+// The cells' key differences split at their quotient's equality, by canonical text: their quotient.
+const cellDiffs = new Map();
 function parse(text) {
     const out = {};
     let depth = 0, start = 0;
@@ -138,10 +181,45 @@ const solveP = (rows, maxRows) => {
     return out;
 };
 // PROVE_TRACE=1 logs each goal grown from its root (hypotheses, nodes, time, outcome) to stderr.
+// PROVE_DUMP: a hook research/perf/prof sets to read each root goal.
+export let proveDump;
+export const setProveDump = (f) => { proveDump = f; };
 const proveTrace = !!globalThis.process?.env?.PROVE_TRACE;
+// `why`, when the budget ran out: which limit, at what size, and what usually helps.
+// Set while core/cyclic.ts grows its goals.
+export const cellProducts = { on: false };
 // 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.
+// A deadline every goal grown inside `withDeadline` keeps, beside its own budget: a search that proves many things (core/
+// infer.ts, core/discover.ts, the search proveRule falls back on) bounds them all; a goal past it is left `unknown`.
+let deadline = Infinity;
+export function withDeadline(until, f) {
+    const outer = deadline;
+    deadline = Math.min(outer, until);
+    try {
+        return f();
+    }
+    finally {
+        deadline = outer;
+    }
+}
+// `units: false`: the goal's own order, no units first (a caller after a model, not a proof: a run guided by the
+// prover's witnesses, say, whose models units would steer).
 export function grow(goal, path = new Map(), budget = { nodes: 0, until: performance.now() + Math.max(20_000, 1_000 * goal.hyps.length) }) {
+    if (deadline < (budget.until ?? Infinity))
+        budget.until = deadline;
+    if (budget.units === false && unitsNow) {
+        unitsNow = false;
+        try {
+            return grow(goal, path, budget);
+        }
+        finally {
+            unitsNow = true;
+        }
+    }
+    if (proveDump && !path.size && !budget.nodes) {
+        proveDump(goal);
+    }
     if (proveTrace && !path.size && !budget.nodes) {
         const t = performance.now(), out = growRoot(goal, path, budget);
         console.error(`[grow] ${goal.name}: ${goal.hyps.length} hyps, ${budget.nodes} nodes, ${Math.round(performance.now() - t)} ms, ${'tree' in out ? 'proven' : `${out.stuck}${out.why ? ` (${out.why})` : ''}`}`);
@@ -157,6 +235,18 @@ export function grow(goal, path = new Map(), budget = { nodes: 0, until: perform
 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 && unitFirst && unitsNow) {
+        // A goal that a few cases settle needs no units (finding them costs a Farkas check per atom); the rest get them.
+        unitsNow = false;
+        try {
+            const quick = growPlain(goal, path, { nodes: 0, until: budget.until, cap: 64 });
+            if ('tree' in quick || quick.stuck === 'sat' || quick.why === undefined)
+                return quick;
+        }
+        finally {
+            unitsNow = true;
+        }
+    }
     if (path.size === 0 && budget.nodes === 0) {
         const open = new Set(leafConstraints(goal, path).flatMap(r => Object.keys(r.lin)).filter(n => n.startsWith('⟦') && columnTerm(n)?.op === 'if')).size;
         const plain = growPlain(goal, path, { nodes: 0, until: budget.until, cap: Math.max(32, Math.round(4_000 / 2 ** (open / 2))) });
@@ -177,7 +267,7 @@ function growPlain(goal, path, budget) {
         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 = timed(() => leafConstraintsReusing(goal, path), ms => { profile.rowsMs += ms; });
+    const full = timed(() => rowsAt(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);
@@ -196,6 +286,8 @@ function growPlain(goal, path, budget) {
         byHyp.set(h, (seen = {})); return reusing(seen, path, p => { const out = []; openH(h, p, out); return out; }); };
     // Then the hypotheses about only the names the conclusion reads (an assumption about another key, a witness, can
     // wait: a refutation seldom needs it), then the rest, each group in the goal's order.
+    if (unitFirst && unitsNow)
+        open.push(...unitsOf(goal));
     if (last >= 0)
         open.push(...openOf(hyps[last]));
     const near = nearOf(goal);
@@ -228,6 +320,21 @@ function growPlain(goal, path, budget) {
             return { tree: { leaf: fast.steps }, nodes: budget.nodes };
     }
     let split = next ?? (verdict.kind === 'unknown' ? bisect(rows, path) ?? fractional(verdict.point, path) : undefined);
+    // A cell difference's failing side (k = k' on the path, the keys apart): (k − k')·Ω = 0 refutes it, a product of each
+    // of the path's two atoms k − k' <= 0 and k' − k <= 0 with Ω >= 0.
+    if (cellProducts.on && path.size) {
+        const [id, last] = [...path].at(-1), q0 = !last.holds ? cellDiffs.get(id) : undefined;
+        if (q0) {
+            const at = (lin) => rows.findIndex(r => canon(r.lin) === canon(lin));
+            const d = last.lin, f = factorsOf(Object.keys(d)[0]).find(x => !Object.keys(q0).includes(x) && Object.keys(d).every(key => factorsOf(key).includes(x)));
+            const e1 = at(q0), e2 = at(scale(q0, -1)), sign = f === undefined ? -1 : at({ [f]: -1 });
+            if (e1 >= 0 && e2 >= 0 && sign >= 0) {
+                const pairs = [[e1, sign], [e2, sign]], out = solve(withProducts(rows, pairs));
+                if (out.kind === 'refuted')
+                    return { tree: leafOf(out.steps, pairs), nodes: budget.nodes };
+            }
+        }
+    }
     // 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(isMonomial));
     // A witness that multiplies out (each monomial's value is its factors' product) is a real model: nothing to refute.
@@ -237,6 +344,30 @@ function growPlain(goal, path, budget) {
         if (real)
             return { stuck: 'sat', witness: w, path };
     }
+    // An equation about a factor (x' = x + 1, a run's next state as a cell) times each factor's sign: e·f = 0 for every
+    // factor f, so a monomial of x' is one of x (x'·x' = (x + 1)²). Whatever the number of rows: there are few such pairs.
+    // Only for cyclic proofs (core/cyclic.ts, whose runs keep each next state as a cell): the usual rules substitute it.
+    if (!split && monomials && cellProducts.on) {
+        const factorSet = new Set(rows.flatMap(r => Object.keys(r.lin).filter(isMonomial).flatMap(factorsOf)));
+        const byCanon = new Map(rows.map((r, i) => [canon(r.lin), i]));
+        const eqs = rows.flatMap((r, i) => (Object.keys(r.lin).some(key => key !== '1' && factorSet.has(key)) && byCanon.has(canon(scale(r.lin, -1))) ? [i] : []));
+        const signs = rows.flatMap((r, i) => { const keys = Object.keys(r.lin); return keys.length === 1 && factorSet.has(keys[0]) && r.lin[keys[0]] < 0 ? [i] : []; });
+        const pairs = eqs.flatMap(i => signs.map(j => [i, j])).slice(0, 200);
+        if (pairs.length) {
+            const sub = solve(withProducts(rows, pairs));
+            if (sub.kind === 'refuted')
+                return { tree: leafOf(sub.steps, pairs), nodes: budget.nodes };
+            // Then every linear row about a factor (n >= x: (n − x)·d >= 0) times each sign, past the forty rows the pairs
+            // below are kept to.
+            const about = rows.flatMap((r, i) => (!eqs.includes(i) && Object.keys(r.lin).some(key => key !== '1' && factorSet.has(key)) && !Object.keys(r.lin).some(isMonomial) ? [i] : []));
+            const more = [...pairs, ...about.flatMap(i => signs.map(j => [i, j]))].slice(0, 400);
+            if (more.length > pairs.length) {
+                const ineq = solve(withProducts(rows, more));
+                if (ineq.kind === 'refuted')
+                    return { tree: leafOf(ineq.steps, more), nodes: budget.nodes };
+            }
+        }
+    }
     if (!split && monomials && rows.length <= 40) {
         // Only rows about the factors (no other map cells), each pair once: elimination over hundreds of products blows up.
         const factorSet = new Set(rows.flatMap(r => Object.keys(r.lin).filter(isMonomial).flatMap(factorsOf)));
@@ -426,6 +557,24 @@ function squareForms(rows) {
 // 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.
+// A leaf's rows, by its path's decisions in order (what they are a function of): a lift reads every leaf of a subtree
+// at its own path, found when it was grown, and at the path without the split, which the next lift up reads again.
+const rowsSeen = new WeakMap();
+function rowsAt(goal, path) {
+    let byPath = rowsSeen.get(goal);
+    if (!byPath)
+        rowsSeen.set(goal, (byPath = new Map()));
+    let id = '';
+    for (const [key, a] of path)
+        id += `${a.holds ? '+' : '-'}${key}|`;
+    let rows = byPath.get(id);
+    if (!rows) {
+        if (byPath.size >= 4096)
+            byPath.clear();
+        byPath.set(id, (rows = leafConstraintsReusing(goal, path)));
+    }
+    return rows;
+}
 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));
@@ -440,7 +589,7 @@ function lift(goal, tree, from, to) {
             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();
+        const ra = rowsAt(goal, a), rb = rowsAt(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);
@@ -466,6 +615,86 @@ function lift(goal, tree, from, to) {
     };
     return go(tree, from, to);
 }
+// A tree for a weaker goal (some hypotheses left out, some conjuncts of one left out) made a tree for the whole: at any
+// path a leaf's rows are among the whole goal's (each hypothesis' facts are a hypothesis' own, the cells, terms and
+// naturals they read a subset), so each input is renumbered to the same row there, a square or product past the rows
+// moved by the difference. Where a dropped conjunct makes the whole hypothesis false under the path, its row 1 <= 0
+// refutes the leaf alone; a leaf neither maps is grown again on the whole goal.
+// `opaque`: variables the weaker goal has for terms of the whole (a step's value, read the same in two hypotheses), each
+// read as the term's linear form at the whole goal's path; a split the whole's path already decides is followed, not
+// made again.
+export function widen(part, whole, tree, opaque = {}, pp = new Map(), wp = pp) {
+    const names = Object.keys(opaque);
+    const rename = (lin) => {
+        if (!names.length)
+            return lin;
+        let out = {};
+        for (const [key, c] of Object.entries(lin)) {
+            const e = opaque[key];
+            if (e) {
+                const l = linear(e, wp);
+                if (!l)
+                    return undefined;
+                out = add(out, scale(l, c));
+            }
+            else if (names.some(n => key.includes(n)))
+                return undefined;
+            else
+                out = add(out, { [key]: c });
+        }
+        return out;
+    };
+    if (!('leaf' in tree)) {
+        const id = canon(tree.split), wl = rename(tree.split);
+        if (!wl) {
+            const o = grow(whole, wp);
+            return 'tree' in o ? o.tree : undefined;
+        }
+        const wid = canon(wl), known = Object.keys(wl).every(key => key === '1') ? (wl['1'] ?? 0) <= 0 : wp.has(wid) ? wp.get(wid).holds : wp.has(canonFlip(wl)) ? !wp.get(canonFlip(wl)).holds : undefined;
+        if (known !== undefined)
+            return widen(part, whole, known ? tree.yes : tree.no, opaque, new Map(pp).set(id, { lin: tree.split, holds: known }), wp);
+        const yes = widen(part, whole, tree.yes, opaque, new Map(pp).set(id, { lin: tree.split, holds: true }), new Map(wp).set(wid, { lin: wl, holds: true }));
+        const no = yes && widen(part, whole, tree.no, opaque, new Map(pp).set(id, { lin: tree.split, holds: false }), new Map(wp).set(wid, { lin: wl, holds: false }));
+        return yes && no ? { split: wl, yes, no } : undefined;
+    }
+    const rp = rowsAt(part, pp), rw = rowsAt(whole, wp), at = new Map();
+    rw.forEach((r, i) => { const key = canon(r.lin); if (!at.has(key))
+        at.set(key, i); });
+    const map = (i) => { if (i >= rp.length)
+        return i - rp.length + rw.length; const l = rename(rp[i].lin); return l && at.get(canon(l)); };
+    const leaf = [], products = [], squares = (tree.squares ?? []).map(rename);
+    let ok = squares.every(Boolean);
+    for (const st of ok ? tree.leaf : []) {
+        if (st.kind !== 'input') {
+            leaf.push(st);
+            continue;
+        }
+        const j = map(st.index);
+        if (j === undefined) {
+            ok = false;
+            break;
+        }
+        leaf.push({ ...st, index: j });
+    }
+    for (const [i, j] of ok ? tree.products ?? [] : []) {
+        const pi = map(i), pj = map(j);
+        if (pi === undefined || pj === undefined) {
+            ok = false;
+            break;
+        }
+        products.push([pi, pj]);
+    }
+    // (renamed, a derivation through products or cuts is replayed: a cut's divisor may not divide the terms' coefficients)
+    if (ok && names.length && !checkRefutation(withProducts(rw, products, squares), leaf))
+        ok = false;
+    if (ok)
+        return { leaf, ...(tree.products ? { products } : {}), ...(tree.squares ? { squares: squares } : {}) };
+    const absurd = rw.findIndex(r => Object.keys(r.lin).every(key => key === '1') && (r.lin['1'] ?? 0) > 0);
+    if (absurd >= 0)
+        return { leaf: [{ kind: 'input', index: absurd }] };
+    const out = grow(whole, wp);
+    return 'tree' in out ? out.tree : undefined;
+}
 // Whether each hypothesis reads only names the goal's conclusion (its last hypothesis) reads.
 const nearSeen = new WeakMap();
 const namesOf = (t) => (t === undefined ? [] : [...JSON.stringify(t).matchAll(/"(?:name|map)":"([^"]+)"/g)].map(m => m[1]));
@@ -477,6 +706,51 @@ function nearOf(goal) {
     }
     return out;
 }
+// Units first: an atom some hypothesis splits on whose value the root's rows already force (a guard `?f = 0` where
+// `?f = 1` holds, `k < len` where it is given). Split at the top, its forced side refutes at once; split late, under
+// every other case, it is split again in each.
+// GDP_UNITS=0 leaves them in the goal's order (for comparing).
+const unitFirst = globalThis.process?.env?.GDP_UNITS !== '0';
+let unitsNow = true;
+const unitSeen = new WeakMap();
+function unitsOf(goal) {
+    let out = unitSeen.get(goal);
+    if (out)
+        return out;
+    // Forced by the root's rows without a solver: a row the atom is (or is the negation of), or the bounds the rows give
+    // single variables (x <= c, x >= c) deciding it whichever way its variables go.
+    const root = new Map(), rows = leafConstraints(goal, root), seen = new Set(), given = new Set();
+    const lo = new Map(), hi = new Map();
+    for (const r of rows) {
+        given.add(canon(r.lin));
+        const vs = Object.keys(r.lin).filter(key => key !== '1');
+        if (vs.length !== 1)
+            continue;
+        const x = vs[0], c = r.lin[x], k = r.lin['1'] ?? 0, bound = -k / c;
+        if (c > 0)
+            hi.set(x, Math.min(hi.get(x) ?? Infinity, Math.floor(bound)));
+        else
+            lo.set(x, Math.max(lo.get(x) ?? -Infinity, Math.ceil(bound)));
+    }
+    const range = (lin) => Object.entries(lin).reduce(([a, b], [x, c]) => x === '1' ? [a + c, b + c]
+        : c > 0 ? [a + c * (lo.get(x) ?? -Infinity), b + c * (hi.get(x) ?? Infinity)] : [a + c * (hi.get(x) ?? Infinity), b + c * (lo.get(x) ?? -Infinity)], [0, 0]);
+    out = [];
+    for (const h of goal.hyps.slice(0, -1)) {
+        const atoms = [];
+        openH(h, root, atoms);
+        for (const lin of atoms) {
+            const id = canon(lin);
+            if (seen.has(id) || seen.has(canonFlip(lin)) || !Object.keys(lin).some(key => key !== '1'))
+                continue;
+            seen.add(id);
+            const [a, b] = range(lin);
+            if (given.has(id) || given.has(canon(atomOf(lin, false).lin)) || b <= 0 || a >= 1)
+                out.push(lin);
+        }
+    }
+    unitSeen.set(goal, out);
+    return out;
+}
 // 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.
@@ -847,6 +1121,134 @@ function instancesFor(m, laws, build, opts = {}) {
     }
     return inst;
 }
+// Instances worth their rows: a quantified flag or a law about every key, at a key where the goals read a map the way
+// its condition reads one at its own key (M[k] read as M[t], M[k + b] as M[t + b]). An instance anywhere else gives each
+// leaf rows about cells nothing else mentions, and a split for each (a flag over grant numbers at a path's positions,
+// say); a tuple, where each of its keys is so read. Found as a fixpoint from the goals with none of these instances, as
+// an instance's rows read cells that make others worth it; a name whose condition reads no map at its keys, and the
+// focus keys, are kept as they are.
+// Untrusted: fewer instances still make a checked proof, and where they don't prove a goal the full set is tried.
+const triggers = (body, key) => {
+    const out = [], mentions = (e) => JSON.stringify(e).includes(`"name":${JSON.stringify(key)}`);
+    const inE = (e) => { if (e.op === 'get') {
+        if (mentions(e.key))
+            out.push({ map: e.map, at: e.key });
+        inE(e.key);
+    }
+    else if (e.op === 'if')
+        (inC(e.c), inE(e.then), inE(e.else));
+    else if (e.op === 'mul')
+        inE(e.a);
+    else if ('a' in e)
+        (inE(e.a), inE(e.b)); };
+    const inC = (c) => (c.op === 'flag' ? undefined : c.op === 'all' ? inC(c.c) : c.op === 'not' ? inC(c.x) : c.op === 'and' || c.op === 'or' ? c.xs.forEach(inC) : (inE(c.a), inE(c.b)));
+    inC(body);
+    return out;
+};
+const substKey = (e, key, by) => JSON.parse(JSON.stringify(e).replaceAll(`{"op":"var","name":${JSON.stringify(key)}}`, JSON.stringify(by)));
+// GDP_TRIGGER=0 keeps every instance (for comparing).
+const triggerOn = globalThis.process?.env?.GDP_TRIGGER !== '0';
+function triggered(m, laws, inst, build, focus = []) {
+    if (!triggerOn)
+        return inst;
+    // Per name: its bound keys, and for each the triggers that read it alone (a key with none takes any value).
+    const bodies = new Map();
+    for (const [n, ks] of Object.entries(inst)) {
+        if (!ks.length)
+            continue;
+        const q = n.startsWith('?') ? m.step.flags?.[n.slice(1)] : undefined, l = q ? undefined : laws.find(x => x.name === n);
+        const body = q?.op === 'all' ? q.c : l?.forall ? l.holds : undefined, keys = q?.op === 'all' ? boundOf(q) : l?.forall ? [l.forall, ...(l.keys ?? [])] : [];
+        if (!body)
+            continue;
+        const per = keys.map(key => triggers(body, key).filter(t => keys.every(o => o === key || !JSON.stringify(t.at).includes(`"name":${JSON.stringify(o)}`))));
+        if (per.some(t => t.length))
+            bodies.set(n, { keys, per });
+    }
+    if (!bodies.size)
+        return inst;
+    const tuplesOf = (n, ks) => { const a = bodies.get(n).keys.length; return Array.from({ length: Math.floor(ks.length / a) }, (_, t) => ks.slice(t * a, (t + 1) * a)); };
+    const kept = (tuple) => tuple.some(e => e.op === 'var' && focus.includes(e.name));
+    const out = Object.fromEntries(Object.entries(inst).map(([n, ks]) => [n, bodies.has(n) ? tuplesOf(n, ks).filter(kept).flat() : ks]));
+    for (let round = 0; round < 8; round++) {
+        const reads = new Set();
+        const inE = (e) => { if (e.op === 'get') {
+            reads.add(`${e.map}|${JSON.stringify(e.key)}`);
+            inE(e.key);
+        }
+        else if (e.op === 'if')
+            (inC(e.c), inE(e.then), inE(e.else));
+        else if (e.op === 'mul')
+            inE(e.a);
+        else if ('a' in e)
+            (inE(e.a), inE(e.b)); };
+        const inC = (c) => (c.op === 'flag' ? undefined : c.op === 'all' ? inC(c.c) : c.op === 'not' ? inC(c.x) : c.op === 'and' || c.op === 'or' ? c.xs.forEach(inC) : (inE(c.a), inE(c.b)));
+        for (const g of build(out))
+            g.hyps.forEach(inC);
+        let grew = false;
+        for (const [n, { keys, per }] of bodies) {
+            const have = new Set(tuplesOf(n, out[n]).map(t => JSON.stringify(t)));
+            for (const tuple of tuplesOf(n, inst[n])) {
+                const id = JSON.stringify(tuple);
+                if (have.has(id) || !keys.every((key, i) => !per[i].length || per[i].some(({ map, at }) => reads.has(`${map}|${JSON.stringify(substKey(at, key, tuple[i]))}`))))
+                    continue;
+                out[n].push(...tuple);
+                have.add(id);
+                grew = true;
+            }
+        }
+        if (!grew)
+            break;
+    }
+    return out;
+}
+// For a certificate others check again (the Lean export sets `minimal.on`): the instances of quantified flags a proof
+// found that its leaves refute with, the proof grown again with those alone. The checked goal is then built from far
+// fewer hypotheses (a law about pairs of items with 900 instance hypotheses and 30 leaves using a few of them, say).
+export const minimal = { on: false };
+// The hypotheses a tree's leaves read: each leaf's input rows, and the rows its products multiply.
+export function usedHyps(goal, tree, path = new Map(), out = new Set()) {
+    if ('leaf' in tree) {
+        const rows = rowsAt(goal, path), n = rows.length, sq = tree.squares?.length ?? 0;
+        const mark = (i) => {
+            if (i < n) {
+                const s = rows[i].src;
+                if (s && 'fact' in s)
+                    out.add(s.fact);
+            }
+            else if (i >= n + sq) {
+                const pq = tree.products?.[i - n - sq];
+                if (pq) {
+                    mark(pq[0]);
+                    mark(pq[1]);
+                }
+            }
+        };
+        for (const st of tree.leaf)
+            if (st.kind === 'input')
+                mark(st.index);
+        return out;
+    }
+    const id = canon(tree.split);
+    usedHyps(goal, tree.yes, new Map(path).set(id, { lin: tree.split, holds: true }), out);
+    return usedHyps(goal, tree.no, new Map(path).set(id, { lin: tree.split, holds: false }), out);
+}
+// The tuples of each quantified flag whose hypotheses `used` names: a flag's instance hypotheses follow its ?f <= 1 in
+// the goal, in the instances' order (kernel.ts's closing).
+function usedInstances(m, goal, inst, used, focus) {
+    const out = { ...inst };
+    for (const [f, q] of Object.entries(m.step.flags ?? {})) {
+        if (q.op !== 'all' || !inst[`?${f}`]?.length)
+            continue;
+        const at = goal.hyps.findIndex(h => h.op === '<=' && h.a.op === 'var' && h.a.name === `?${f}` && h.b.op === 'const' && h.b.value === 1);
+        if (at < 0)
+            continue;
+        const a = boundOf(q).length, ks = inst[`?${f}`];
+        out[`?${f}`] = Array.from({ length: Math.floor(ks.length / a) }, (_, t) => ks.slice(t * a, (t + 1) * a))
+            .filter((tuple, t) => used.has(at + 1 + t) || tuple.some(e => e.op === 'var' && focus.includes(e.name))).flat();
+    }
+    return out;
+}
+const sameInstances = (a, b) => Object.keys(b).every(n => (a[n]?.length ?? 0) === b[n].length);
 // Instances without the keys that read any of these names (a law about several keys loses each tuple that does).
 const avoiding = (inst, names, laws, m) => {
     const bad = (e) => names.some(n => JSON.stringify(e).includes(`"name":${JSON.stringify(n)}`));
@@ -941,6 +1343,9 @@ export function proveLaw(m, laws, i) {
         seed: [...keys, ...(law.forall ? [{ op: 'var', name: `${law.forall}#` }] : []), ...(law.keys ?? []).map((name) => ({ op: 'var', name }))],
         focus: [...(law.forall ? [`${law.forall}#`] : []), ...(law.keys ?? [])],
     });
+    const few = triggered(m, laws, inst, i2 => obligations(m, laws, { [law.name]: i2 }, i), law.forall ? [`${law.forall}#`] : []);
+    if (!sameInstances(few, inst) && obligations(m, laws, { [law.name]: few }, i).every(goal => 'tree' in grow(goal)))
+        return { proven: true };
     for (const goal of obligations(m, laws, { [law.name]: inst }, i)) {
         const out = grow(goal);
         if (!('tree' in out))
@@ -957,6 +1362,64 @@ function proveLawsAsGiven(m, laws) {
             focus: [...(law.forall ? [`${law.forall}#`] : []), ...(law.keys ?? [])],
         });
     });
+    const t0 = performance.now(), out = proveThinned(m, laws, { ...instances }), usualMs = performance.now() - t0;
+    if (cyclicOn()) {
+        if (cyclicMachine(m, laws))
+            crossCyclic('machine', m.name, out.proven && out.checked, () => { const { facts, specs } = machineNodes(m, laws, instances); return proveCyclic(facts, specs); }, usualMs);
+        else
+            console.error(`cyclic: ${JSON.stringify({ kind: 'machine', name: m.name, usual: out.proven && out.checked, uncovered: true })}`);
+    }
+    return out;
+}
+// Each law with its instances thinned (`triggered`) where that proves it, else with all of them.
+function proveThinned(m, laws, instances) {
+    const trees = {}, fulls = { ...instances };
+    let nodes = 0, leaves = 0;
+    for (const [i, law] of laws.entries()) {
+        const full = instances[law.name], few = triggered(m, laws, full, inst => obligations(m, laws, { ...instances, [law.name]: inst }, i), law.forall ? [`${law.forall}#`] : []);
+        for (const inst of sameInstances(few, full) ? [full] : [few, full]) {
+            instances[law.name] = inst;
+            const done = {};
+            let failed, n = 0, lv = 0;
+            for (const goal of obligations(m, laws, instances, i)) {
+                const out = grow(goal);
+                if (!('tree' in out)) {
+                    failed = { goal: goal.name, stuck: out.stuck, ...(out.witness ? { witness: out.witness } : {}), ...(out.why ? { why: out.why } : {}) };
+                    break;
+                }
+                done[goal.name] = out.tree;
+                n += out.nodes;
+                lv += countLeaves(out.tree);
+            }
+            if (failed && inst !== full)
+                continue;
+            if (failed)
+                return { proven: false, nodes, leaves, failed, checked: false };
+            Object.assign(trees, done);
+            nodes += n;
+            leaves += lv;
+            break;
+        }
+    }
+    // The goals of no one law (a history's own), with the instances chosen.
+    for (const goal of obligations(m, laws, instances)) {
+        if (trees[goal.name])
+            continue;
+        const out = grow(goal);
+        // Where thinned instances leave such a goal unproven, every goal again with the full ones.
+        if (!('tree' in out) && laws.some(l => instances[l.name] !== fulls[l.name]))
+            return proveWith(m, laws, fulls);
+        if (!('tree' in out))
+            return { proven: false, nodes, leaves, failed: { goal: goal.name, stuck: out.stuck, ...(out.witness ? { witness: out.witness } : {}), ...(out.why ? { why: out.why } : {}) }, checked: false };
+        trees[goal.name] = out.tree;
+        nodes += out.nodes;
+        leaves += countLeaves(out.tree);
+    }
+    const proof = { instances, trees };
+    return { proven: true, nodes, leaves, checked: checkLaws(m, laws, proof), proof };
+}
+// Every goal of the laws with these instances.
+function proveWith(m, laws, instances) {
     const trees = {};
     let nodes = 0, leaves = 0;
     for (const goal of obligations(m, laws, instances)) {
@@ -1007,7 +1470,12 @@ function proveStepLawsAsGiven(m, laws, stepLaws, base) {
     let nodes = base.nodes, leaves = base.leaves;
     for (const sl of stepLaws)
         for (const goal of stepLawObligations(m, laws, perStep[sl.name] ?? instances, sl)) {
-            let out = grow(goal);
+            const full = perStep[sl.name] ?? instances, few = triggered(plain, laws, full, inst => stepLawObligations(m, laws, inst, sl), [sl.forall, ...(sl.keys ?? [])].flatMap(k => (k ? [k] : [])));
+            let out = sameInstances(few, full) ? grow(goal) : grow(stepLawObligations(m, laws, few, sl).find(g => g.name === goal.name) ?? goal);
+            if ('tree' in out && !sameInstances(few, full))
+                perStep[sl.name] = few;
+            else if (!sameInstances(few, full))
+                out = grow(goal);
             // A k-step law that reads a condition kept across its steps: each flag at its own witnesses, at every step.
             if (!('tree' in out))
                 for (const kept of keptAcross(plain, laws, perStep[sl.name] ?? instances, own(sl), sl.steps ?? 1)) {
@@ -1020,6 +1488,18 @@ function proveStepLawsAsGiven(m, laws, stepLaws, base) {
                 }
             if (!('tree' in out))
                 return { proven: false, nodes, leaves, failed: { goal: goal.name, stuck: out.stuck, ...(out.witness ? { witness: out.witness } : {}), ...(out.why ? { why: out.why } : {}) }, checked: false };
+            if (minimal.on) {
+                const had = perStep[sl.name] ?? instances, built = stepLawObligations(m, laws, had, sl).find(g => g.name === goal.name);
+                if (built) {
+                    const focus = [sl.forall, ...(sl.keys ?? [])].flatMap(k => (k ? [k] : [])), thin = usedInstances(plain, built, had, usedHyps(built, out.tree), focus);
+                    const g2 = sameInstances(thin, had) ? undefined : stepLawObligations(m, laws, thin, sl).find(g => g.name === goal.name);
+                    const again = g2 && grow(g2);
+                    if (again && 'tree' in again) {
+                        out = again;
+                        perStep[sl.name] = thin;
+                    }
+                }
+            }
             trees[goal.name] = out.tree;
             nodes += out.nodes;
             leaves += countLeaves(out.tree);