gdp-wired 0.18.0 → 0.20.0

package/dist/lean-kernel/emit.js

@@ -1,10 +1,11 @@
 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, minimal, proveBuilt, proveLaws, proveStepLaws } from "../kernel/prove.js";
+import { grow, minimal, proveBuilt, proveLaws, proveStepLaws, withDeadline } 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 { allowNode, certMs, closingInsts, reqTS, withWitness, foldNodes, certMode, quietly, uncoveredWhy, hasQuantified, kWhens, machineNodes, proveCyclic, routeOf, searchedStepNodes, skMachine, stepLawNodes, tBack, tSub } from "../core/cyclic.js";
 import { leanLibrary } from "./library.js";
 export { leanLibrary };
 // --- to Lean ------------------------------------------------------------------------------------------------------------
@@ -48,8 +49,34 @@ export function leaves(t, path, visit) {
     leaves(t.yes, new Map(path).set(id, { lin: t.split, holds: true }), visit);
     leaves(t.no, new Map(path).set(id, { lin: t.split, holds: false }), visit);
 }
-export function encode(ex, tamper = false, dropStep = true, globalVars, globalMaps) {
+export function encode(ex, tamper = false, dropStep = true, globalVars, globalMaps, slim = false) {
     const { goal, tree } = ex;
+    // `slim`: the table only has the columns Lean reads. Each row a leaf uses has a hint (where Lean looks for it first),
+    // and Lean computes only the hinted hypotheses' linear forms (Kernel.lean's srcRows), so the columns are the
+    // variables, those hypotheses' choices and the cells they read, a hinted term column's, and every row's (the path's
+    // atoms, the leaf's rows, its squares and products). A leaf with a row of no hint (Lean then reads every
+    // hypothesis's rows) keeps the whole table. A premise or descent of a cyclic node reads one or two of its
+    // hypotheses, so its table is a few columns, not every choice of the node's facts.
+    // Each leaf with its path and rows, found once (the passes below and the tree's text read them in the same order).
+    const leafList = [];
+    leaves(tree, new Map(), (leaf, path) => { leafList.push({ leaf, path, base: leafConstraints(goal, path) }); });
+    const reads = new Set(), hintTerms = new Set();
+    let whole = !slim;
+    if (slim)
+        for (const { leaf, base } of leafList) {
+            const n0 = base.length;
+            for (const i of [...leaf.leaf.flatMap(st => (st.kind === 'input' && st.index < n0 ? [st.index] : [])), ...(leaf.products ?? []).flat().filter(i => i < n0)]) {
+                const src = base[i].src;
+                if (!src)
+                    whole = true;
+                else if ('fact' in src)
+                    reads.add(src.fact);
+                else if ('term' in src)
+                    hintTerms.add(src.term);
+            }
+        }
+    const readHyps = whole ? goal.hyps : goal.hyps.filter((_, i) => reads.has(i));
+    const readTerms = whole ? [] : [...hintTerms].map(name => columnTerm(name));
     // Columns: every variable of the hypotheses, then every cell any leaf uses (and the cells inside their keys),
     // shallower cells first so a key reads only earlier columns.
     const vars = globalVars ?? [...new Set(goal.hyps.flatMap(varsOf))];
@@ -101,9 +128,15 @@ export function encode(ex, tamper = false, dropStep = true, globalVars, globalMa
             else if (typeof val === 'object' && val !== null)
                 choices(val);
     };
-    goal.hyps.forEach(choices);
-    leaves(tree, new Map(), (leaf, path) => {
-        for (const r of [...withProducts(leafConstraints(goal, path), leaf.products ?? [], leaf.squares), ...(leaf.squares ?? []).map(lin => ({ lin }))])
+    readHyps.forEach(choices);
+    readTerms.forEach(choices);
+    const readSubterms = [...readHyps, ...readTerms.map((t) => ({ op: '<=', a: t, b: t }))].flatMap(subterms).filter(e => e.op === 'prod' || e.op === 'get');
+    for (const { leaf, path, base } of leafList) {
+        const n0 = base.length;
+        const used = whole ? undefined : new Set([...leaf.leaf.flatMap(st => (st.kind === 'input' && st.index < n0 ? [st.index] : [])), ...(leaf.products ?? []).flat().filter(i => i < n0)]);
+        const rowsHere = whole ? withProducts(base, leaf.products ?? [], leaf.squares)
+            : [...base.filter((_, i) => used.has(i)), ...withProducts(base, leaf.products ?? [], leaf.squares).slice(n0), ...[...path.values()].map(a => ({ lin: a.lin }))];
+        for (const r of [...rowsHere, ...(leaf.squares ?? []).map(lin => ({ lin }))])
             for (const key of Object.keys(r.lin)) {
                 if (isMonomial(key))
                     addMono(key);
@@ -114,18 +147,17 @@ export function encode(ex, tamper = false, dropStep = true, globalVars, globalMa
             }
         // Each cell a hypothesis reads under the path, kept or not: two reads of one cell cancel in a row (T − T), yet
         // Lean's linear form of each still needs the cell's column to see the comparison decided.
-        for (const h of goal.hyps)
-            for (const e of subterms(h)) {
-                if (e.op === 'prod')
-                    for (const key of Object.keys(linear(e, path) ?? {}))
-                        if (isMonomial(key))
-                            addMono(key);
-                if (e.op === 'get')
-                    for (const key of Object.keys(linear(e, path) ?? {}))
-                        if (isCell(key))
-                            addCell(key);
-            }
-    });
+        for (const e of readSubterms) {
+            if (e.op === 'prod')
+                for (const key of Object.keys(linear(e, path) ?? {}))
+                    if (isMonomial(key))
+                        addMono(key);
+            if (e.op === 'get')
+                for (const key of Object.keys(linear(e, path) ?? {}))
+                    if (isCell(key))
+                        addCell(key);
+        }
+    }
     const depth = (name) => name.split('[').length;
     // Term columns (open choices, each standing for its term's value) before the cells, whose keys may read them; a
     // monomial with a cell among its factors after the cells.
@@ -172,13 +204,11 @@ export function encode(ex, tamper = false, dropStep = true, globalVars, globalMa
         : name.includes('[') ? `.cell ${maps.indexOf(cellMap(name))} ${row(cellKey(name))}`
             : name.startsWith('⟦') ? `.term (${e(columnTerm(name))})`
                 : `.var ${vars.indexOf(name)}`));
-    let leafNo = 0;
-    const lean = (t, path) => {
-        if (!('leaf' in t)) {
-            const id = canon(t.split);
-            return `.split ${row(t.split)}\n  (${lean(t.yes, new Map(path).set(id, { lin: t.split, holds: true }))})\n  (${lean(t.no, new Map(path).set(id, { lin: t.split, holds: false }))})`;
-        }
-        const base = leafConstraints(goal, path), prods = t.products ?? [], squares = t.squares ?? [];
+    let leafNo = 0, leafAt = 0;
+    const lean = (t) => {
+        if (!('leaf' in t))
+            return `.split ${row(t.split)}\n  (${lean(t.yes)})\n  (${lean(t.no)})`;
+        const { path, base } = leafList[leafAt++], prods = t.products ?? [], squares = t.squares ?? [];
         const rows = withProducts(base, prods, squares).map(r => r.lin), n0 = base.length;
         // Only the rows the derivation and the products read, renumbered (the squares follow them, then the products, in
         // order); cuts carry their quotient row (Cert's format).
@@ -225,12 +255,17 @@ export function encode(ex, tamper = false, dropStep = true, globalVars, globalMa
             if ('fact' in src)
                 return `.fact ${src.fact}`;
             const j = 'pair' in src ? pairs.indexOf([...src.pair].sort().join('\n')) : col.get('nat' in src ? src.nat : src.term) ?? -1;
-            return j < 0 ? '.any' : 'pair' in src ? `.eq ${j}` : 'nat' in src ? `.nat ${j}` : `.term ${j}`;
+            return j < 0 ? '.any' : 'pair' in src ? `.eq ${eqAt.get(j)}` : 'nat' in src ? `.nat ${j}` : `.term ${j}`;
         };
-        const at2 = list(used.map(u => `(${row(rows[u])}, ${hint(base[u].src)})`)), rest = `${list(steps)} ${list(eqs)} ${list(prods.map(([i, j]) => `(${idx(i)}, ${idx(j)})`))}`;
+        // (slim: only the pairs a row's hint names, renumbered; Lean reads the rest only for a row of no hint, which a slim
+        // table has none of)
+        const pairAt = (src) => (src && 'pair' in src ? pairs.indexOf([...src.pair].sort().join('\n')) : -1);
+        const keepEqs = slim && !whole ? [...new Set(used.map(u => pairAt(base[u].src)).filter(j => j >= 0))] : eqs.map((_, j) => j);
+        const eqAt = new Map(keepEqs.map((j, i) => [j, i]));
+        const at2 = list(used.map(u => `(${row(rows[u])}, ${hint(base[u].src)})`)), rest = `${list(steps)} ${list(keepEqs.map(j => eqs[j]))} ${list(prods.map(([i, j]) => `(${idx(i)}, ${idx(j)})`))}`;
         return squares.length ? `.leafSq ${at2} ${list(squares.map(row))} ${rest}` : `.leafAt ${at2} ${rest}`;
     };
-    return { tab: list(tab), hyps: list(goal.hyps.map(c)), tree: lean(tree, new Map()), cols, c, e };
+    return { tab: list(tab), tabCols: tab, hyps: list(goal.hyps.map(c)), tree: lean(tree), cols, c, e };
 }
 export function goalToLean(ex, i, tamper = false, dropStep = true) {
     const { tab, hyps, tree, cols } = encode(ex, tamper, dropStep);
@@ -381,30 +416,6 @@ theorem law${j} ${reach.binders} (h : ${reach.hyp}) : ${statement(law)} := by
   ${law.forall ? `exact fun k => (evalC_iff (upd ρ ${vars.indexOf(law.forall)} k) μ ${id}_l${j}.holds).mp (hl k)` : `exact (evalC_iff ρ μ ${id}_l${j}.holds).mp hl`}`}`)).join('\n')}
 end ${id}`;
 }
-// Live.lean's reqC: each input named by its term, two parts per and.
-const reqTS = (req) => (req.length ? { op: 'and', xs: [{ op: '=', a: { op: 'var', name: req[0][0] }, b: req[0][1] }, reqTS(req.slice(1))] } : { op: '<=', a: { op: 'const', value: 0 }, b: { op: 'const', value: 0 } });
-// Witnesses for a helpful request's free inputs, for its allowed goal: all free first, then each free input fixed to 0, a
-// state variable or a param (a history's query, say, which its relations bound), the first combination that proves.
-function withWitness(m, request, attempt) {
-    const free = m.inputs.filter(i => !(i in request));
-    const cands = [undefined, { op: 'const', value: 0 }, ...Object.keys(m.state).map(v => ({ op: 'var', name: v })), ...m.params.map(v => ({ op: 'var', name: v }))];
-    const combos = [[]];
-    if (free.length <= 2) {
-        const go = (i, acc) => { if (i === free.length) {
-            if (acc.length)
-                combos.push(acc);
-            return;
-        } for (const c of cands)
-            go(i + 1, c ? [...acc, [free[i], c]] : acc); };
-        go(0, []);
-    }
-    for (const wit of combos) {
-        const out = attempt(wit);
-        if (out !== undefined)
-            return { wit, out };
-    }
-    return undefined;
-}
 // A liveness as Live.lean's record: from, to, the rank's parts, each helpful request with its region, the primes.
 function liveLit(l, t, ix, primes, primeMaps) {
     return `⟨${t.c(l.from)}, ${t.c(l.to)}, ${list(livenessRanks(l).map(t.e))},
@@ -543,6 +554,30 @@ export function machineLit(mm, t, ix, mx) {
   ${list((mm.facts ?? []).filter(l => !l.keys?.length).map(l => `⟨${c(l.holds)}, ${l.forall ? `some ${ix(l.forall)}` : 'none'}⟩`))},
   ${list((mm.facts ?? []).filter(l => l.keys?.length).map(l => `(⟨${c(l.holds)}, some ${ix(l.forall)}⟩, ${list(l.keys.map(k2 => String(ix(k2))))})`))}⟩`;
 }
+// A request's extended names: its inputs, each flag that holds at every key and its witnesses (Sets.lean's extVars, in
+// the order the usual export lists a later step's names in).
+const extOf = (m) => [...m.inputs, ...Object.entries(m.step.flags ?? {}).flatMap(([f, c]) => (c.op === 'all' ? [`?${f}`, ...witnessesOf(f, c)] : []))];
+// The names a machine's export numbers first, before those only its goals read: the machine's own (params, inputs, state,
+// flags, the keys of its laws and facts, the keys its writes and quantified flags bind) and its claims' (each step law's
+// key, the state after the step, each later request's names, the state between steps, a history's record). The usual
+// export and the cyclic one (cycMachineToLean) number them alike, so that a machine, a law's statement and a step law are
+// the same Lean text in both.
+function machineNames(m, laws, allSteps, stepLaws, opts) {
+    const flags = Object.entries(m.step.flags ?? {}), quantified = flags.filter(([, c]) => c.op === 'all').map(([f]) => f);
+    const qwits = (f) => witnessesOf(f, m.step.flags[f]);
+    const carried = m.inputMaps ?? [], keysOf = [...new Set([...laws, ...(m.facts ?? [])].flatMap(l => [l.forall, ...(l.keys ?? [])].filter((k) => !!k)))];
+    const k = Math.max(1, ...allSteps.map(sl => sl.steps ?? 1));
+    const ext = [...m.inputs, ...quantified.flatMap(f => [`?${f}`, ...qwits(f)])];
+    const later = Array.from({ length: k - 1 }, (_, j) => ext.map(v => `${v}@${j + 2}`)).flat();
+    const laterMaps = Array.from({ length: k - 1 }, (_, j) => carried.map(mp => `${mp}@${j + 2}`)).flat();
+    const primes = allSteps.length ? Object.keys(m.state).map(s2 => `${s2}'`) : [];
+    const vars = [...new Set([...m.params, ...m.inputs, ...Object.keys(m.state), ...keysOf, ...keysOf.map(k2 => `${k2}#`), '#', ...flags.map(([f]) => `?${f}`),
+            ...quantified.flatMap(qwits), ...boundKeys(m), ...(opts.tamper ? boundKeys(opts.tamper.machine) : []), ...stepLaws.flatMap(sl => (sl.forall ? [sl.forall] : [])), ...(opts.free ?? []),
+            ...primes, ...later, ...Array.from({ length: k - 1 }, (_, j) => Object.keys(m.state).map(n2 => stateName(n2, j + 1))).flat(), ...(opts.record ?? []).map(f => `r.${f}`)])];
+    const baseMaps = [...new Set([...Object.keys(m.maps ?? {}), ...Object.keys(m.step.maps ?? {}), ...Object.keys(m.fns ?? {})])];
+    const maps = [...new Set([...baseMaps, ...carried, ...(allSteps.length ? Object.keys(m.maps ?? {}).map(mp => `${mp}'`) : []), ...laterMaps])];
+    return { vars, maps };
+}
 export function smachineToLean(id, given, laws, opts = {}) {
     const hm = given.history ? { ...given, history: { ...given.history, prune: undefined } } : undefined;
     const hplain = hm ? historyMachine(hm) : undefined, stepLaws = opts.stepLaws ?? [], rf = opts.refined, gv = opts.ghosts ?? [];
@@ -639,18 +674,14 @@ example : (checkSMachine ${id}_tampered ${id}_proof && sliveOk ${id}_tampered ${
 theorem ${id}_orig_laws : ∀ ρ M, SReach ${id}_ghosted.orig ρ M → ∀ e ∈ ${id}_proof, avoids ${id}_ghosted.vars e.law.holds = true → e.Holds ρ M :=
   sghost_laws ${id}_ghosted ${id}_ghostOk ${id}_proof ${id}_check` });
     const allSteps = claimSteps();
-    const r = proveStepLaws(m, laws, allSteps);
+    const r = proveStepLawsOnce(m, laws, allSteps);
     if (!r.proven || !r.proof)
         throw new Error(`${id}: not proven`);
     const lp = r.proof.laws, si = r.proof.instances;
     const flags = Object.entries(m.step.flags ?? {}), quantified = flags.filter(([, c]) => c.op === 'all').map(([f]) => f);
     const qwits = (f) => witnessesOf(f, m.step.flags[f]);
-    const carried = m.inputMaps ?? [], facts = m.facts ?? [], keysOf = [...new Set([...laws, ...facts].flatMap(l => [l.forall, ...(l.keys ?? [])].filter((k) => !!k)))];
-    const k = Math.max(1, ...allSteps.map(sl => sl.steps ?? 1));
+    const carried = m.inputMaps ?? [], facts = m.facts ?? [];
     const ext = [...m.inputs, ...quantified.flatMap(f => [`?${f}`, ...qwits(f)])];
-    const later = Array.from({ length: k - 1 }, (_, j) => ext.map(v => `${v}@${j + 2}`)).flat();
-    const laterMaps = Array.from({ length: k - 1 }, (_, j) => carried.map(mp => `${mp}@${j + 2}`)).flat();
-    const primes = allSteps.length ? Object.keys(m.state).map(s2 => `${s2}'`) : [];
     const instOf = (sl) => r.proof.perStep?.[sl.name] ?? si;
     const goalsL = obligations(m, laws, lp.instances), goalsS = allSteps.map(sl => stepLawObligations(m, laws, instOf(sl), sl)[0]);
     // Weak fairness over sets: each helpful request allowed in its region carrying empty sets (Live.lean's sAllowGoal,
@@ -716,13 +747,9 @@ theorem ${id}_orig_laws : ∀ ρ M, SReach ${id}_ghosted.orig ρ M → ∀ e ∈
             return r2.proven ? r2 : undefined;
         })]));
     const allowGoals = [...allowed.values()].flatMap(a => (a ? [a.out.goal] : []));
-    const vars = [...new Set([...m.params, ...m.inputs, ...Object.keys(m.state), ...keysOf, ...keysOf.map(k2 => `${k2}#`), '#', ...flags.map(([f]) => `?${f}`),
-            ...quantified.flatMap(qwits), ...boundKeys(m), ...(opts.tamper ? boundKeys(opts.tamper.machine) : []), ...stepLaws.flatMap(sl => (sl.forall ? [sl.forall] : [])), ...(opts.free ?? []),
-            ...primes, ...later, ...Array.from({ length: k - 1 }, (_, j) => Object.keys(m.state).map(n2 => stateName(n2, j + 1))).flat(),
-            ...(hm ? hm.history.record.map(f => `r.${f}`) : []), ...[...goalsL, ...goalsS, ...allowGoals, ...(hplain?.goals ?? [])].flatMap(g => g.hyps.flatMap(varsOf))])];
-    const baseMaps = [...new Set([...Object.keys(m.maps ?? {}), ...Object.keys(m.step.maps ?? {}), ...Object.keys(m.fns ?? {})])];
-    const mapNames = [...new Set([...baseMaps, ...carried, ...(allSteps.length ? Object.keys(m.maps ?? {}).map(mp => `${mp}'`) : []), ...laterMaps,
-            ...[...JSON.stringify([...goalsL, ...goalsS, ...allowGoals]).matchAll(/"op":"get","map":"([^"]+)"/g)].map(x2 => x2[1])])];
+    const named = machineNames(m, laws, allSteps, stepLaws, { ...opts, ...(hm ? { record: hm.history.record } : {}) });
+    const vars = [...new Set([...named.vars, ...[...goalsL, ...goalsS, ...allowGoals, ...(hplain?.goals ?? [])].flatMap(g => g.hyps.flatMap(varsOf))])];
+    const mapNames = [...new Set([...named.maps, ...[...JSON.stringify([...goalsL, ...goalsS, ...allowGoals]).matchAll(/"op":"get","map":"([^"]+)"/g)].map(x2 => x2[1])])];
     const enc = (g, tree) => encode({ name: `${id}: ${g.name}`, goal: g, tree }, false, true, vars, mapNames);
     const { e, c } = leanTerms(vars, mapNames, id);
     const ix = (name) => { const j = vars.indexOf(name); if (j < 0)
@@ -830,6 +857,353 @@ ${hm ? histBlock() : readable(id, laws, vars, mapNames, { binders: '(ρ : Nat
 def ${id}_tampered : SMachine := ${lit(opts.tamper.machine)}
 example : checkSMachine ${id}_tampered ${id}_proof = false := by ${checkBy}` : ''}${records.length ? `\n\n${records.join('\n\n')}` : ''}${opts.after ? `\n\n${opts.after(ix)}` : ''}`;
 }
+// --- the cyclic certificate's export (GDP_CERT=cyclic) -------------------------------------------------------------
+// By default, or with GDP_CERT=cyclic (core/cyclic.ts's certOn: a covered proof's certificate is its cyclic proof; or toLean's
+// `cyclic`), toLean exports each machine the cyclic route covers from one cyclic
+// proof (kernel/cyclic.ts) of its laws and of every step law its claims bring (its own step laws and k-step laws, a
+// liveness's), carried to the machine by Bridge.lean's cyc_machine_sound and BridgeRules.lean's cyc_kstep_sound,
+// sleads_of_holds (liveness, loops), hreach_plain (histories) and cyc_ghost_holds (ghosts), and each theorem stated as the
+// usual export states it: the same machine, laws, step laws and liveness (machineNames numbers them alike), the same
+// `<id>.lawN`, `<id>_stepN_holds`, `<id>_liveN_holds`, `<id>_halts`; a machine with flags that hold at every key through
+// its sk machine (BridgeRules.lean's q bridges). What the cyclic route doesn't cover goes the usual way: a law that reads
+// a map at a key read from a map, and whatever no certificate is found for within the deadline (`certReport`).
+// The usual proof of a machine's laws and step laws, made once per toLean: an item exported the usual way after its
+// cyclic certificate wasn't found (cycMachineProof) reads the proof that search started from, not one made again. It
+// is made with no cyclic certificate of its own (quietly): the export makes the certificate it exports from the usual
+// trees (cycMachineProof), and the usual export reads the trees, so a certificate made here is never read.
+const usualMade = new Map();
+function proveStepLawsOnce(m, laws, stepLaws) {
+    const key = JSON.stringify([m, laws, stepLaws]), had = usualMade.get(key);
+    if (had)
+        return had;
+    const r = quietly(() => proveStepLaws(m, laws, stepLaws));
+    usualMade.set(key, r);
+    return r;
+}
+const envOf = () => globalThis.process?.env;
+export const cyclicCerts = certMode;
+let certsOn = false, cycTexts = 0;
+// What the last toLean exported from cyclic certificates, and what went the usual way (and why).
+export const certReport = { cyclic: [], usual: [], translatedSteps: [] };
+// Each item's cyclic certificate is made within one deadline (GDP_CERT_MS, 10 s by default), every goal it grows (the
+// translation's leaves grown again, the searched nodes) bounded by it: past it, the item goes the usual way.
+function cycMachineProof(m, laws, allSteps, allows = []) {
+    const r = proveStepLawsOnce(m, laws, allSteps);
+    if (!r.proven || !r.proof)
+        return { why: 'not proven the usual way' };
+    const until = performance.now() + certMs();
+    return withDeadline(until, () => cycMachineProofBy(m, laws, allSteps, allows, r, until));
+}
+function cycMachineProofBy(m, laws, allSteps, allows, r, until) {
+    if (!r.proof)
+        return { why: 'not proven the usual way' };
+    const tStart = performance.now();
+    const lp = r.proof.laws, instOf = (sl) => r.proof.perStep?.[sl.name] ?? r.proof.instances;
+    // A machine with flags that hold at every key: its sk machine's nodes, the flags' closing facts read where each node
+    // reads the run.
+    const q = hasQuantified(m), mm = skMachine(m);
+    const L = laws.length, mine = (facts, lawNodes) => searchedStepNodes(m, laws, allSteps.map(sl => ({ law: sl, instances: instOf(sl) })), facts, lawNodes);
+    const tries = [];
+    if (routeOf() !== 'search' && allSteps.length) {
+        const usualSteps = allSteps.map(sl => { const inst = instOf(sl), g = stepLawObligations(m, laws, inst, sl)[0]; return { sl, inst, goal: g, tree: r.proof.trees[g.name] }; });
+        const tr = usualSteps.every(u => u.tree) ? machineNodes(m, laws, lp.instances, { trees: lp.trees, steps: usualSteps }) : undefined;
+        if (tr && !tr.why && tr.specs.length === 3 * L + 2 * allSteps.length) {
+            // (either time form cycKOk reads: one step back at a time, or t − n at once)
+            const id = (x) => JSON.stringify(x), forms = [tBack, tSub].map(time => stepLawNodes(mm, laws, allSteps.map(sl => ({ law: sl, instances: instOf(sl) })), tr.facts, tr.specs, time));
+            const fits = allSteps.every((_, j) => forms.some(own => {
+                const a = tr.specs[3 * L + 2 * j + 1], b = own[j], hs = new Set(b.hyps.map(id));
+                return id(a.concl) === id(b.concl) && a.hyps.every(h => hs.has(id(h)));
+            }));
+            if (fits)
+                tries.push({ facts: tr.facts, specs: tr.specs, lawNodes: tr.specs, stepAt: allSteps.map((_, j) => 3 * L + 2 * j + 1), translated: true });
+        }
+    }
+    for (const base of [...(routeOf() !== 'search' ? [machineNodes(m, laws, lp.instances, { trees: lp.trees })] : []), machineNodes(m, laws, lp.instances)].filter(b => !b.why)) {
+        tries.push({ facts: base.facts, specs: [...base.specs, ...mine(base.facts, base.specs)], lawNodes: base.specs, stepAt: allSteps.map((_, j) => base.specs.length + j) });
+    }
+    let last = 'no nodes';
+    const t00 = tStart;
+    for (const { facts, specs: specs0, lawNodes, stepAt, translated } of tries) {
+        if (performance.now() > until)
+            return { why: `past the certificate's deadline (${certMs()} ms)` };
+        const tTry = performance.now();
+        let specs = specs0, v = proveCyclic(facts, specs);
+        if (envOf()?.GDP_LEAN_TIMES === '1')
+            console.error(`lean try ${m.name}: ${translated ? 'translated' : 'laws + searched steps'}, ${specs.length} nodes, ${v.proven && v.checked ? 'proven' : 'not'}, ${Math.round(performance.now() - tTry)} ms (${Math.round(tTry - t00)} ms building before)`);
+        if (!(v.proven && v.checked)) {
+            last = performance.now() > until ? `past the certificate's deadline (${certMs()} ms)` : v.proven ? `not checked (${v.why})` : `${v.node}: ${v.goal}: ${v.stuck}`;
+            continue;
+        }
+        const allowAt = allows.map((group) => {
+            if ((lawNodes[0]?.rank.length ?? 2) < 2)
+                return undefined;
+            const before = specs, out = [];
+            for (const a of group) {
+                const found = withWitness(m, a.request, wit => {
+                    if (performance.now() > until)
+                        return undefined;
+                    const spec = allowNode(mm, laws, r.proof.instances, { op: 'and', xs: [a.when, reqTS(wit)] }, facts, lawNodes, `${m.name}: allowed`, q ? closingInsts(m, facts, [r.proof.instances, ...Object.values(lp.instances)], [{ op: 'var', name: 't$' }], laws) : []);
+                    const v2 = proveCyclic(facts, [...specs, spec]);
+                    return v2.proven && v2.checked ? { spec, v2 } : undefined;
+                });
+                if (!found) {
+                    specs = before;
+                    return undefined;
+                }
+                out.push({ node: specs.length, wit: found.wit });
+                specs = [...specs, found.out.spec];
+                v = found.out.v2;
+            }
+            return out;
+        });
+        if (v.proven && v.checked) {
+            if (translated)
+                certReport.translatedSteps.push(m.name);
+            return { p: v.proof, stepAt, allowAt };
+        }
+    }
+    return { why: last };
+}
+// A machine (with a history, ghosts, a liveness or as a loop's) from one cyclic proof, or why it can't be.
+export function cycMachineToLean(id, given, laws, opts = {}) {
+    const hm = given.history ? { ...given, history: { ...given.history, prune: undefined } } : undefined;
+    const hplain = hm ? historyMachine(hm) : undefined, m = hplain ? hplain.machine : given;
+    const stepLaws = opts.stepLaws ?? [], gv = opts.ghosts ?? [], lp0 = opts.loop;
+    const why = uncoveredWhy(m, laws);
+    if (why)
+        return { why };
+    // With flags that hold at every key, the sk machine's encoding and BridgeRules.lean's q bridges.
+    const mq = skMachine(m), Q = hasQuantified(m) ? 'Q' : '', q = hasQuantified(m) ? 'q' : '';
+    const lives = (opts.liveness ?? []).map(l => ({ l, ...livenessParts(m, l) }));
+    // A refinement's step law: the spec stutters or allows the request it is sent, its `then` Lean's SRefined.allowed (the
+    // spec's assumption at the witness, the composite's flags inlined).
+    const rf = opts.refined;
+    const rfStep = rf && { ...rf.step, when: undefined, then: { op: 'or', xs: [rf.stutter, substC(rf.spec.assume ?? trueC, { vars: Object.fromEntries(Object.entries(rf.wit).map(([inp, t2]) => [`b_${inp}`, t2])), maps: {},
+                    flags: Object.fromEntries(Object.keys(m.step.flags ?? {}).map(f => [f, { op: 'flag', name: f }])) })] } };
+    const allSteps = [...(rfStep ? [rfStep] : stepLaws), ...lives.flatMap(x => [x.stay, x.cover, ...x.helps])];
+    const made = cycMachineProof(m, laws, allSteps, lives.map(x => x.helps.map((hs, i) => ({ when: hs.when, request: livenessHelpful(x.l)[i].request }))));
+    if ('why' in made)
+        return made;
+    const { p, stepAt, allowAt } = made;
+    const named = machineNames(m, laws, allSteps, stepLaws, { ...(opts.free ? { free: opts.free } : {}), ...(hm ? { record: hm.history.record } : {}) });
+    const sc = cycScope([p], { machine: mq, laws });
+    const vars = [...new Set([...named.vars, ...sc.vars])], maps = [...new Set([...named.maps, ...sc.maps])];
+    const { e, c } = leanTerms(vars, maps, id);
+    const ix = (name) => { const j = vars.indexOf(name); if (j < 0)
+        throw new Error(`${id}: no variable for ${name}`); return j; };
+    const mx = (name) => { const j = maps.indexOf(name); if (j < 0)
+        throw new Error(`${id}: no map for ${name}`); return j; };
+    const lit = (mm) => machineLit(mm, { e, c }, ix, mx);
+    const inline = (c2) => substC(c2, { vars: {}, maps: {}, flags: flagsOfM(m) });
+    const keysOf = (l) => [...(l.forall ? [l.forall] : []), ...(l.keys ?? [])];
+    const keysL = (l) => list(keysOf(l).map(k2 => String(ix(k2))));
+    const state = Object.keys(m.state), carried = m.inputMaps ?? [];
+    const primesL = () => list(state.map(s2 => `(${ix(s2)}, ${ix(`${s2}'`)})`)), primeMapsL = () => list(Object.keys(m.maps ?? {}).map(mp => `(${mx(mp)}, ${mx(`${mp}'`)})`));
+    const node = (i) => `${id}_node${i}`;
+    // What every law's and step law's check reads alike, proven once: the exported facts among the encoding's, and (with
+    // no flag at every key) the encoding's shape and terms at no keys, which a law's at its keys implies. Each check then
+    // reads those as true (simp only, unfolding the check), not computed again per law.
+    const sharedOk = [`${id}_factsIn`, ...(Q ? [] : [`${id}_shape`, `${id}_terms`])].join(', ');
+    const okLemmas = `theorem ${id}_factsIn : cyc${Q}FactsIn ${id}_machine ${id}_enc ${id}_facts = true := by ${checkBy}${Q ? '' : `
+theorem ${id}_shape : cycShapeOk ${id}_machine ${id}_enc [] = true := by ${checkBy}
+theorem ${id}_terms : cycTermsOk ${id}_machine ${id}_enc [] = true := by ${checkBy}`}`;
+    const mOk = `by simp only [cyc${Q}MOk, ${sharedOk}]; ${checkBy}`, kOk = `by simp only [cyc${Q}KOk, cyc${Q}KOkAt, ${sharedOk}]; ${checkBy}`;
+    const aOk = `by simp only [cyc${Q}AOk, ${sharedOk}]; ${checkBy}`;
+    const kstep = (sk, i) => `cyc_${q}kstep_sound ${id}_machine ${id}_enc ${id}_facts ${id}_nodes ${id}_check ${sk} ${node(i)} ${node(i)}_mem`;
+    // The machine as the usual export defines it: with a history its plain machine, with ghosts the ghosted one, a loop's.
+    const orig = { ...m, state: Object.fromEntries(Object.entries(m.state).filter(([n2]) => !gv.includes(n2))), step: { ...m.step, state: Object.fromEntries(Object.entries(m.step.state ?? {}).filter(([n2]) => !gv.includes(n2))) } };
+    const hlit = () => {
+        const h = hm.history, base = { ...hm, history: undefined };
+        return `⟨${lit(base)},
+  ${c(h.keep)},
+  ${list(h.record.map(f => String(ix(f))))},
+  ${list(h.record.map(f => String(ix(`r.${f}`))))},
+  ${list(Object.entries(h.sums).map(([name, g]) => `(${ix(name)}, ${e(g)})`))},
+  ${list(Object.entries(h.queries).map(([name, g]) => `(${ix(name)}, ${e(g)})`))},
+  ${list((h.relations ?? []).map(rel => { if (rel.holds.op !== '<=')
+            throw new Error(`${id}: a relation is a <= b`); return `(${c(rel.when)}, ${e(rel.holds.a)}, ${e(rel.holds.b)})`; }))}⟩`;
+    };
+    const loopLit = (lp) => `⟨${list(lp.inputs.map(name => String(ix(name))))},
+  ${list(Object.entries(lp.state).map(([name, e2]) => `(${ix(name)}, ${e(e2)})`))},
+  ${list(Object.entries(lp.body).map(([name, e2]) => `(${ix(name)}, ${e(e2)})`))},
+  ${c(lp.while)},
+  ${lp.pre ? c(lp.pre) : TRUE},
+  ${lp.assume ? c(lp.assume) : TRUE}⟩`;
+    const machineDef = rf ? `def ${id}_refined : SRefined := ⟨${lit(rf.impl)},
+  ${lit(rf.spec)},
+  ${list(Object.entries(rf.wit).map(([inp, t2]) => `(${ix(`b_${inp}`)}, ${e(t2)})`))},
+  ${c(rf.stutter)}⟩
+def ${id}_machine : SMachine := ${id}_refined.full` : gv.length ? `def ${id}_ghosted : SGhosted := ⟨${lit(orig)},
+  ${list(gv.map(v2 => `(${ix(v2)}, ${e(m.state[v2])}, ${e(m.step.state?.[v2] ?? { op: 'var', name: v2 })})`))}⟩
+def ${id}_machine : SMachine := ${id}_ghosted.full
+theorem ${id}_ghostOk : sghostOk ${id}_ghosted = true := by ${checkBy}` : hm ? `def ${id}_hist : HMachine := ${hlit()}
+def ${id}_machine : SMachine := ${id}_hist.plain` : lp0 ? `def ${id}_loop : Loop := ${loopLit(lp0.loop)}
+def ${id}_machine : SMachine := ${id}_loop.machine` : `def ${id}_machine : SMachine := ${lit(m)}`;
+    const enc = `⟨${['u$', 'k$', 'T$', 'O$', 't$'].map(ix).join(', ')},
+  ${list([...state, ...mq.inputs].map(x => `(${ix(x)}, ${mx(`${x}@`)})`))},
+  ${list([...Object.keys(m.maps ?? {}), ...carried].map(x => `(${mx(x)}, ${mx(`${x}@`)})`))}⟩`;
+    // Each law: Bridge.lean's check and theorem, then all of them as the usual export's `<id>_laws` states them.
+    const lawBlocks = laws.map((l, j) => `-- ${l.name}
+def ${id}_law${j} : C := ${c(l.holds)}
+def ${id}_l${j} : MLaw := ⟨${id}_law${j}, ${l.forall ? `some ${ix(l.forall)}` : 'none'}⟩
+theorem ${id}_law${j}_ok : cyc${Q}MOk ${id}_machine ${id}_enc ${id}_facts ${id}_law${j} ${keysL(l)} ${node(j)} = true := ${mOk}
+theorem ${id}_law${j}_holds : ∀ ρ M, SReach ${id}_machine ρ M → ∀ ρ' : Nat → Nat, (∀ i, i ∉ ${keysL(l)} → ρ' i = ρ i) → evalC ρ' M ${id}_law${j} = true :=
+  cyc_${q}machine_sound ${id}_machine ${id}_enc ${id}_facts ${id}_nodes ${id}_check ${id}_law${j} ${keysL(l)} ${node(j)} ${node(j)}_mem ${id}_law${j}_ok`).join('\n');
+    const keys2 = (l) => list((l.keys ?? []).map(k2 => String(ix(k2))));
+    const oneOf = (hyp) => `simp only [${id}_mlaws, List.mem_cons, List.not_mem_nil, or_false] at ${hyp}`;
+    const lawsThm = `def ${id}_mlaws : List (MLaw × List Nat) := ${list(laws.map((l, j) => `(${id}_l${j}, ${keys2(l)})`))}
+theorem ${id}_laws : ∀ ρ M, SReach ${id}_machine ρ M → ∀ e ∈ ${id}_mlaws, holdsOver e.1 M e.2 ρ := by
+  intro ρ M h e he
+  ${laws.length ? `${oneOf('he')}
+  rcases he with ${laws.map(() => 'rfl').join(' | ')}
+  ${laws.map((_, j) => `· exact cyc_machine_holds (${id}_law${j}_holds ρ M h)`).join('\n  ')}` : `simp [${id}_mlaws] at he`}`;
+    // A history's record goals (leaf goals, as the usual export has them), and its laws over histories.
+    const histBlock = () => {
+        const records = hplain.goals.map(g => { const out = grow(g); if (!('tree' in out))
+            throw new Error(`${id}: ${g.name} not proven`); const x2 = encode({ name: `${id}: ${g.name}`, goal: g, tree: out.tree }, false, true, vars, maps); return `(${x2.tab}, ${x2.tree})`; });
+        const reach = (hyp) => `(hreach_plain ${id}_hist ${id}_records ${id}_hcheck ρ μ hist ${hyp})`;
+        return `def ${id}_records : List (List VDef × Tree) := ${list(records)}
+theorem ${id}_hcheck : checkHMachine ${id}_hist [] ${id}_records = true := by ${checkBy}
+theorem ${id}_hlaws : ∀ ρ M hist, HReach ${id}_hist ρ M hist → ∀ e ∈ ${id}_mlaws, holdsOver e.1 M e.2 ρ :=
+  fun ρ M hist h => ${id}_laws ρ M (hreach_plain ${id}_hist ${id}_records ${id}_hcheck ρ M hist h)
+${readable(id, laws, vars, maps, { binders: '(ρ : Nat → Nat) (μ : Nat → Nat → Nat) (hist : List (Nat → Nat))', hyp: `HReach ${id}_hist ρ μ hist`, call: '',
+            have: j => `have hl : holdsOver ${id}_l${j} μ ${keys2(laws[j])} ρ := cyc_machine_holds (${id}_law${j}_holds ρ μ ${reach('h')})` })}`;
+    };
+    // The machine's own step laws, one step or k (BridgeRules.lean's cyc_kstep_sound): the SKStep as the usual export
+    // writes it, with no certificate in it.
+    const stepBlocks = (rf ? [] : stepLaws).map((sl, j) => {
+        const kk = sl.steps ?? 1;
+        const ren = Array.from({ length: kk }, (_, s2) => (s2 === 0 ? '[]' : list(extOf(m).map(v2 => `(${ix(v2)}, ${ix(`${v2}@${s2 + 1}`)})`))));
+        const mren = Array.from({ length: kk }, (_, s2) => (s2 === 0 ? '[]' : list(carried.map(mp => `(${mx(mp)}, ${mx(`${mp}@${s2 + 1}`)})`))));
+        const names = Array.from({ length: kk - 1 }, (_, s2) => list(state.map(n2 => `(${ix(n2)}, ${ix(stateName(n2, s2 + 1))})`)));
+        return `-- Step law${kk > 1 ? ` over ${kk} steps` : ''}: ${sl.name}
+def ${id}_step${j} : SKStep := ⟨⟨${list(kWhens(mq, sl).map(c))},
+  ${c(inline(sl.then))},
+  ${list(ren)},
+  ${primesL()},
+  ${primeMapsL()},
+  [],
+  ([], .leaf [] [] [] [])⟩,
+  ${list(mren)},
+  [], [], [], [], [],
+  ${list(names)}⟩
+theorem ${id}_step${j}_ok : cyc${Q}KOk ${id}_machine ${id}_enc ${id}_facts ${id}_step${j} ${node(stepAt[j])} = true := ${kOk}
+theorem ${id}_step${j}_holds : SKStepHolds ${id}_machine ${id}_step${j} :=
+  ${kstep(`${id}_step${j}`, stepAt[j])} ${id}_step${j}_ok`;
+    });
+    // Each liveness from its step laws (BridgeRules.lean's sleads_of_holds), as the usual export states it.
+    let at = stepLaws.length;
+    const liveBlocks = lives.map(({ l, helps }, j) => {
+        const lid = `${id}_live${j}`, at0 = at, s0 = stepAt[at0], c0 = stepAt[at0 + 1], hAt = (i) => stepAt[at0 + 2 + i];
+        at += 2 + helps.length;
+        // Under weak fairness, where each helpful request is proven allowed in its region (BridgeRules.lean's cyc_allow_sound).
+        const al = allowAt[j], wfp = al ? `
+${al.map((a, i) => `def ${lid}_wit${i} : List (Nat × E) := ${list(a.wit.map(([inp, t2]) => `(${ix(inp)}, ${e(t2)})`))}`).join('\n')}
+theorem ${lid}_allows : ∀ h ∈ ${lid}.helps, ∃ wit : List (Nat × E), distinct ((h.2 ++ wit).map (·.1)) = true
+    ∧ (∀ p ∈ wit, (${id}_machine.f.m.inputs.contains p.1 = true ∧ avoids ${id}_machine.extVars (.eq p.2 p.2) = true) ∧ avoidsMaps ${id}_machine.carried (.eq p.2 p.2) = true)
+    ∧ AllowHolds ${id}_machine (.and (liveHelpWhen ${lid} h) (reqC wit)) := by
+  intro h hh
+  simp only [${lid}, List.mem_cons, List.not_mem_nil, or_false] at hh
+  rcases hh with ${helps.map(() => 'rfl').join(' | ')}
+  ${al.map((a, i) => `· exact ⟨${lid}_wit${i}, by ${checkBy}, by ${checkBy}, cyc_${q}allow_sound ${id}_machine ${id}_enc ${id}_facts ${id}_nodes ${id}_check _ ${node(a.node)} ${node(a.node)}_mem (${aOk})⟩`).join('\n  ')}
+/-- ${l.name}, under weak fairness: along every run that takes each helpful request whenever, from some point on, it
+stays allowed, \`from\` is followed by \`to\`. -/
+theorem ${lid}_holds_wf (run : SRun ${id}_machine)
+    (fair : ∀ h ∈ ${lid}.helps, ∀ n, (∀ m, n ≤ m → ∃ ι κ, (∀ p ∈ h.2, ι p.1 = evalE (run.st m).1 (run.st m).2 p.2)
+        ∧ evalC (sView ${id}_machine (run.st m).1 (run.st m).2 ι κ).1 (sView ${id}_machine (run.st m).1 (run.st m).2 ι κ).2 ${id}_machine.f.m.assume = true) →
+      ∃ m, n ≤ m ∧ ∀ p ∈ h.2, (run.req m).1 p.1 = evalE (run.st m).1 (run.st m).2 p.2) :
+    ∀ n, evalC (run.st n).1 (run.st n).2 ${lid}.from_ = true → ∃ m, n ≤ m ∧ evalC (run.st m).1 (run.st m).2 ${lid}.to = true :=
+  sleads_wf_of_holds ${id}_machine ${lid} ${lid}_ok ${lid}_stay ${lid}_cover ${lid}_helps ${lid}_allows run fair` : '';
+        return `-- Liveness: ${l.name}
+def ${lid} : Live := ${liveLit(l, { e, c }, ix, primesL(), primeMapsL())}
+theorem ${lid}_ok : sliveOk ${id}_machine ${lid} = true := by ${checkBy}
+theorem ${lid}_stay : SKStepHolds ${id}_machine (liveK ${lid} ${lid}.pend (liveStayC ${lid})) := ${kstep('_', s0)} (${kOk})
+theorem ${lid}_cover : SKStepHolds ${id}_machine (liveK ${lid} ${lid}.pend (liveCoverC ${lid})) := ${kstep('_', c0)} (${kOk})
+theorem ${lid}_helps : ∀ h ∈ ${lid}.helps, SKStepHolds ${id}_machine (liveK ${lid} (liveHelpWhen ${lid} h) (liveHelpThen ${lid})) := by
+  intro h hh
+  simp only [${lid}, List.mem_cons, List.not_mem_nil, or_false] at hh
+  rcases hh with ${helps.map(() => 'rfl').join(' | ')}
+  ${helps.map((_, i) => `· exact ${kstep('_', hAt(i))} (${kOk})`).join('\n  ')}
+/-- ${l.name}: along every run that takes each helpful request infinitely often, \`from\` is followed by \`to\`. -/
+theorem ${lid}_holds (run : SRun ${id}_machine)
+    (fair : ∀ h ∈ ${lid}.helps, ∀ n, ∃ m, n ≤ m ∧ ∀ p ∈ h.2, (run.req m).1 p.1 = evalE (run.st m).1 (run.st m).2 p.2) :
+    ∀ n, evalC (run.st n).1 (run.st n).2 ${lid}.from_ = true → ∃ m, n ≤ m ∧ evalC (run.st m).1 (run.st m).2 ${lid}.to = true :=
+  sleads_of_holds ${id}_machine ${lid} ${lid}_ok ${lid}_stay ${lid}_cover ${lid}_helps run fair${wfp}`;
+    });
+    const loopBlock = lp0 ? `/-- ${lp0.loop.name} halts: for params meeting its precondition, no run of turns goes on forever. -/
+theorem ${id}_halts : ∀ maps ρ0, evalC ρ0 maps ${id}_loop.pre = true →
+    ¬ ∃ f : Nat → Nat → Nat, f 0 = applyS ${id}_loop.init ρ0 maps ∧ ∀ n, Turn ${id}_loop maps (f n) (f (n + 1)) :=
+  loop_halts_of ${id}_loop ${id}_live0 rfl rfl (by intro h hh; simp only [${id}_live0, List.mem_singleton] at hh; subst hh; rfl) (by ${checkBy}) ${id}_live0_holds` : '';
+    const ghostBlock = gv.length ? `-- The laws that read no ghost hold of the machine without its ghosts.
+theorem ${id}_orig_laws : ∀ ρ M, SReach ${id}_ghosted.orig ρ M → ∀ e ∈ ${id}_mlaws, avoids ${id}_ghosted.vars e.1.holds = true → holdsOver e.1 M e.2 ρ := by
+  intro ρ M hr e he hav
+  ${laws.length ? `${oneOf('he')}
+  rcases he with ${laws.map(() => 'rfl').join(' | ')}
+  ${laws.map((l, j) => `· exact cyc_machine_holds (cyc_ghost_holds ${id}_ghosted ${id}_ghostOk ${id}_law${j} ${keysL(l)} hav ${id}_law${j}_holds ρ M hr)`).join('\n  ')}` : `simp [${id}_mlaws] at he`}` : '';
+    const refineBlock = rf ? `theorem ${id}_allowed : SKStepHolds ${id}_machine (srStep ${id}_refined ${primesL()} ${primeMapsL()} noSProof) := ${kstep('_', stepAt[0])} (${kOk})
+theorem ${id}_refines : ∀ ρ M, SReach ${id}_refined.impl ρ M → ∃ ρc Mc σ Ms, SReach ${id}_refined.full ρc Mc ∧ Agree ${id}_refined.SV ρc ρ
+    ∧ (∀ mp, mp ∉ ${id}_refined.SM → Mc mp = M mp) ∧ SReach ${id}_refined.spec σ Ms ∧ Agree ${id}_refined.X σ ρc
+    ∧ (∀ mp, mp ∉ ${id}_refined.IM → mp ∉ ${id}_refined.spec.carried → Ms mp = Mc mp) ∧ ∀ e ∈ ${id}_mlaws, holdsOver e.1 Mc e.2 ρc :=
+  srefines_of_holds ${id}_refined (by ${checkBy}) (by ${checkBy}) _ ${id}_laws
+    (fun ρ M h => by have hp := ${id}_law${rf.specPre}_holds ρ M h ρ (fun _ _ => rfl); exact hp)
+    ${primesL()} ${primeMapsL()} noSProof ${id}_allowed (by ${checkBy}) (by ${checkBy}) (by ${checkBy})` : '';
+    const records = [...stepBlocks, ...(refineBlock ? [refineBlock] : []), ...liveBlocks, ...(loopBlock ? [loopBlock] : []), ...(ghostBlock ? [ghostBlock] : [])];
+    cycTexts++;
+    return { text: `-- ${m.name}: ${laws.map(l => l.name).join('; ')}, as one cyclic proof (its laws' nodes, then ${allSteps.length} step laws')
+--   (variables ${vars.map((v2, j) => `${j} ${v2}`).join(', ')}; maps ${maps.map((v2, j) => `${j} ${v2}`).join(', ')})
+${machineDef}
+def ${id}_enc : CycEnc := ${enc}
+${cycProofText(id, p, [], vars, maps)}
+${okLemmas}
+${lawBlocks}
+${lawsThm}
+${hm ? histBlock() : readable(id, laws, vars, maps, { binders: '(ρ : Nat → Nat) (μ : Nat → Nat → Nat)', hyp: `SReach ${id}_machine ρ μ`, call: '',
+            have: j => `have hl : holdsOver ${id}_l${j} μ ${keys2(laws[j])} ρ := cyc_machine_holds (${id}_law${j}_holds ρ μ h)` })}${opts.noFacts ? '' : factsProof(id, m, maps, vars, opts.simp)}${records.length ? `\n\n${records.join('\n\n')}` : ''}${opts.after ? `\n\n${opts.after(ix)}` : ''}` };
+}
+// A fold from its cyclic proof (Bridge.lean's cyc_fold_sound): the fold numbered as foldToLean numbers it, each law's
+// theorem over trees, and all of them as the usual export's `<id>_laws` states them.
+function cycFoldToLean(id, f, laws) {
+    const gs = foldObligations(f, laws), trees = {};
+    for (const g of gs) {
+        const o = grow(g);
+        if (!('tree' in o))
+            return { why: `${g.name}: not proven the usual way` };
+        trees[g.name] = o.tree;
+    }
+    let p, why = 'no nodes';
+    const until = performance.now() + certMs();
+    for (const base of withDeadline(until, () => [...(routeOf() !== 'search' ? [foldNodes(f, laws, trees)] : []), foldNodes(f, laws)].filter(b => !b.why))) {
+        if (performance.now() > until) {
+            why = `past the certificate's deadline (${certMs()} ms)`;
+            break;
+        }
+        const v = withDeadline(until, () => proveCyclic(base.facts, base.specs));
+        if (v.proven && v.checked) {
+            p = v.proof;
+            break;
+        }
+        why = v.proven ? `not checked (${v.why})` : `${v.node}: ${v.goal}: ${v.stuck}`;
+    }
+    if (!p)
+        return { why };
+    const st = Object.keys(f.leaf), v = (name) => ({ op: 'var', name });
+    const sc = cycScope([p], undefined, [...[...f.params, ...f.inputs, ...st, ...st.map(x => `l_${x}`), ...st.map(x => `r_${x}`), 'n$', 'N$'].map(v),
+        ...Object.values(f.leaf), ...Object.values(f.node), ...laws.map((l) => ({ op: 'if', c: l.holds, then: v('n$'), else: v('n$') })),
+        ...['Kind', 'Left', 'Right', ...st, ...f.inputs].map((x) => ({ op: 'get', map: `${x}@`, key: v('n$') }))]);
+    const vars = [...new Set([...f.params, ...f.inputs, ...st, ...st.map(n2 => `l_${n2}`), ...st.map(n2 => `r_${n2}`), ...sc.vars])], maps = sc.maps;
+    const t = leanTerms(vars, maps, id);
+    cycTexts++;
+    return { text: `-- ${f.name}: ${laws.map(law => law.name).join('; ')}, as one cyclic proof  (variables ${vars.map((v2, j) => `${j} ${v2}`).join(', ')}; maps ${maps.map((v2, j) => `${j} ${v2}`).join(', ')})
+${cycProofText(id, p, [], vars, maps)}
+${cycFoldLean(id, f, laws, vars, maps, t)}
+def ${id}_flaws : List C := ${list(laws.map((_, j) => `${id}_law${j}`))}
+theorem ${id}_laws : ∀ maps ρ, evalC ρ maps ${id}_fold.pre = true → ∀ t, Allowed ${id}_fold ρ maps t →
+    ∀ l ∈ ${id}_flaws, evalC (foldT ${id}_fold ρ maps t) maps l = true := by
+  intro maps ρ hp t ht l hl
+  simp only [${id}_flaws, List.mem_cons, List.not_mem_nil, or_false] at hl
+  rcases hl with ${laws.map(() => 'rfl').join(' | ')}
+  ${laws.map((_, j) => `· exact ${id}_law${j}_holds maps ρ hp t ht`).join('\n  ')}` };
+}
 // A function defined by a recurrence (core/dsl.ts recur): its Lean definition by the same recurrence, and its lemmas
 // proven together by induction (each case by omega, its min, max and ifs split first), and its laws between two points
 // by induction on the distance. A function of several arguments is `<name>_rec`, its further arguments first, and the
@@ -916,8 +1290,10 @@ function recurKernel(lean, r, uses, which) {
     const cite = (f) => { const j = r.lemmas.findIndex(l => f.name === `${l.name} at x`); return two && j >= 0 ? `(${lean}_lemmas ${args.join(' ')} x)${proj(j, r.lemmas.length)}` : undefined; };
     const factsAt = factsProof(id, m, fnNames, vars, [`${id}_ρ`, `${id}_μ`, ...recurDefs], { binders, rho: `(${id}_ρ ${ps})`, mu: `${id}_μ`, cite });
     const unfold = [`${id}_machine`, `${id}_μ`, 'applyS', 'assoc', 'lookup', 'evalE', 'evalC', ...recurDefs].join(', ');
+    // (with cyclic certificates, the machine's laws from its cyclic proof, where it has one)
+    const cyc = certsOn ? cycMachineToLean(id, m, pr.laws, { noFacts: true }) : undefined;
     const pre = `
-${smachineToLean(id, m, pr.laws, { noFacts: true })}
+${cyc && 'text' in cyc ? cyc.text : smachineToLean(id, m, pr.laws, { noFacts: true })}
 def ${id}_ρ ${binders} : Nat → Nat := fun i => ${chain(start.map(([n, e]) => [col(n), e]), '0', 'i')}
 noncomputable def ${id}_μ : Nat → Nat → Nat := fun j => ${chain(fnNames.map((n, j) => [j, `(${m.fns[n].lean})`]), 'fun _ => 0', 'j')}${factsAt}
 -- The run of ${m.name} that ${two ? 'counts y up from x' : 'counts x up from 0'}: reachable, and holding ${two ? 'y = x + n and f(y)' : 'x = n and f(x)'}.
@@ -939,7 +1315,9 @@ theorem ${id}_run ${binders} : ∀ n, ∃ ρ, SReach ${id}_machine ρ ${id}_μ
     all_goals simp [sNext, sView, decideFlags, decideQ, flagSub, withInputs, withCarried, ${hs.join(', ')}, ${unfold}]`;
     // The lemmas (or the laws between, after the lemmas at y): each the machine's law read on the run.
     const own = two ? r.between.map((_, j) => r.lemmas.length + j) : r.lemmas.map((_, j) => j);
-    const each = (j) => `by have h := ${id}_laws ρ ${id}_μ hr ${id}_e${j} (by simp [${id}_proof]); simp [SEntry.Holds, holdsOver, ${id}_e${j}, ${id}_l${j}, MLaw.Holds, evalC, evalE, ${hs.join(', ')}] at h; simpa using h`;
+    const each = (j) => (cyc && 'text' in cyc
+        ? `by have h := ${id}_law${j}_holds ρ ${id}_μ hr ρ (fun _ _ => rfl); simp [${id}_law${j}, evalC, evalE, ${hs.join(', ')}] at h; simpa using h`
+        : `by have h := ${id}_laws ρ ${id}_μ hr ${id}_e${j} (by simp [${id}_proof]); simp [SEntry.Holds, holdsOver, ${id}_e${j}, ${id}_l${j}, MLaw.Holds, evalC, evalE, ${hs.join(', ')}] at h; simpa using h`);
     const proof = (from) => `(obtain ⟨ρ, hr, ${hs.join(', ')}⟩ := ${id}_run ${from}; exact ${own.length === 1 ? `(${each(own[0])})` : `⟨${own.map(j => `(${each(j)})`).join(', ')}⟩`})`;
     return { pre, proof };
 }
@@ -1068,10 +1446,18 @@ export function hmachineToLean(id, m, laws, tampers = [], corollary) {
 // `decide +kernel` (Lean's kernel alone). Every such theorem then also rests on an axiom of its own that `#print axioms`
 // names (`…_native.native_decide.ax_…`): it trusts Lean's compiler, its runtime and the C compiler. Defaults to off, or
 // to GDP_LEAN_NATIVE=1 (the suite's quick runs); a release's proofs stay on Lean's kernel and its core axioms.
+// `cyclic`: each machine, loop and fold the cyclic route covers from cyclic certificates (see cycMachineToLean); defaults
+// to GDP_CERT=cyclic. `certReport` then says which items went which way.
 export function toLean(items, opts = {}) {
-    const outer = checkBy;
+    const outer = checkBy, outerCerts = certsOn;
     const env = globalThis.process?.env;
     checkBy = (opts.native ?? env?.GDP_LEAN_NATIVE === '1') ? 'native_decide' : 'decide +kernel';
+    certsOn = opts.cyclic ?? cyclicCerts();
+    certReport.cyclic = [];
+    certReport.usual = [];
+    certReport.translatedSteps = [];
+    cycTexts = 0;
+    usualMade.clear();
     // 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;
@@ -1080,6 +1466,7 @@ export function toLean(items, opts = {}) {
     }
     finally {
         checkBy = outer;
+        certsOn = outerCerts;
         minimal.on = wasMinimal;
     }
 }
@@ -1107,21 +1494,29 @@ function toLeanWith(items, opts) {
         return `${pairing}${text}\n`;
     }).join('');
     for (let item of items) {
-        const id = ident(item.id);
+        const id = ident(item.id), tItem = performance.now();
         if ('machine' in item) {
             const m = item.machine;
             // Laws with some key go in as the prover proved them: with its witness in place (the stronger law).
             const someKey = (c) => JSON.stringify(c).includes('"op":"all"');
             if ([...item.laws.map(l => l.holds), ...(item.stepLaws ?? []).map(sl => sl.then)].some(someKey)) {
-                const r = proveStepLaws(m, item.laws, item.stepLaws ?? []);
+                const r = proveStepLawsOnce(m, item.laws, item.stepLaws ?? []);
                 if (!r.proven)
                     throw new Error(`${item.id}: not proven (${r.failed?.stuck ?? ''})`);
                 item = { ...item, laws: r.laws ?? item.laws, ...(item.stepLaws ? { stepLaws: r.stepLaws ?? item.stepLaws } : {}) };
             }
             // One twin: every machine goes to Lean as a machine with sets (one with none, if it has none): its laws, step laws,
             // liveness and ghosts in one export; a machine with a history as its plain machine, and its laws over histories.
-            parts.push(`-- ${item.id}\n${recurDefs(m)}${item.lean?.defs ? `${item.lean.defs}\n` : ''}${smachineToLean(id, m, item.laws, { stepLaws: item.stepLaws, ...(item.liveness?.length ? { liveness: item.liveness } : {}),
-                ...(item.ghosts?.length ? { ghosts: item.ghosts } : {}), ...(item.lean?.simp ? { simp: item.lean.simp } : {}), ...(item.lean?.after ? { after: item.lean.after } : {}) })}`);
+            // With cyclic certificates, from one cyclic proof where the cyclic route covers it.
+            const mopts = { stepLaws: item.stepLaws, ...(item.liveness?.length ? { liveness: item.liveness } : {}),
+                ...(item.ghosts?.length ? { ghosts: item.ghosts } : {}), ...(item.lean?.simp ? { simp: item.lean.simp } : {}), ...(item.lean?.after ? { after: item.lean.after } : {}) };
+            const defs = `${recurDefs(m)}${item.lean?.defs ? `${item.lean.defs}\n` : ''}`;
+            const cyc = certsOn ? cycMachineToLean(id, m, item.laws, mopts) : undefined;
+            if (cyc && 'text' in cyc)
+                certReport.cyclic.push(item.id);
+            else if (cyc)
+                certReport.usual.push({ id: item.id, why: cyc.why });
+            parts.push(`-- ${item.id}\n${defs}${cyc && 'text' in cyc ? cyc.text : smachineToLean(id, m, item.laws, mopts)}`);
             theorems.push(`${id}_laws`, ...(m.history ? [`${id}_hlaws`] : []), ...(item.stepLaws ?? []).map((_, j) => `${id}_step${j}_holds`), ...(item.liveness ?? []).map((_, j) => `${id}_live${j}_holds`));
             if (item.lean?.after)
                 theorems.push(...[...item.lean.after(() => 0).matchAll(/^theorem (\S+)/gm)].map(x2 => x2[1]));
@@ -1133,11 +1528,24 @@ function toLeanWith(items, opts) {
             const laws = [...relation, { name: `${spec.name}'s precondition`, holds: spec.pre ?? atMost(n(0), n(0)) }];
             const sl = R.stepLaws[0] ?? { name: `${spec.name} allows the request it is sent`, then: { op: 'or', xs: [stutter, atMost(n(0), n(0))] } };
             const refined = { impl: S.impl, spec: S.spec, wit: witness, stutter, specPre: relation.length }, free = spec.inputs.map(i => `b_${i}`);
-            parts.push(`-- ${item.id}\n${smachineToLean(id, R.machine, laws, { stepLaws: [sl], free, refined })}`);
+            // With cyclic certificates: the composite's laws and its step law (Lean's SRefined.allowed, built here as Lean builds
+            // it) from one cyclic proof, through BridgeRules.lean's srefines_of_holds.
+            const cyc = certsOn ? cycMachineToLean(id, R.machine, laws, { free, refined: { ...refined, step: sl } }) : undefined;
+            if (cyc && 'text' in cyc)
+                certReport.cyclic.push(item.id);
+            else if (cyc)
+                certReport.usual.push({ id: item.id, why: cyc.why });
+            parts.push(`-- ${item.id}\n${cyc && 'text' in cyc ? cyc.text : smachineToLean(id, R.machine, laws, { stepLaws: [sl], free, refined })}`);
             theorems.push(`${id}_laws`, `${id}_refines`);
         }
         else if ('loop' in item) {
-            parts.push(`-- ${item.id}\n${loopToLean(id, item.loop, item.laws ?? [], item.rank)}`);
+            loopObligations(item.loop, item.laws ?? [], item.rank);
+            const cyc = certsOn ? cycMachineToLean(id, loopMachine(item.loop), item.laws ?? [], { liveness: [loopLiveness(item.loop, item.rank)], loop: { loop: item.loop } }) : undefined;
+            if (cyc && 'text' in cyc)
+                certReport.cyclic.push(item.id);
+            else if (cyc)
+                certReport.usual.push({ id: item.id, why: cyc.why });
+            parts.push(`-- ${item.id}\n${cyc && 'text' in cyc ? cyc.text : loopToLean(id, item.loop, item.laws ?? [], item.rank)}`);
             theorems.push(`${id}_halts`);
         }
         else if ('cyclic' in item) {
@@ -1147,7 +1555,12 @@ function toLeanWith(items, opts) {
             ...(item.after ? (ts => (item.data ? ts.slice(-1).map(t => `${id}.${t}`) : ts))([...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)}`);
+            const cyc = certsOn ? cycFoldToLean(id, item.fold, item.laws) : undefined;
+            if (cyc && 'text' in cyc)
+                certReport.cyclic.push(item.id);
+            else if (cyc)
+                certReport.usual.push({ id: item.id, why: cyc.why });
+            parts.push(`-- ${item.id}\n${cyc && 'text' in cyc ? cyc.text : foldToLean(id, item.fold, item.laws)}`);
             theorems.push(`${id}_laws`);
         }
         else {
@@ -1156,10 +1569,12 @@ function toLeanWith(items, opts) {
             parts.push(goalToLean({ name: item.id, goal: item.goal, tree: grown(item.goal) }, n, false).replace(new RegExp(`\\bt${n}(_goal|_tree)?\\b`, 'g'), (_, suffix) => `${id}${suffix ?? ''}`));
             theorems.push(id);
         }
+        if (envOf()?.GDP_LEAN_TIMES === '1')
+            console.error(`lean item ${item.id}: ${Math.round(performance.now() - tItem)} ms, ${parts.at(-1)?.length ?? 0} bytes`);
     }
     // 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
-${items.some(item => 'cyclic' in item) ? (items.some(item => 'cyclic' in item && (item.bridge || item.recur || item.fold)) ? 'import Bridge\n' : 'import Cyclic\n') : ''}${items.some(item => 'cyclic' in item && item.data) ? 'import Data\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'}
+${cycTexts ? 'import BridgeRules\n' : ''}${items.some(item => 'cyclic' in item) ? (items.some(item => 'cyclic' in item && (item.bridge || item.recur || item.fold)) ? 'import Bridge\n' : 'import Cyclic\n') : ''}${items.some(item => 'cyclic' in item && item.data) ? 'import Data\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
@@ -1200,10 +1615,35 @@ export function cyclicToLean(id, p, tampered = [], after, bridge, recur, fold) {
         ...(fold ? [...Object.values(fold.fold.leaf), ...Object.values(fold.fold.node), ...fold.laws.map((l) => ({ op: 'if', c: l.holds, then: v('n$'), else: v('n$') }))] : []),
         ...(fold ? ['Kind', 'Left', 'Right', ...fnames, ...fold.fold.inputs].map((x) => ({ op: 'get', map: `${x}@`, key: v('n$') })) : [])]);
     const { e, c } = leanTerms(vars, maps, id);
+    const ix = (name) => vars.indexOf(name), 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(', ')})
+${cycProofText(id, p, tampered, vars, maps)}${bridge ? `\n${cycBridgeLean(id, p, bridge, vars, maps, { e, c })}` : ''}${recur ? `\n${cycRecurLean(id, p, recur, vars, maps, { e, c })}` : ''}${fold ? `\n${cycFoldLean(id, fold.fold, fold.laws, vars, maps, { e, c })}` : ''}${after ? `\n${after(ix, mx)}` : ''}`;
+}
+// A cyclic proof as Lean: its facts and nodes (each goal's table and tree, Lean building the goals from the nodes), each
+// node's membership, the check and cyclic_sound's theorem; each tampered proof's check computed to false.
+function cycProofText(id, p, tampered, vars, maps) {
+    const { e, c } = leanTerms(vars, maps, id);
+    // (data, not code: no compiled code for Lean to make, unless native_decide runs it)
+    const d = checkBy === 'native_decide' ? 'def' : 'noncomputable def';
     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})`; };
+    // Each table once (`<id>_tabN`): a node's goals (its own, each use's premises and descent) share its hypotheses, so
+    // most of their tables are the same columns, and Lean elaborates each list once instead of once per goal.
+    // So too each term column's term (an open choice the tables share) and each goal's table and tree where two goals
+    // have the same (a premise read at the same terms by two nodes).
+    const shared = (prefix) => {
+        const seen = new Map();
+        return { seen, name: (text) => { let name = seen.get(text); if (!name)
+                seen.set(text, (name = `${id}_${prefix}${seen.size}`)); return name; } };
+    };
+    const terms = shared('term'), tabs = shared('tab'), goals = shared('goal');
+    const enc = (g, tree) => {
+        const x = encode({ name: `${id}: ${g.name}`, goal: g, tree }, false, true, vars, maps, true);
+        const tab = list(x.tabCols.map(col => (col.startsWith('.term (') && col.length > 48 ? `.term ${terms.name(col.slice(6))}` : col)));
+        const pair = `(${tabs.name(tab)}, ${x.tree})`;
+        return pair.length > 200 ? goals.name(pair) : pair;
+    };
     const nodeLits = (q) => q.nodes.map((n, i) => {
         const o = p.nodes[i];
         const uses = n.uses.map((u, j) => {
@@ -1213,22 +1653,24 @@ export function cyclicToLean(id, p, tampered = [], after, bridge, recur, fold) {
         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}⟩
+    const own = nodeLits(p), bad = tampered.map(t => nodes(t.proof));
+    return `${d} ${id}_facts : List Fact := ${facts}
+${[...terms.seen].map(([t, name]) => `${d} ${name} : E := ${t}`).join('\n')}
+${[...tabs.seen].map(([tab, name]) => `${d} ${name} : List VDef := ${tab}`).join('\n')}
+${[...goals.seen].map(([g, name]) => `${d} ${name} : List VDef × Tree := ${g}`).join('\n')}
+${own.map((x, i) => `${d} ${id}_hyps${i} : List C := ${x.hyps}
+${d} ${id}_concl${i} : C := ${x.concl}
+${d} ${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}`))}
+${d} ${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')}${bridge ? `\n${cycBridgeLean(id, p, bridge, vars, maps, { e, c })}` : ''}${recur ? `\n${cycRecurLean(id, p, recur, vars, maps, { e, c })}` : ''}${fold ? `\n${cycFoldLean(id, fold.fold, fold.laws, vars, maps, { e, c })}` : ''}${after ? `\n${after(ix, mx)}` : ''}`;
+${d} ${id}_tampered${j} : List CNode := ${bad[j]}
+example : checkCyclic ${id}_facts ${id}_tampered${j} = false := by ${checkBy}`).join('\n')}`;
 }
 function cycScope(all, bridge, extra = []) {
     const names = (t) => [...JSON.stringify(t).matchAll(/"op":"var","name":"([^"]+)"/g)].map(m => m[1]);