gdp-wired 0.17.0 → 0.19.0

package/dist/kernel/prove.js

@@ -1,5 +1,6 @@
 import { add, k, refuteFast, scale, solve, sub, v } from "../core/solver.js";
-import { crossCyclic, cyclicMachine, cyclicOn, machineNodes, proveCyclic } from "../core/cyclic.js";
+import { checkRefutation } from "../core/check.js";
+import { allowNode, certCyclic, certMs, certOn, certSearch, closingInsts, crossCyclic, cyclicOn, cycLog, hasQuantified, machineNodes, proveCyclic, qflagNodes, reqTS, searchedStepNodes, skMachine, timedKind, withWitness, translatedProof, uncoveredWhy } 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) {
@@ -77,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 = [];
@@ -87,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);
@@ -96,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;
@@ -225,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);
@@ -278,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.
@@ -500,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));
@@ -514,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);
@@ -540,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]));
@@ -1051,9 +1206,9 @@ function triggered(m, laws, inst, build, focus = []) {
 // 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()) {
+export 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 rows = rowsAt(goal, path), n = rows.length, sq = tree.squares?.length ?? 0;
         const mark = (i) => {
             if (i < n) {
                 const s = rows[i].src;
@@ -1207,15 +1362,54 @@ function proveLawsAsGiven(m, laws) {
             focus: [...(law.forall ? [`${law.forall}#`] : []), ...(law.keys ?? [])],
         });
     });
-    const t0 = performance.now(), out = proveThinned(m, laws, { ...instances }), usualMs = performance.now() - t0;
+    // (GDP_CERT=cyclic: a covered machine's certificate is its cyclic proof, core/cyclic.ts's certCyclic; the usual trees
+    // are its input, not checked again)
+    // (what no instance covers, read only where a cyclic mode is on: the usual route's own proofs, inferLaws' trial ones
+    // among them, do nothing more than before)
+    // A machine with a history: its laws are its plain machine's (historyMachine; the record goals leaf goals beside them).
+    const modes = cyclicOn() || certOn(), hist = modes && m.history ? historyMachine(m) : undefined, mc = hist ? hist.machine : m;
+    const why = modes ? uncoveredWhy(mc, laws) : undefined;
+    // (flags that hold at every key: searched, where GDP_CERT_SEARCH=1)
+    const q = why === 'a flag at every key' && certOn() && certSearch(), cert = certOn() && (!why || q);
+    usualCheck.on = !cert || q;
+    const t0 = performance.now(), out = (() => { try {
+        return proveThinned(m, laws, { ...instances });
+    }
+    finally {
+        usualCheck.on = true;
+    } })(), usualMs = performance.now() - t0;
+    if (out.proof)
+        usualProof.last = { m, laws, proof: out.proof };
+    const inst = out.proof?.instances ?? instances;
+    const searched = () => { const { facts, specs } = q ? qflagNodes(mc, laws, inst) : machineNodes(mc, laws, inst); return proveCyclic(facts, specs); };
+    const translated = !q && out.proof ? ((st) => translatedProof(() => JSON.stringify(['machine', mc, laws, inst]), () => timedKind('instance', 0, () => machineNodes(mc, laws, inst, out.proof, st)), st)) : undefined;
     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);
+        if (!why)
+            crossCyclic('machine', m.name, out.proven && out.checked, searched, usualMs, translated);
         else
-            console.error(`cyclic: ${JSON.stringify({ kind: 'machine', name: m.name, usual: out.proven && out.checked, uncovered: true })}`);
+            cycLog({ kind: 'machine', name: m.name, usual: out.proven && out.checked, uncovered: true, why });
+    }
+    if (cert && out.proven && out.proof) {
+        const until = performance.now() + certMs(), c = q ? withDeadline(until, () => certCyclic('machine', m.name, undefined, searched, usualMs)) : certCyclic('machine', m.name, translated, searched, usualMs);
+        if (q && !c.checked)
+            uncovered('machine', m.name, `${why}: no cyclic proof found${performance.now() > until ? ` within ${certMs()} ms` : ''}`);
+        else {
+            // (a history's record goals checked as they are: leaf goals)
+            const records = !hist || hist.goals.every(g => out.proof.trees[g.name] !== undefined && check(g, out.proof.trees[g.name]));
+            out.checked = c.checked && records;
+            Object.assign(out.proof, { cyclic: c.proof });
+        }
     }
+    else if (certOn() && why && out.proven)
+        cycLog({ kind: 'machine', name: m.name, cert: true, uncovered: true, why });
     return out;
 }
+// A proof of a kind no cyclic instance covers, counted (`cyclic: {..., uncovered: true}`).
+const uncovered = (kind, name, why) => cycLog({ kind, name, uncovered: true, why });
+// Whether the usual proof's trees are checked (off while GDP_CERT=cyclic makes the certificate a cyclic proof).
+export const usualCheck = { on: true };
+// The last machine proof made (core/dsl.ts's recurrences read their machine's, to translate it: core/cyclic.ts).
+export const usualProof = {};
 // 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 };
@@ -1261,7 +1455,7 @@ function proveThinned(m, laws, instances) {
         leaves += countLeaves(out.tree);
     }
     const proof = { instances, trees };
-    return { proven: true, nodes, leaves, checked: checkLaws(m, laws, proof), proof };
+    return { proven: true, nodes, leaves, checked: !usualCheck.on || checkLaws(m, laws, proof), proof };
 }
 // Every goal of the laws with these instances.
 function proveWith(m, laws, instances) {
@@ -1276,7 +1470,7 @@ function proveWith(m, laws, instances) {
         leaves += countLeaves(out.tree);
     }
     const proof = { instances, trees };
-    return { proven: true, nodes, leaves, checked: checkLaws(m, laws, proof), proof };
+    return { proven: true, nodes, leaves, checked: !usualCheck.on || checkLaws(m, laws, proof), proof };
 }
 export function proveStepLaws(m, given, stepLaws) {
     const base = proveLaws(m, given);
@@ -1296,6 +1490,7 @@ export function proveStepLaws(m, given, stepLaws) {
 function proveStepLawsAsGiven(m, laws, stepLaws, base) {
     if (!base.proof)
         return { proven: false, nodes: base.nodes, leaves: base.leaves, checked: false };
+    const t0 = performance.now();
     const plain = m.history ? historyMachine(m).machine : m;
     // 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
@@ -1350,12 +1545,44 @@ function proveStepLawsAsGiven(m, laws, stepLaws, base) {
             leaves += countLeaves(out.tree);
         }
     const proof = { laws: base.proof, instances, ...(Object.keys(perStep).length ? { perStep } : {}), trees };
-    return { proven: true, nodes, leaves, checked: checkStepLaws(m, laws, stepLaws, proof), proof };
+    const out = { proven: true, nodes, leaves, checked: checkStepLaws(m, laws, stepLaws, proof), proof };
+    // Step laws of a machine the cyclic instances cover (one step, or several over no map) are translated with the laws
+    // (core/cyclic.ts); the rest are counted as no instance's.
+    if (!cyclicOn() && !certOn())
+        return out;
+    // (a machine with a history: its plain machine's; flags at every key and k-step laws over a map searched, where
+    // GDP_CERT_SEARCH=1)
+    const why = uncoveredWhy(plain, laws), one = stepLaws.filter(sl => (sl.steps ?? 1) === 1 || (!Object.keys(plain.maps ?? {}).length && !plain.inputMaps?.length));
+    if (!why && one.length && out.checked) {
+        const steps = one.map(sl => { const inst = perStep[sl.name] ?? instances, goal = stepLawObligations(m, laws, inst, sl)[0]; return { sl, inst, goal, tree: trees[goal.name] }; });
+        const translated = (st) => translatedProof(() => JSON.stringify(['steps', plain, laws, base.proof.instances, steps.map(x => [x.sl, x.inst])]), reused => timedKind('instance', 0, () => machineNodes(plain, laws, base.proof.instances, { trees: base.proof.trees, steps, lawsMade: reused }, st)), st, () => JSON.stringify(['machine', plain, laws, base.proof.instances]));
+        const usualMs = performance.now() - t0;
+        if (cyclicOn())
+            crossCyclic('step law', m.name, true, undefined, usualMs, translated);
+        if (certOn())
+            out.checked = certCyclic('step law', m.name, translated, undefined, usualMs).checked;
+    }
+    const rest = stepLaws.filter(sl => why || !one.includes(sl));
+    if (certOn() && certSearch() && out.checked && rest.length && (!why || why === 'a flag at every key')) {
+        // The rest searched: the laws' nodes (searched), each step law's node (core/cyclic.ts's stepLawNodes).
+        const searchedSteps = () => {
+            const b = why ? qflagNodes(plain, laws, base.proof.instances) : machineNodes(plain, laws, base.proof.instances);
+            return proveCyclic(b.facts, [...b.specs, ...searchedStepNodes(plain, laws, rest.map(sl => ({ law: sl, instances: perStep[sl.name] ?? instances })), b.facts, b.specs)]);
+        };
+        const until = performance.now() + certMs(), c = withDeadline(until, () => certCyclic('step law', m.name, undefined, searchedSteps, performance.now() - t0));
+        const none = `no cyclic proof found${performance.now() > until ? ` within ${certMs()} ms` : ''}`;
+        for (const sl of c.checked ? [] : rest)
+            uncovered((sl.steps ?? 1) > 1 ? 'k-step law' : 'step law', m.name, `${why ?? `${sl.steps} steps over a map`}: ${none}`);
+    }
+    else if (cyclicOn() || certOn())
+        for (const sl of rest)
+            uncovered((sl.steps ?? 1) > 1 ? 'k-step law' : 'step law', m.name, why ?? `${sl.steps} steps over a map`);
+    return out;
 }
 // Progress (kernel.ts's progressObligations): the laws proven first, then each goal, the every-key laws assumed at every
 // key the goals read a map at.
 export function proveProgress(m, laws, p) {
-    const base = proveLaws(m, laws);
+    const t0 = performance.now(), base = proveLaws(m, laws);
     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;
@@ -1370,12 +1597,42 @@ export function proveProgress(m, laws, p) {
         nodes += out.nodes;
         leaves += countLeaves(out.tree);
     }
-    return { proven: true, nodes, leaves, checked: progressObligations(m, ls, instances, p).every(g => check(g, trees[g.name])), instances, trees };
+    const checked = progressObligations(m, ls, instances, p).every(g => check(g, trees[g.name]));
+    // (GDP_CERT=cyclic with GDP_CERT_SEARCH=1: a request allowed whose claim is that alone, over a machine without a history
+    // or carried maps, gets core/cyclic.ts's allowNode after the laws' nodes, BridgeRules.lean's cycAOk: from every
+    // reachable state, every request meeting the region, its terms and the witnesses withWitness finds is allowed)
+    const alone = JSON.stringify(p.then) === JSON.stringify(trueC) && !m.history && !m.inputMaps?.length && m.assume !== undefined;
+    if (certOn() && certSearch() && alone && checked && base.proof) {
+        const until = performance.now() + certMs(), lp = base.proof, q = hasQuantified(m);
+        const allowed = () => {
+            const b = q ? qflagNodes(m, ls, lp.instances) : machineNodes(m, ls, lp.instances, lp);
+            if (b.why || (b.specs[0]?.rank.length ?? 2) < 2)
+                return { proven: false, checked: false, node: m.name, goal: 'allowed', stuck: b.why ?? 'laws ranked by time alone' };
+            let last = { proven: false, checked: false, node: m.name, goal: 'allowed', stuck: 'no witness' };
+            const found = withWitness(m, p.request, wit => {
+                if (performance.now() > until)
+                    return undefined;
+                const w = { op: 'and', xs: [p.when, reqTS(Object.entries(p.request)), reqTS(wit)] };
+                const spec = allowNode(skMachine(m), ls, instances, w, b.facts, b.specs, `${m.name}: allowed`, q ? closingInsts(m, b.facts, [instances, ...Object.values(lp.instances)], [{ op: 'var', name: 't$' }], ls) : []);
+                last = proveCyclic(b.facts, [...b.specs, spec]);
+                return last.proven && last.checked ? last : undefined;
+            });
+            return found?.out ?? last;
+        };
+        const c = withDeadline(until, () => certCyclic('progress', m.name, undefined, allowed, performance.now() - t0));
+        if (!c.checked)
+            uncovered('progress', m.name, `a request allowed: no cyclic proof found${performance.now() > until ? ` within ${certMs()} ms` : ''}`);
+    }
+    else if (cyclicOn() || certOn())
+        uncovered('progress', m.name, alone ? 'a request allowed' : 'a request allowed and a claim after it');
+    return { proven: true, nodes, leaves, checked, instances, trees };
 }
 // Liveness (kernel.ts's livenessParts): its step laws, proven together. The claim needs no more (a run takes the
 // request, so it is allowed); but a request never allowed would leave the claim about no run, so where a helpful request
 // names every input a client sends and carries no maps, it is proven allowed in its region too.
 export function proveLiveness(m, laws, l) {
+    if (cyclicOn() || certOn())
+        uncovered('liveness', m.name, 'a claim about runs that never end');
     const { stay, cover, helps } = livenessParts(m, l);
     const a = proveStepLaws(m, laws, [stay, cover, ...helps]);
     if (!a.proven || !a.checked)

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

@@ -37,6 +37,7 @@ export declare function readable(id: string, laws: Law[], vars: string[], maps:
     binders: string;
     hyp: string;
     call: string;
+    have?: (j: number) => string;
 }): string;
 export type ProgressCase = {
     id: string;
@@ -61,6 +62,10 @@ export declare function mmachineToLean(id: string, m: Machine, laws: Law[], opts
     stepLaws?: StepLaw[];
 }): string;
 export declare const hasSets: (m: Machine) => boolean;
+export declare function machineLit(mm: Machine, t: {
+    e: (x: E) => string;
+    c: (x: C) => string;
+}, ix: (name: string) => number, mx: (name: string) => number): string;
 export declare function smachineToLean(id: string, given: Machine, laws: Law[], opts?: {
     stepLaws?: StepLaw[];
     liveness?: Liveness[];
@@ -96,6 +101,39 @@ export declare function smachineToLean(id: string, given: Machine, laws: Law[],
     };
     noFacts?: boolean;
 }): string;
+export declare const cyclicCerts: () => boolean;
+export declare const certReport: {
+    cyclic: string[];
+    usual: {
+        id: string;
+        why: string;
+    }[];
+    translatedSteps: string[];
+};
+export declare function cycMachineToLean(id: string, given: Machine, laws: Law[], opts?: {
+    stepLaws?: StepLaw[];
+    liveness?: Liveness[];
+    simp?: string[];
+    free?: string[];
+    ghosts?: string[];
+    after?: (ix: (name: string) => number) => string;
+    loop?: {
+        loop: Loop;
+    };
+    noFacts?: boolean;
+    refined?: {
+        impl: Machine;
+        spec: Machine;
+        wit: Record<string, E>;
+        stutter: C;
+        specPre: number;
+        step: StepLaw;
+    };
+}): {
+    text: string;
+} | {
+    why: string;
+};
 type Uses = Record<string, {
     lean?: string;
     recur?: Recurrence;
@@ -152,15 +190,71 @@ export type LeanItem = {
         proof: Cyclic;
     }[];
     after?: (ix: (name: string) => number, mx: (map: string) => number) => string;
+    bridge?: CycBridge;
+    recur?: CycRecur;
+    fold?: {
+        fold: Fold;
+        laws: Law[];
+    };
+    data?: true;
 };
 export declare function toLean(items: LeanItem[], opts?: {
     title?: string;
     native?: boolean;
+    cyclic?: boolean;
 }): string;
 export declare function leanProject(file: string, opts?: {
     name?: string;
 }): Record<string, string>;
+export type CycBridge = {
+    machine: Machine;
+    laws: Law[];
+    tampered?: {
+        what: string;
+        machine: Machine;
+    }[];
+};
+export type CycRecur = {
+    name: string;
+    args: string[];
+    zero: E;
+    next: E;
+    lemmas: {
+        name: string;
+        holds: C;
+    }[];
+    between: {
+        name: string;
+        holds: C;
+    }[];
+};
 export declare function cyclicToLean(id: string, p: Cyclic, tampered?: {
     what: string;
     proof: Cyclic;
-}[], after?: (ix: (name: string) => number, mx: (map: string) => number) => string): string;
+}[], after?: (ix: (name: string) => number, mx: (map: string) => number) => string, bridge?: CycBridge, recur?: CycRecur, fold?: {
+    fold: Fold;
+    laws: Law[];
+}): string;
+export declare function cycEncodingLean(id: string, facts: {
+    name: string;
+    keys: string[];
+    holds: C;
+}[], nodes: {
+    name: string;
+    hyps: C[];
+    concl: C;
+}[], b: CycBridge): string;
+export declare function cycRecurCheckLean(id: string, facts: {
+    name: string;
+    keys: string[];
+    holds: C;
+}[], r: CycRecur): string;
+export declare function cycFoldCheckLean(id: string, facts: {
+    name: string;
+    keys: string[];
+    holds: C;
+}[], nodes: {
+    name: string;
+    hyps: C[];
+    concl: C;
+}[], f: Fold, laws: Law[]): string;