gdp-wired 0.3.0 → 0.5.0

package/dist/kernel/prove.js

@@ -1,5 +1,5 @@
-import { add, k, scale, solve, sub } from "../core/solver.js";
-import { canon, check, checkLaws, checkStepLaws, historyMachine, leafConstraints, linear, livenessHelpful, livenessParts, obligations, plainKey, progressObligations, stepLawObligations, trueC, truth, unreachable, withProducts } from "./kernel.js";
+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";
 // The atoms the path leaves open, in evaluation order: deciding any of them makes progress.
 function openE(e, path, out) {
     switch (e.op) {
@@ -22,7 +22,7 @@ function openE(e, path, out) {
         case 'max': {
             openE(e.a, path, out), openE(e.b, path, out);
             const a = linear(e.a, path), b = linear(e.b, path);
-            if (a && b && linear(e, path) === undefined)
+            if (a && b && !decided(e, path))
                 out.push(e.op === 'sub' ? sub(b, a) : sub(a, b));
             return;
         }
@@ -116,12 +116,34 @@ function parse(text) {
 // 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) }) {
+    // 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) {
+        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))) });
+        if ('tree' in plain || plain.stuck === 'sat' || plain.why === undefined)
+            return plain;
+        const cut = withCuts(goal, path, budget);
+        if (cut)
+            return cut;
+    }
+    return growPlain(goal, path, budget);
+}
+function growPlain(goal, path, budget) {
+    if (budget.cap !== undefined && budget.nodes >= budget.cap)
+        return { stuck: 'unknown', path, why: 'cap' };
     if (++budget.nodes > 200_000 || (budget.until !== undefined && performance.now() > budget.until))
-        return { stuck: 'unknown', path };
-    const rows = leafConstraints(goal, path);
+        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 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: { leaf: verdict.steps }, nodes: budget.nodes };
+        return { tree: leafOf(verdict.steps), nodes: budget.nodes };
     const open = [];
     for (const h of goal.hyps)
         openH(h, path, open);
@@ -148,7 +170,7 @@ export function grow(goal, path = new Map(), budget = { nodes: 0, until: perform
         pairs.splice(300);
         const product = solve(withProducts(rows, pairs));
         if (product.kind === 'refuted')
-            return { tree: { leaf: product.steps, products: pairs }, nodes: budget.nodes };
+            return { tree: leafOf(product.steps, pairs), nodes: budget.nodes };
         // Degree three: each row times each product of two variables (x·y >= 0 is the pair of -x <= 0 and -y <= 0).
         const degree = Math.max(...rows.flatMap(r => Object.keys(r.lin).map(key => (key === '1' ? 0 : key.split('*').length))));
         if (degree >= 3) {
@@ -159,7 +181,7 @@ export function grow(goal, path = new Map(), budget = { nodes: 0, until: perform
                     cubes.push([rows.length + s, i]);
             const third = solve(withProducts(rows, [...sq, ...cubes]));
             if (third.kind === 'refuted')
-                return { tree: { leaf: third.steps, products: [...sq, ...cubes] }, nodes: budget.nodes };
+                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))));
@@ -174,14 +196,105 @@ export function grow(goal, path = new Map(), budget = { nodes: 0, until: perform
     if (!split)
         return { stuck: verdict.kind === 'sat' ? 'sat' : 'unknown', ...(verdict.kind === 'sat' ? { witness: verdict.witness } : {}), path };
     const id = canon(split);
-    const yes = grow(goal, new Map(path).set(id, { lin: split, holds: true }), budget);
+    const yes = growPlain(goal, new Map(path).set(id, { lin: split, holds: true }), budget);
+    if (!('tree' in yes))
+        return yes;
+    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 };
+}
+// 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);
+    return `the prover's ${limit === 'nodes' ? '200,000-node' : 'time'} budget ran out at ${goal.hyps.length} hypotheses, ${depth} case splits deep. ` +
+        `Each case a step decides multiplies the cases to refute, so ${steps > 1 ? `a law over ${steps} steps` : 'many interacting cases'} can outgrow it: ` +
+        'state the law over fewer steps (a one-step law and an invariant often give the same), or split it into laws about fewer conditions';
+}
+// Cuts: where each of many choices (a step's case, over a run of k steps) multiplies the cases, a fact about each
+// choice's value that holds whichever way it goes is split on first: its failing side is refuted by deciding that
+// choice alone, and the rest of the proof assumes it, so the tree is a chain of small refutations instead of every
+// combination. For a term column t = if c then A else B the candidates are t ≤ A, t ≤ B, t ≥ A and t ≥ B, innermost
+// choices first; a cut is only a split, so the kernel checks it like any other.
+function withCuts(goal, path, budget) {
+    const rows = leafConstraints(goal, path);
+    const columns = [...new Set(rows.flatMap(r => Object.keys(r.lin)).filter(n => n.startsWith('⟦')))]
+        .map(n => ({ n, e: columnTerm(n) })).filter(x => x.e.op === 'if' && !decided(x.e, path))
+        .sort((a, b) => Number(a.n.slice(1, -1)) - Number(b.n.slice(1, -1))); // a term's parts get their ids before it: innermost first
+    const chain = [];
+    let at = new Map(path);
+    for (const { n, e } of columns) {
+        if (e.op !== 'if')
+            continue;
+        const a = linear(e.then, at), b = linear(e.else, at), focus = topAtoms(e.c, at);
+        if (!a || !b || !focus.length)
+            continue;
+        for (const lemma of [sub(v(n), a), sub(v(n), b), sub(a, v(n)), sub(b, v(n))]) {
+            const id = canon(lemma);
+            if (at.has(id) || Object.keys(lemma).every(key => key === '1'))
+                continue;
+            const no = growFocused(goal, new Map(at).set(id, { lin: lemma, holds: false }), focus, { nodes: 0 });
+            if ('tree' in no) {
+                chain.push({ split: lemma, no: no.tree });
+                at = new Map(at).set(id, { lin: lemma, holds: true });
+            }
+        }
+    }
+    if (!chain.length)
+        return undefined;
+    const rest = growPlain(goal, at, budget);
+    if (!('tree' in rest))
+        return rest;
+    return { tree: chain.reduceRight((acc, c) => ({ split: c.split, yes: acc, no: c.no }), rest.tree), nodes: budget.nodes };
+}
+// A condition's own comparisons, each a split atom, read with term columns for whatever choices are inside it.
+function topAtoms(c, path) {
+    if (c.op === 'not')
+        return topAtoms(c.x, path);
+    if (c.op === 'and' || c.op === 'or')
+        return c.xs.flatMap(y => topAtoms(y, path));
+    if (c.op === 'flag' || c.op === 'all')
+        return [];
+    const a = linear(c.a, path), b = linear(c.b, 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)))));
+}
+// 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) {
+    if (++budget.nodes > 64)
+        return { stuck: 'unknown', path };
+    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)))));
+    if (!split)
+        return { stuck: verdict.kind === 'sat' ? 'sat' : 'unknown', path };
+    const id = canon(split);
+    const yes = growFocused(goal, new Map(path).set(id, { lin: split, holds: true }), focus, budget, near);
     if (!('tree' in yes))
         return yes;
-    const no = grow(goal, new Map(path).set(id, { lin: split, holds: false }), budget);
+    const no = growFocused(goal, new Map(path).set(id, { lin: split, holds: false }), focus, budget, near);
     if (!('tree' in no))
         return no;
     return { tree: { split, yes: yes.tree, no: no.tree }, nodes: budget.nodes };
 }
+// A refutation from the rows near some facts (the rows reachable from their variables in two hops, each row joining the
+// variables it reads), its inputs renumbered to the whole leaf's. A cut about one step of a long run needs that step's
+// rows, not the run's; a cut it misses is only a cut not made (the plain search still follows).
+function solveNear(rows, seeds) {
+    const reach = new Set(seeds.flatMap(l => Object.keys(l).filter(key => key !== '1')));
+    for (let hop = 0; hop < 2; hop++)
+        for (const r of rows) {
+            const keys = Object.keys(r.lin).filter(key => key !== '1');
+            if (keys.some(key => reach.has(key)))
+                keys.forEach(key => reach.add(key));
+        }
+    const picked = rows.flatMap((r, i) => (Object.keys(r.lin).every(key => key === '1' || reach.has(key)) ? [i] : []));
+    const near = solve(picked.map(i => rows[i]));
+    return near.kind === 'refuted' ? { kind: 'refuted', steps: near.steps.map(st => (st.kind === 'input' ? { ...st, index: picked[st.index] } : st)) } : near;
+}
 // Integer completeness for bounded systems: when elimination is inexact and finds no witness, halve a variable's range
 // (x <= mid or x >= mid + 1). Each half is a split like any other, so the kernel checks it the same way; a variable
 // pinned to one value becomes an equality, which the solver substitutes exactly.
@@ -363,6 +476,42 @@ function match(pattern, term, x) {
 const witnesses = (m) => Object.entries(m.step.flags ?? {}).flatMap(([f, c]) => (c.op === 'all' ? [{ op: 'var', name: `w?${f}` }] : []));
 // The keys each quantified flag is assumed at (instances under ?f).
 const flagInstances = (m, keys) => Object.fromEntries(Object.entries(m.step.flags ?? {}).flatMap(([f, c]) => (c.op === 'all' ? [[`?${f}`, keys]] : [])));
+// The instances some goals need, for every entry point: the every-key laws and the quantified flags at `seed` (the keys
+// the step and the laws read, when known before any goal is built), then twice round: the facts at every key the goals
+// built so far read a function at, and, where the seed doesn't cover them (no seed, positions that shift, a law about
+// several keys), the every-key laws and flags at every key they read a map at (a law about several keys at tuples
+// relating `focus`, the goals' own keys).
+function instancesFor(m, laws, build, opts = {}) {
+    let inst = opts.start ?? (opts.seed ? { ...Object.fromEntries(laws.filter(l => l.forall).map(l => [l.name, l.keys?.length ? [] : opts.seed])), ...flagInstances(m, opts.seed) } : {});
+    const reads = opts.reads ?? (!opts.seed || shifts(m) || laws.some(l => l.keys?.length));
+    for (let round = 0; round < 2; round++) {
+        if (m.facts?.length)
+            inst = withFacts(m, inst, fnKeys(m, build(inst)));
+        if (reads) {
+            const keys = mapKeys(build(inst));
+            inst = union(withReads(laws, inst, keys, opts.focus ?? []), flagInstances(m, keys));
+        }
+    }
+    return inst;
+}
+// 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) => {
+    const bad = (e) => names.some(n => JSON.stringify(e).includes(`"name":${JSON.stringify(n)}`));
+    return Object.fromEntries(Object.entries(inst).map(([n, keys]) => {
+        const arity = (laws.find(l => l.name === n)?.keys?.length ?? 0) + 1;
+        const tuples = Array.from({ length: Math.floor(keys.length / arity) }, (_, t) => keys.slice(t * arity, (t + 1) * arity));
+        return [n, tuples.filter(tuple => !tuple.some(bad)).flat()];
+    }));
+};
+// Two sets of instances together: each name at the keys of both.
+const union = (a, b) => {
+    const out = { ...a };
+    for (const [n, keys] of Object.entries(b)) {
+        const seen = new Set((out[n] ?? []).map(e => JSON.stringify(e)));
+        out[n] = [...(out[n] ?? []), ...keys.filter(e => !seen.has(JSON.stringify(e)))];
+    }
+    return out;
+};
 const someKeys = (c, positive = true) => c.op === 'all' ? [...(positive ? [] : [c]), ...someKeys(c.c, positive)] : c.op === 'not' ? someKeys(c.x, !positive) : c.op === 'and' || c.op === 'or' ? c.xs.flatMap(y => someKeys(y, positive)) : [];
 function atWitness(c, picks, positive = true) {
     switch (c.op) {
@@ -427,29 +576,20 @@ export function proveLaws(m, laws) {
     return { ...proveLawsAsGiven(m, out.items), laws: out.items };
 }
 function proveLawsAsGiven(m, laws) {
-    const keys = [...readKeys(m, laws), ...witnesses(m)];
-    const instances = {};
-    for (const law of laws) {
-        const at = [...keys, ...(law.forall ? [{ op: 'var', name: `${law.forall}#` }] : []), ...(law.keys ?? []).map((name) => ({ op: 'var', name }))];
-        instances[law.name] = { ...Object.fromEntries(laws.filter(l => l.forall).map(l => [l.name, l.keys?.length ? [] : at])), ...flagInstances(m, at) };
-    }
-    // The facts about functions, at every key each law's goals read a function at (found from the goals, twice round).
-    for (let round = 0; round < 2 && m.facts?.length; round++) {
-        const goals = obligations(m, laws, instances);
-        laws.forEach((law, i) => { instances[law.name] = withFacts(m, instances[law.name], fnKeys(m, goals.slice(2 * i, 2 * i + 2))); });
-    }
-    // Where positions shift (a write at every key reading its key at k ∸ 1 or k + 1) or a law is about two keys, the
-    // every-key laws also at each key the goals read a map at, once round.
-    if (shifts(m) || laws.some(l => l.keys?.length)) {
-        const goals = obligations(m, laws, instances);
-        laws.forEach((law, i) => { instances[law.name] = withReads(laws, instances[law.name], mapKeys(goals.slice(2 * i, 2 * i + 2)), [...(law.forall ? [`${law.forall}#`] : []), ...(law.keys ?? [])]); });
-    }
+    // 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), {
+            seed: [...keys, ...(law.forall ? [{ op: 'var', name: `${law.forall}#` }] : []), ...(law.keys ?? []).map((name) => ({ op: 'var', name }))],
+            focus: [...(law.forall ? [`${law.forall}#`] : []), ...(law.keys ?? [])],
+        });
+    });
     const trees = {};
     let nodes = 0, leaves = 0;
     for (const goal of obligations(m, laws, instances)) {
         const out = grow(goal);
         if (!('tree' in out))
-            return { proven: false, nodes, leaves, failed: { goal: goal.name, stuck: out.stuck, ...(out.witness ? { witness: out.witness } : {}) }, checked: false };
+            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);
@@ -476,23 +616,26 @@ function proveStepLawsAsGiven(m, laws, stepLaws, base) {
     if (!base.proof)
         return { proven: false, nodes: base.nodes, leaves: base.leaves, checked: false };
     const plain = m.history ? historyMachine(m).machine : m;
-    const keys = [...readKeys(plain, laws), ...witnesses(plain), ...stepLaws.flatMap(sl => [sl.then, ...(sl.when === undefined ? [] : Array.isArray(sl.when) ? sl.when : [sl.when])].flatMap(readKeysC)),
-        ...stepLaws.flatMap(sl => [sl.forall, ...(sl.keys ?? [])].flatMap(key => (key ? [{ op: 'var', name: key }] : [])))];
-    let instances = { ...Object.fromEntries(laws.filter(l => l.forall).map(l => [l.name, l.keys?.length ? [] : keys])), ...flagInstances(plain, keys) };
-    for (let round = 0; round < 2 && plain.facts?.length; round++)
-        instances = withFacts(plain, instances, fnKeys(plain, stepLaws.flatMap(sl => stepLawObligations(m, laws, instances, sl))));
-    // Where positions shift or a law is about two keys, each step law gets its own instances, from its own goal.
+    // Each step law its own instances, from its own goal: the keys the step and the laws read, and its own (a k-step
+    // law's later frames read keys no other step law has); where positions shift or a law is about several keys, the
+    // keys its goal reads a map at too. A frame's hypotheses read no name the run introduces later (kernel.ts's
+    // stepZone), so a k-step law drops the keys that read one.
+    const shared = [...readKeys(plain, laws), ...witnesses(plain)], named = [...laws, ...(plain.facts ?? [])], reads = shifts(plain) || laws.some(l => l.keys?.length);
+    const own = (sl) => [...[sl.then, ...(sl.when === undefined ? [] : Array.isArray(sl.when) ? sl.when : [sl.when])].flatMap(readKeysC),
+        ...[sl.forall, ...(sl.keys ?? [])].flatMap(key => (key ? [{ op: 'var', name: key }] : []))];
     const perStep = {};
-    if (shifts(plain) || laws.some(l => l.keys?.length))
-        for (const sl of stepLaws)
-            perStep[sl.name] = withReads(laws, instances, mapKeys(stepLawObligations(m, laws, instances, sl)), [sl.forall, ...(sl.keys ?? [])].flatMap(k => (k ? [k] : [])));
+    for (const sl of stepLaws) {
+        const zone = stepZone(plain, sl.steps ?? 1), keep = (inst) => avoiding(inst, zone, named);
+        perStep[sl.name] = keep(instancesFor(plain, laws, inst => stepLawObligations(m, laws, keep(inst), sl), { seed: [...shared, ...own(sl)], focus: [sl.forall, ...(sl.keys ?? [])].flatMap(k => (k ? [k] : [])), reads }));
+    }
+    const instances = perStep[stepLaws[0]?.name ?? ''] ?? {};
     const trees = {};
     let nodes = base.nodes, leaves = base.leaves;
     for (const sl of stepLaws)
         for (const goal of stepLawObligations(m, laws, perStep[sl.name] ?? instances, sl)) {
             const out = grow(goal);
             if (!('tree' in out))
-                return { proven: false, nodes, leaves, failed: { goal: goal.name, stuck: out.stuck, ...(out.witness ? { witness: out.witness } : {}) }, checked: false };
+                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);
@@ -507,16 +650,13 @@ export function proveProgress(m, laws, p) {
     if (!base.proven || !base.checked)
         return { proven: false, nodes: base.nodes, leaves: base.leaves, ...(base.failed ? { failed: base.failed } : {}), checked: false };
     const ls = base.laws ?? laws;
-    let instances = { ...withReads(ls, {}, mapKeys(progressObligations(m, ls, {}, p)), []), ...flagInstances(m, mapKeys(progressObligations(m, ls, {}, p))) };
-    instances = { ...instances, ...withReads(ls, instances, mapKeys(progressObligations(m, ls, instances, p)), []) };
-    if (m.facts?.length)
-        instances = withFacts(m, instances, fnKeys(m, progressObligations(m, ls, instances, p)));
+    const instances = instancesFor(m, ls, inst => progressObligations(m, ls, inst, p));
     const trees = {};
     let nodes = base.nodes, leaves = base.leaves;
     for (const goal of progressObligations(m, ls, instances, p)) {
         const out = grow(goal);
         if (!('tree' in out))
-            return { proven: false, nodes, leaves, failed: { goal: goal.name, stuck: out.stuck, ...(out.witness ? { witness: out.witness } : {}) }, checked: false };
+            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);
@@ -562,7 +702,7 @@ function readKeysC(c) {
 export const countLeaves = (t) => ('leaf' in t ? 1 : countLeaves(t.yes) + countLeaves(t.no));
 // A real counterexample for a goal the prover couldn't close (with products, its witness may be abstract): the free
 // variables over 0..bound, every hypothesis evaluated with true arithmetic. Goals that read maps are left to the
-// machine searches (search/), which run whole histories.
+// machine searches (research/search/), which run whole histories.
 export function concretize(goal, bound = 12) {
     const names = new Set();
     let reads = false;
@@ -604,16 +744,15 @@ export function concretize(goal, bound = 12) {
     }
     return undefined;
 }
+// The facts a goal needs, as hypotheses: each fact about every key at the keys the goal reads a function at (and at
+// the keys those facts read, a second round), each plain fact as it is.
+export function factsFor(m, goal) {
+    return assumed(m.facts ?? [], instancesFor(m, [], inst => [{ ...goal, hyps: [...assumed(m.facts ?? [], inst), ...goal.hyps] }]));
+}
 // A goal built from its instances (an exporter's goal, shaped as its Lean twin builds it): the every-key laws, the
 // quantified flags and the facts assumed at every key it reads a map or function at, then a tree, checked.
 export function proveBuilt(m, laws, build) {
-    let instances = {};
-    for (let round = 0; round < 2; round++) {
-        const g = build(instances), keys = mapKeys([g]);
-        instances = { ...withReads(laws, instances, keys, []), ...flagInstances(m, keys) };
-        if (m.facts?.length)
-            instances = withFacts(m, instances, fnKeys(m, [build(instances)]));
-    }
+    const instances = instancesFor(m, laws, inst => [build(inst)]);
     const goal = build(instances), out = grow(goal);
     if (!('tree' in out) || !check(goal, out.tree))
         return { proven: false };

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

@@ -57,16 +57,6 @@ export declare function mmachineToLean(id: string, m: Machine, laws: Law[], opts
     progress?: ProgressCase[];
     free?: string[];
     stepLaws?: StepLaw[];
-    liveness?: Liveness[];
-    ghosts?: string[];
-    after?: (ix: (name: string) => number) => string;
-    refined?: {
-        impl: Machine;
-        spec: Machine;
-        wit: Record<string, E>;
-        stutter: C;
-        specPre: number;
-    };
 }): string;
 export declare const hasSets: (m: Machine) => boolean;
 export declare function smachineToLean(id: string, m: Machine, laws: Law[], opts?: {
@@ -78,6 +68,8 @@ export declare function smachineToLean(id: string, m: Machine, laws: Law[], opts
     };
     simp?: string[];
     free?: string[];
+    ghosts?: string[];
+    after?: (ix: (name: string) => number) => string;
     refined?: {
         impl: Machine;
         spec: Machine;