gdp-wired 0.15.0 → 0.17.0

package/dist/kernel/prove.js

@@ -1,5 +1,6 @@
 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 { 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) {
@@ -138,10 +139,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 +193,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))) });
@@ -196,6 +244,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);
@@ -237,6 +287,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)));
@@ -283,6 +357,27 @@ function growPlain(goal, path, budget) {
                     return { tree: leafOf(third.steps, weighted, squares), nodes: budget.nodes };
             }
         }
+        // A multiplier: every row times a factor the path has at least 1 (the row 1 − x <= 0), with the squares (x·a − b)
+        // and (x·b − a) of each product a·b the rows read: a certificate that multiplies the goal by x first ((Σv)² <= n·Σv²
+        // over running samples is n times the goal, closed by (n·v − s)²).
+        const ones = rows.flatMap((r, i) => { const ks = Object.keys(r.lin); return ks.length === 2 && r.lin['1'] === 1 && ks.some(key => key !== '1' && r.lin[key] === -1 && factorSet.has(key)) ? [i] : []; });
+        for (const xi of ones.slice(0, 3)) {
+            const x = Object.keys(rows[xi].lin).find(key => key !== '1'), name = (fs) => [...fs].sort().join('*');
+            const forms = new Map();
+            for (const m of new Set(rows.flatMap(r => Object.keys(r.lin).filter(isMonomial)))) {
+                const [a, b, ...more] = factorsOf(m);
+                if (!a || !b || more.length)
+                    continue;
+                for (const [u, w] of [[a, b], [b, a]]) {
+                    const t = { [name([x, u])]: 1, [w]: -1 };
+                    forms.set(canon(t), t);
+                }
+            }
+            const times = relevant.map(i => [i, xi]), sq = [...forms.values()].slice(0, 32);
+            const multiplied = solve(withProducts(rows, times, sq));
+            if (multiplied.kind === 'refuted')
+                return { tree: leafOf(multiplied.steps, times, sq), nodes: budget.nodes };
+        }
         const factors = [...new Set(rows.flatMap(r => Object.keys(r.lin).filter(isMonomial).flatMap(factorsOf)))];
         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).
@@ -456,6 +551,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.
@@ -826,6 +966,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.
+function usedHyps(goal, tree, path = new Map(), out = new Set()) {
+    if ('leaf' in tree) {
+        const rows = leafConstraints(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)}`));
@@ -920,6 +1188,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))
@@ -936,6 +1207,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)) {
@@ -986,7 +1315,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)) {
@@ -999,6 +1333,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);

package/dist/lean-kernel/emit.d.ts

@@ -1,6 +1,7 @@
 import type { C, E, Law, Machine, Recurrence } from '../core/machine.js';
 import { type Lin, type Step } from '../core/solver.js';
 import { type Fold, type Goal, type Instances, type Liveness, type Loop, type Path, type StepLaw, type Tree } from '../kernel/kernel.js';
+import { type Cyclic } from '../kernel/cyclic.js';
 import { leanLibrary } from './library.js';
 export { leanLibrary };
 export type Exported = {
@@ -143,6 +144,14 @@ export type LeanItem = {
 } | {
     id: string;
     goal: Goal;
+} | {
+    id: string;
+    cyclic: Cyclic;
+    tampered?: {
+        what: string;
+        proof: Cyclic;
+    }[];
+    after?: (ix: (name: string) => number, mx: (map: string) => number) => string;
 };
 export declare function toLean(items: LeanItem[], opts?: {
     title?: string;
@@ -151,3 +160,7 @@ export declare function toLean(items: LeanItem[], opts?: {
 export declare function leanProject(file: string, opts?: {
     name?: string;
 }): Record<string, string>;
+export declare function cyclicToLean(id: string, p: Cyclic, tampered?: {
+    what: string;
+    proof: Cyclic;
+}[], after?: (ix: (name: string) => number, mx: (map: string) => number) => string): string;

package/dist/lean-kernel/emit.js

@@ -1,9 +1,10 @@
 import { atMost, n, not, pointWrite } from "../core/machine.js";
 import { add, k, scale, sub } from "../core/solver.js";
 import { boundOf, canon, factorsOf, isCell, isMonomial, columnTerm, stateName, termColumn, historyMachine, foldObligations, leafConstraints, loopLiveness, loopMachine, linear, livenessHelpful, livenessParts, livenessRanks, loopObligations, trueC, obligations, progressObligations, stepLawObligations, substC, witnessesOf, withProducts } from "../kernel/kernel.js";
-import { grow, proveBuilt, proveLaws, proveStepLaws } from "../kernel/prove.js";
+import { grow, minimal, proveBuilt, proveLaws, proveStepLaws } from "../kernel/prove.js";
 import { refinement, refinementSides } from "../core/compose.js";
 import { leanSurface, leanTerms } from "./lean-terms.js";
+import { descentGoal, mainGoal, premiseGoal } from "../kernel/cyclic.js";
 import { leanLibrary } from "./library.js";
 export { leanLibrary };
 // --- to Lean ------------------------------------------------------------------------------------------------------------
@@ -1055,11 +1056,15 @@ export function toLean(items, opts = {}) {
     const outer = checkBy;
     const env = globalThis.process?.env;
     checkBy = (opts.native ?? env?.GDP_LEAN_NATIVE === '1') ? 'native_decide' : 'decide +kernel';
+    // The proofs found with only the instances their leaves use: the same laws, from fewer hypotheses for Lean to build.
+    const wasMinimal = minimal.on;
+    minimal.on = true;
     try {
         return toLeanWith(items, opts);
     }
     finally {
         checkBy = outer;
+        minimal.on = wasMinimal;
     }
 }
 function toLeanWith(items, opts) {
@@ -1119,6 +1124,10 @@ function toLeanWith(items, opts) {
             parts.push(`-- ${item.id}\n${loopToLean(id, item.loop, item.laws ?? [], item.rank)}`);
             theorems.push(`${id}_halts`);
         }
+        else if ('cyclic' in item) {
+            parts.push(`-- ${item.id}\n${cyclicToLean(id, item.cyclic, item.tampered ?? [], item.after)}`);
+            theorems.push(`${id}_sound`, ...(item.after ? [...item.after(() => 0, () => 0).matchAll(/^theorem (\S+)/gm)].map(x2 => x2[1]) : []));
+        }
         else if ('fold' in item) {
             parts.push(`-- ${item.id}\n${foldToLean(id, item.fold, item.laws)}`);
             theorems.push(`${id}_laws`);
@@ -1132,7 +1141,7 @@ function toLeanWith(items, opts) {
     }
     // The file the items need: Live.lean for a liveness or a loop, Sets.lean (which imports Steps.lean) for any machine.
     return `import History
-import ${items.some(item => 'refinement' in item) ? 'Refine' : items.some(item => 'machine' in item && item.ghosts?.length) ? 'Ghost' : items.some(item => ('machine' in item && item.liveness?.length) || 'loop' in item) ? 'Live' : items.some(item => 'machine' in item) ? 'Sets' : 'Steps'}
+${items.some(item => 'cyclic' in item) ? 'import Cyclic\n' : ''}import ${items.some(item => 'refinement' in item) ? 'Refine' : items.some(item => 'machine' in item && item.ghosts?.length) ? 'Ghost' : items.some(item => ('machine' in item && item.liveness?.length) || 'loop' in item) ? 'Live' : items.some(item => 'machine' in item) ? 'Sets' : 'Steps'}
 open Kern Cert
 set_option maxRecDepth 100000
 set_option maxHeartbeats 0
@@ -1164,3 +1173,42 @@ lean_lib ${name} where
 `,
     };
 }
+// A cyclic proof through Kern.cyclic_sound: the facts and the nodes, each goal's table and tree (Lean builds the goals
+// from the nodes), one theorem for every node; each tampered proof's check computed to false. `after` writes Lean
+// after it (a corollary in plain terms), given the variables' and maps' numbers.
+export function cyclicToLean(id, p, tampered = [], after) {
+    const all = [p, ...tampered.map(t => t.proof)];
+    const names = (t) => [...JSON.stringify(t).matchAll(/"op":"var","name":"([^"]+)"/g)].map(m => m[1]);
+    const vars = [...new Set(all.flatMap(q => [...q.facts.flatMap(f => [...f.keys, ...names(f.holds)]), ...q.nodes.flatMap(n => [...names([n.hyps, n.concl, n.rank, n.insts]), ...n.uses.flatMap(u => [...Object.keys(u.subst), ...names([u.subst, u.guard])])])]))];
+    const maps = [...new Set([...JSON.stringify(all).matchAll(/"op":"get","map":"([^"]+)"/g)].map(m => m[1]))];
+    const { e, c } = leanTerms(vars, maps, id);
+    const ix = (name) => vars.indexOf(name);
+    const facts = list(p.facts.map(f => `⟨${list(f.keys.map(key => String(ix(key))))}, ${c(f.holds)}⟩`));
+    // A tampered proof keeps the proof's tables and trees (made for the proof's own goals) under its changed nodes.
+    const enc = (g, tree) => { const x = encode({ name: `${id}: ${g.name}`, goal: g, tree }, false, true, vars, maps); return `(${x.tab}, ${x.tree})`; };
+    const nodeLits = (q) => q.nodes.map((n, i) => {
+        const o = p.nodes[i];
+        const uses = n.uses.map((u, j) => {
+            const ou = o.uses[j], om = p.nodes[ou.node];
+            return `⟨${u.node}, ${list(Object.entries(u.subst).map(([name, t]) => `(${ix(name)}, ${e(t)})`))}, ${c(u.guard)},\n  ${list(om.hyps.map((h, k2) => enc(premiseGoal(p.facts, o, ou, h, k2), ou.premises[k2])))},\n  ${enc(descentGoal(p.facts, o, ou, om), ou.descent)}⟩`;
+        });
+        return { hyps: list(n.hyps.map(c)), concl: c(n.concl), rest: `${list(n.rank.map(e))}, ${list(n.insts.map(t => `(${t.fact}, ${list(t.at.map(e))})`))},\n  ${list(uses)},\n  ${enc(mainGoal(p.facts, p.nodes, o), o.main)}` };
+    });
+    const nodes = (q) => list(nodeLits(q).map(x => `⟨${x.hyps}, ${x.concl}, ${x.rest}⟩`));
+    const mx = (map) => maps.indexOf(map);
+    return `-- ${p.nodes.map(n => n.name).join('; ')}  (variables ${vars.map((name, j) => `${j} ${name}`).join(', ')}; maps ${maps.map((name, j) => `${j} ${name}`).join(', ')})
+def ${id}_facts : List Fact := ${facts}
+${nodeLits(p).map((x, i) => `def ${id}_hyps${i} : List C := ${x.hyps}
+def ${id}_concl${i} : C := ${x.concl}
+def ${id}_node${i} : CNode := ⟨${id}_hyps${i}, ${id}_concl${i}, ${x.rest}⟩
+theorem ${id}_node${i}_hyps : ${id}_node${i}.hyps = ${id}_hyps${i} := rfl
+theorem ${id}_node${i}_concl : ${id}_node${i}.concl = ${id}_concl${i} := rfl`).join('\n')}
+def ${id}_nodes : List CNode := ${list(p.nodes.map((_, i) => `${id}_node${i}`))}
+${p.nodes.map((_, i) => `theorem ${id}_node${i}_mem : ${id}_node${i} ∈ ${id}_nodes := by simp only [${id}_nodes, List.mem_cons, true_or, or_true]`).join('\n')}
+theorem ${id}_check : checkCyclic ${id}_facts ${id}_nodes = true := by ${checkBy}
+theorem ${id}_sound : ∀ (maps : Nat → Nat → Nat) env, FactsHold ${id}_facts env maps → ∀ n ∈ ${id}_nodes, (∀ c ∈ n.hyps, evalC env maps c = true) → evalC env maps n.concl = true :=
+  cyclic_sound ${id}_facts ${id}_nodes ${id}_check
+${tampered.map((t, j) => `-- TAMPERED: ${t.what}. Lean computes the check to false.
+def ${id}_tampered${j} : List CNode := ${nodes(t.proof)}
+example : checkCyclic ${id}_facts ${id}_tampered${j} = false := by ${checkBy}`).join('\n')}${after ? `\n${after(ix, mx)}` : ''}`;
+}