gdp-wired 0.17.0 → 0.19.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, cyclicMachine, foldNodes, hasQuantified, kWhens, machineNodes, proveCyclic, qflagNodes, routeOf, searchedStepNodes, skMachine, stepLawNodes, tBack, tSub } from "../core/cyclic.js";
 import { leanLibrary } from "./library.js";
 export { leanLibrary };
 // --- to Lean ------------------------------------------------------------------------------------------------------------
@@ -131,12 +132,24 @@ export function encode(ex, tamper = false, dropStep = true, globalVars, globalMa
     // monomial with a cell among its factors after the cells.
     const degree = (a, b) => factorsOf(a).length - factorsOf(b).length;
     const plainMonos = [...monos].filter(m => factorsOf(m).every(f => !isCell(f))).sort(degree), cellMonos = [...monos].filter(m => factorsOf(m).some(isCell)).sort(degree);
-    const cols = [...vars, ...plainMonos, ...[...terms].sort((a, b) => Number(a.slice(1, -1)) - Number(b.slice(1, -1))), ...[...cells].sort((a, b) => depth(a) - depth(b)), ...cellMonos];
+    // A cell whose key reads a product of cells (a cyclic proof's map at u + k·Ω, its key k read from a map over time)
+    // comes after that product, and the product after its cells: each column placed after the columns it reads.
+    const late = [], placed = new Set();
+    const place = (name) => {
+        if (placed.has(name))
+            return;
+        placed.add(name);
+        for (const d of isMonomial(name) ? factorsOf(name) : Object.keys(cellKey(name)))
+            if (cells.has(d) || cellMonos.includes(d))
+                place(d);
+        late.push(name);
+    };
+    for (const cell of [...cells].sort((a, b) => depth(a) - depth(b)))
+        place(cell);
+    for (const mono of cellMonos)
+        place(mono);
+    const cols = [...vars, ...plainMonos, ...[...terms].sort((a, b) => Number(a.slice(1, -1)) - Number(b.slice(1, -1))), ...late];
     const col = new Map(cols.map((name, j) => [name, j]));
-    for (const cell of cells)
-        for (const key of Object.keys(cellKey(cell)))
-            if (cellMonos.includes(key))
-                throw new Error(`${ex.name}: the key of ${cell} reads a product of cells`);
     const maps = globalMaps ?? [...new Set([...[...cells].map(cellMap), ...goal.hyps.flatMap(h => [...JSON.stringify(h).matchAll(/"op":"get","map":"([^"]+)"/g)].map(m => m[1]))])];
     const dense = (lin) => {
         const coefs = new Array(cols.length).fill(0);
@@ -321,6 +334,7 @@ theorem ${id}_laws : ∀ maps ρ, evalC ρ maps ${id}_fold.pre = true → ∀ t,
 // Readable corollaries: each law as a plain Lean statement over named variables (ρ the state, μ the maps, each name an
 // abbreviation for its column), proven from the machine's theorem by unfolding the law's own definition. The statement
 // is what a Lean development cites; the column numbers stay inside the namespace.
+// `have`: the line that gives each law as a hypothesis hl (an SEntry's Holds by default; a cyclic proof's, holdsOver).
 export function readable(id, laws, vars, maps, reach) {
     for (const name of [...vars, ...maps])
         if (name === 'ρ' || name === 'μ' || name.includes('«') || name.includes('»'))
@@ -363,35 +377,11 @@ export function readable(id, laws, vars, maps, reach) {
 ${[...vars.filter(v => used.has(v)).map(v => `abbrev ${q(v)} : Nat := ${vars.indexOf(v)}`), ...maps.filter(mp => used.has(mp)).map(mp => `abbrev ${q(mp)} : Nat := ${maps.indexOf(mp)}`)].join('\n')}
 ${laws.map((law, j) => (law.stated ? `-- ${law.name}: as written, with some key; proven (below) with the prover's witness in place\n` : '') + (JSON.stringify(law.holds).includes('"op":"if"') ? `-- ${law.name}: its terms read an if, so no plain statement here (${id}_laws holds it)` : `/-- ${law.name.replace(/-\//g, '- /')} -/
 theorem law${j} ${reach.binders} (h : ${reach.hyp}) : ${statement(law)} := by
-  ${law.keys?.length ? `have hl : ${id}_e${j}.Holds ρ μ := ${reach.call} ${id}_e${j} (by simp [${id}_proof])
-  exact fun k ${law.keys.map((_, i) => `k${i + 2}`).join(' ')} => (evalC_iff (upd (${law.keys.reduce((acc, key, i) => `upd (${acc}) ${vars.indexOf(key)} k${i + 2}`, 'ρ')}) ${vars.indexOf(law.forall)} k) μ ${id}_l${j}.holds).mp (hl ${law.keys.map((_, i) => `k${i + 2}`).join(' ')} k)` : `have hl : ${id}_l${j}.Holds ρ μ := ${reach.call} ${id}_e${j} (by simp [${id}_proof])
+  ${law.keys?.length ? `${reach.have ? reach.have(j) : `have hl : ${id}_e${j}.Holds ρ μ := ${reach.call} ${id}_e${j} (by simp [${id}_proof])`}
+  exact fun k ${law.keys.map((_, i) => `k${i + 2}`).join(' ')} => (evalC_iff (upd (${law.keys.reduce((acc, key, i) => `upd (${acc}) ${vars.indexOf(key)} k${i + 2}`, 'ρ')}) ${vars.indexOf(law.forall)} k) μ ${id}_l${j}.holds).mp (hl ${law.keys.map((_, i) => `k${i + 2}`).join(' ')} k)` : `${reach.have ? reach.have(j) : `have hl : ${id}_l${j}.Holds ρ μ := ${reach.call} ${id}_e${j} (by simp [${id}_proof])`}
   ${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))},
@@ -511,6 +501,49 @@ const boundKeys = (m) => [...Object.values(m.step.flags ?? {}).flatMap(c => (c.o
 // the relations assumed), built in Lean from the machine and its history (History.lean's HMachine.plain), so every claim
 // below is about it; with the relations' record goals, its laws hold over histories too (hmachine_sound).
 // `historyTampers`: the history with other relations, each refused.
+// A machine as Sets.lean's SMachine literal: its variables and maps numbered by `ix` and `mx`, its terms by `t`.
+export function machineLit(mm, t, ix, mx) {
+    const { e, c } = t;
+    const fl = flagsOfM(mm), fs = Object.entries(mm.step.flags ?? {}), ws = Object.entries(mm.step.maps ?? {});
+    return `⟨⟨⟨${list(mm.inputs.map(name => String(ix(name))))},
+  ${list(Object.entries(mm.state).map(([name, e2]) => `(${ix(name)}, ${e(e2)})`))},
+  ${list(Object.entries(mm.maps ?? {}).map(([name, c2]) => `(${mx(name)}, ${c2})`))},
+  ${list(Object.entries(mm.step.state ?? {}).map(([name, e2]) => `(${ix(name)}, ${e(e2)})`))},
+  ${list(ws.flatMap(([name, w]) => ('each' in w ? [] : [`(${mx(name)}, ${e(w.key)}, ${e(w.value)})`])))},
+  ${mm.pre ? c(mm.pre) : TRUE},
+  ${mm.assume ? c(mm.assume) : TRUE}⟩,
+  ${list(fs.flatMap(([f, c2]) => (c2.op === 'all' ? [] : [`(${ix(`?${f}`)}, ${c(fl[f])})`])))}⟩,
+  ${list((mm.inputMaps ?? []).map(mp => String(mx(mp))))},
+  ${list(ws.flatMap(([name, w]) => ('each' in w ? [`(${mx(name)}, ${ix(w.each)}, ${e(w.value)})`] : [])))},
+  ${list(fs.flatMap(([f, c2]) => (c2.op === 'all' ? [`(${ix(`?${f}`)}, ${list(boundOf(c2).map(key => String(ix(key))))}, ${c(c2.c)})`] : [])))},
+  ${list(fs.flatMap(([f, c2]) => (c2.op === 'all' ? [`(${ix(`?${f}`)}, ${list(witnessesOf(f, c2).map(w => String(ix(w))))})`] : [])))},
+  ${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 ?? [];
@@ -613,12 +646,8 @@ theorem ${id}_orig_laws : ∀ ρ M, SReach ${id}_ghosted.orig ρ M → ∀ e ∈
     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,
@@ -684,13 +713,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)
@@ -698,23 +723,7 @@ theorem ${id}_orig_laws : ∀ ρ M, SReach ${id}_ghosted.orig ρ M → ∀ e ∈
     const mx = (name) => { const j = mapNames.indexOf(name); if (j < 0)
         throw new Error(`${id}: no map for ${name}`); return j; };
     const inline = (c2) => substC(c2, { vars: {}, maps: {}, flags: flagsOfM(m) });
-    const lit = (mm) => {
-        const fl = flagsOfM(mm), fs = Object.entries(mm.step.flags ?? {}), ws = Object.entries(mm.step.maps ?? {});
-        return `⟨⟨⟨${list(mm.inputs.map(name => String(ix(name))))},
-  ${list(Object.entries(mm.state).map(([name, e2]) => `(${ix(name)}, ${e(e2)})`))},
-  ${list(Object.entries(mm.maps ?? {}).map(([name, c2]) => `(${mx(name)}, ${c2})`))},
-  ${list(Object.entries(mm.step.state ?? {}).map(([name, e2]) => `(${ix(name)}, ${e(e2)})`))},
-  ${list(ws.flatMap(([name, w]) => ('each' in w ? [] : [`(${mx(name)}, ${e(w.key)}, ${e(w.value)})`])))},
-  ${mm.pre ? c(mm.pre) : TRUE},
-  ${mm.assume ? c(mm.assume) : TRUE}⟩,
-  ${list(fs.flatMap(([f, c2]) => (c2.op === 'all' ? [] : [`(${ix(`?${f}`)}, ${c(fl[f])})`])))}⟩,
-  ${list((mm.inputMaps ?? []).map(mp => String(mx(mp))))},
-  ${list(ws.flatMap(([name, w]) => ('each' in w ? [`(${mx(name)}, ${ix(w.each)}, ${e(w.value)})`] : [])))},
-  ${list(fs.flatMap(([f, c2]) => (c2.op === 'all' ? [`(${ix(`?${f}`)}, ${list(boundOf(c2).map(key => String(ix(key))))}, ${c(c2.c)})`] : [])))},
-  ${list(fs.flatMap(([f, c2]) => (c2.op === 'all' ? [`(${ix(`?${f}`)}, ${list(witnessesOf(f, c2).map(w => String(ix(w))))})`] : [])))},
-  ${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))))})`))}⟩`;
-    };
+    const lit = (mm) => machineLit(mm, { e, c }, ix, mx);
     // A loop as Live.lean's record: inputs, start, body, while, precondition, assumption.
     const loopLit = (lp) => `⟨${list(lp.inputs.map(name => String(ix(name))))},
   ${list(Object.entries(lp.state).map(([name, e2]) => `(${ix(name)}, ${e(e2)})`))},
@@ -814,6 +823,325 @@ ${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`. What the cyclic route doesn't cover goes the usual
+// way: a flag that holds at every key, a law that reads a map at a key read from a map, a refinement, and a liveness's
+// weak fairness (its helpful requests proven allowed: a claim about requests the run doesn't take).
+const envOf = () => globalThis.process?.env;
+export const cyclicCerts = () => envOf()?.GDP_CERT !== 'usual';
+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 = proveStepLaws(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 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 (!q && 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 (q ? [qflagNodes(m, laws, lp.instances)]
+        : [...(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';
+    for (const { facts, specs: specs0, lawNodes, stepAt, translated } of tries) {
+        if (performance.now() > until)
+            return { why: `past the certificate's deadline (${certMs()} ms)` };
+        let specs = specs0, v = proveCyclic(facts, specs);
+        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;
+    if (!cyclicMachine(skMachine(m), laws))
+        return { why: 'a law reading a map at a key read from a map' };
+    // 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}`;
+    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 := by ${checkBy}
+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 := by ${checkBy}
+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 (by ${checkBy})⟩`).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)} (by ${checkBy})
+theorem ${lid}_cover : SKStepHolds ${id}_machine (liveK ${lid} ${lid}.pend (liveCoverC ${lid})) := ${kstep('_', c0)} (by ${checkBy})
+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))} (by ${checkBy})`).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])} (by ${checkBy})
+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)}
+${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
@@ -900,8 +1228,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)'}.
@@ -923,7 +1253,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 };
 }
@@ -1052,10 +1384,17 @@ 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;
     // 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;
@@ -1064,6 +1403,7 @@ export function toLean(items, opts = {}) {
     }
     finally {
         checkBy = outer;
+        certsOn = outerCerts;
         minimal.on = wasMinimal;
     }
 }
@@ -1104,8 +1444,16 @@ function toLeanWith(items, opts) {
             }
             // 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]));
@@ -1117,19 +1465,39 @@ 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) {
-            parts.push(`-- ${item.id}\n${cyclicToLean(id, item.cyclic, item.tampered ?? [], item.after)}`);
-            theorems.push(`${id}_sound`, ...(item.after ? [...item.after(() => 0, () => 0).matchAll(/^theorem (\S+)/gm)].map(x2 => x2[1]) : []));
+            parts.push(`-- ${item.id}\n${cyclicToLean(id, item.cyclic, item.tampered ?? [], item.after, item.bridge, item.recur, item.fold)}`);
+            theorems.push(`${id}_sound`, ...(item.bridge?.laws ?? item.fold?.laws ?? []).map((_, j) => `${id}_law${j}_holds`), ...(item.recur ? [`${id}_values`] : []), ...(item.recur ? [...item.recur.lemmas.map((_, j) => `${id}_lemma${j}`), ...item.recur.between.map((_, j) => `${id}_between${j}`)] : []), 
+            // A datatype law's theorem is in a namespace of the item's (its datatypes and functions are named as declared).
+            ...(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 {
@@ -1141,7 +1509,7 @@ function toLeanWith(items, opts) {
     }
     // The file the items need: Live.lean for a liveness or a loop, Sets.lean (which imports Steps.lean) for any machine.
     return `import History
-${items.some(item => 'cyclic' in item) ? 'import Cyclic\n' : ''}import ${items.some(item => 'refinement' in item) ? 'Refine' : items.some(item => 'machine' in item && item.ghosts?.length) ? 'Ghost' : items.some(item => ('machine' in item && item.liveness?.length) || 'loop' in item) ? 'Live' : items.some(item => 'machine' in item) ? 'Sets' : 'Steps'}
+${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
@@ -1173,14 +1541,22 @@ lean_lib ${name} where
 `,
     };
 }
-// A cyclic proof through Kern.cyclic_sound: the facts and the nodes, each goal's table and tree (Lean builds the goals
-// from the nodes), one theorem for every node; each tampered proof's check computed to false. `after` writes Lean
-// after it (a corollary in plain terms), given the variables' and maps' numbers.
-export function cyclicToLean(id, p, tampered = [], after) {
+export function cyclicToLean(id, p, tampered = [], after, bridge, recur, fold) {
     const all = [p, ...tampered.map(t => t.proof)];
-    const names = (t) => [...JSON.stringify(t).matchAll(/"op":"var","name":"([^"]+)"/g)].map(m => m[1]);
-    const vars = [...new Set(all.flatMap(q => [...q.facts.flatMap(f => [...f.keys, ...names(f.holds)]), ...q.nodes.flatMap(n => [...names([n.hyps, n.concl, n.rank, n.insts]), ...n.uses.flatMap(u => [...Object.keys(u.subst), ...names([u.subst, u.guard])])])]))];
-    const maps = [...new Set([...JSON.stringify(all).matchAll(/"op":"get","map":"([^"]+)"/g)].map(m => m[1]))];
+    const v = (name) => ({ op: 'var', name });
+    const fnames = fold ? Object.keys(fold.fold.leaf) : [];
+    const { vars, maps } = cycScope(all, bridge, [...(recur ? [recur.zero, recur.next, v('x'), v('prev'), v('k$'), ...recur.args.map(v)] : []),
+        ...(fold ? [...fold.fold.params, ...fold.fold.inputs, ...fnames, ...fnames.map(x => `l_${x}`), ...fnames.map(x => `r_${x}`), 'n$', 'N$'].map(v) : []),
+        ...(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);
     const ix = (name) => vars.indexOf(name);
     const facts = list(p.facts.map(f => `⟨${list(f.keys.map(key => String(ix(key))))}, ${c(f.holds)}⟩`));
@@ -1195,9 +1571,7 @@ export function cyclicToLean(id, p, tampered = [], after) {
         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}
+    return `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}⟩
@@ -1210,5 +1584,163 @@ theorem ${id}_sound : ∀ (maps : Nat → Nat → Nat) env, FactsHold ${id}_fact
   cyclic_sound ${id}_facts ${id}_nodes ${id}_check
 ${tampered.map((t, j) => `-- TAMPERED: ${t.what}. Lean computes the check to false.
 def ${id}_tampered${j} : List CNode := ${nodes(t.proof)}
-example : checkCyclic ${id}_facts ${id}_tampered${j} = false := by ${checkBy}`).join('\n')}${after ? `\n${after(ix, mx)}` : ''}`;
+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]);
+    const ms = bridge ? [bridge.machine, ...(bridge.tampered ?? []).map(t => t.machine)] : [];
+    const keysOf = (l) => [...(l.forall ? [l.forall] : []), ...(l.keys ?? [])];
+    const traced = (m) => [...Object.keys(m.state), ...m.inputs], tracedMaps = (m) => [...Object.keys(m.maps ?? {}), ...(m.inputMaps ?? [])];
+    const machineVars = ms.flatMap(m => [...m.params, ...m.inputs, ...Object.keys(m.state), ...Object.keys(m.step.flags ?? {}).map(f => `?${f}`),
+        ...Object.values(m.step.maps ?? {}).flatMap(w => ('each' in w ? [w.each] : [])), ...(m.facts ?? []).flatMap(keysOf), ...names([m.state, m.step, m.pre, m.assume, m.facts])]);
+    const vars = [...new Set([...all.flatMap(q => [...q.facts.flatMap(f => [...f.keys, ...names(f.holds)]), ...q.nodes.flatMap(n => [...names([n.hyps, n.concl, n.rank, n.insts]), ...n.uses.flatMap(u => [...Object.keys(u.subst), ...names([u.subst, u.guard])])])]),
+            ...machineVars, ...(bridge ? [...bridge.laws.flatMap(l => [...keysOf(l), ...names(l.holds)]), 'u$', 'k$', 'T$', 'O$', 't$'] : []), ...names(extra)])];
+    const maps = [...new Set([...[...JSON.stringify([all, ms, bridge?.laws ?? []]).matchAll(/"op":"get","map":"([^"]+)"/g)].map(m => m[1]),
+            ...ms.flatMap(m => [...tracedMaps(m), ...Object.keys(m.fns ?? {}), ...traced(m).map(x => `${x}@`), ...tracedMaps(m).map(x => `${x}@`)])])];
+    return { vars, maps };
+}
+// Bridge.lean's cycMOk alone, part by part, for each law of a machine (the sweep research/cyclic/bridge.ts runs over the
+// examples): the facts and nodes machineNodes makes, each node with no proof (cycMOk reads only its hypotheses and
+// conclusion), against the machine's encoding. Each part an example, named in a comment before it.
+export function cycEncodingLean(id, facts, nodes, b) {
+    const shape = { facts, nodes: nodes.map(n => ({ hyps: n.hyps, concl: n.concl, rank: [], insts: [], uses: [] })) };
+    const { vars, maps } = cycScope([shape], b);
+    const t = 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 m = b.machine, keysOf = (l) => list([...(l.forall ? [l.forall] : []), ...(l.keys ?? [])].map(k2 => String(ix(k2))));
+    const by = checkBy;
+    return `-- ${id}: ${m.name}
+def ${id}_machine : SMachine := ${machineLit(m, t, ix, mx)}
+def ${id}_enc : CycEnc := ⟨${['u$', 'k$', 'T$', 'O$', 't$'].map(ix).join(', ')},
+  ${list([...Object.keys(m.state), ...m.inputs].map(x => `(${ix(x)}, ${mx(`${x}@`)})`))},
+  ${list([...Object.keys(m.maps ?? {}), ...(m.inputMaps ?? [])].map(x => `(${mx(x)}, ${mx(`${x}@`)})`))}⟩
+${facts.map((f, i) => `-- CHECK ${id} fact ${i}: ${f.name}
+example : (natC (${t.c(f.holds)}) || (cycCanon ${id}_machine ${id}_enc).any (factBeq ⟨${list(f.keys.map(k2 => String(ix(k2))))}, ${t.c(f.holds)}⟩)) = true := by ${by}`).join('\n')}
+${b.laws.map((l, j) => `-- CHECK ${id} law ${j}: shape: ${l.name}
+example : cycShapeOk ${id}_machine ${id}_enc ${keysOf(l)} = true := by ${by}
+-- CHECK ${id} law ${j}: terms: ${l.name}
+example : cycTermsOk ${id}_machine ${id}_enc ${keysOf(l)} = true := by ${by}
+-- CHECK ${id} law ${j}: law: ${l.name}
+example : cycLawOk ${id}_machine ${id}_enc (${t.c(l.holds)}) = true := by ${by}
+-- CHECK ${id} law ${j}: node: ${l.name}
+example : cycNodeOk ${id}_machine ${id}_enc (${t.c(l.holds)}) ⟨${list(nodes[j].hyps.map(t.c))}, ${t.c(nodes[j].concl)}, [], [], [], ([], .leaf [] [] [] [])⟩ = true := by ${by}`).join('\n')}`;
+}
+// Bridge.lean's recOk and foldOk alone, for the sweep (research/cyclic/bridge.ts): recurNodes' and foldNodes' facts (and
+// a fold's nodes, with no proof: foldOk reads only their hypotheses and conclusions) against the recurrence's equations
+// and the fold's table. Each an example, named in a comment before it.
+export function cycRecurCheckLean(id, facts, r) {
+    const v = (name) => ({ op: 'var', name });
+    const { vars, maps } = cycScope([{ facts, nodes: [] }], undefined, [r.zero, r.next, v('x'), v('prev'), v('k$'), ...r.args.map(v), { op: 'get', map: `${r.name}$`, key: v('x') }]);
+    const t = leanTerms(vars, maps, id), ix = (n2) => vars.indexOf(n2), mx = (n2) => maps.indexOf(n2);
+    return `-- CHECK ${id} recurrence: ${r.name}
+example : recOk ⟨${mx(`${r.name}$`)}, ${ix('x')}, ${ix('prev')}, ${ix('k$')}⟩ (${t.e(r.zero)}) (${t.e(r.next)}) []
+    ${list(facts.map(f => `⟨${list(f.keys.map(k2 => String(ix(k2))))}, ${t.c(f.holds)}⟩`))} = true := by ${checkBy}`;
+}
+export function cycFoldCheckLean(id, facts, nodes, f, laws) {
+    const v = (name) => ({ op: 'var', name }), st = Object.keys(f.leaf);
+    const shape = { facts, nodes: nodes.map(n => ({ hyps: n.hyps, concl: n.concl, rank: [], insts: [], uses: [] })) };
+    const { vars, maps } = cycScope([shape], 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), ...['Kind', 'Left', 'Right', ...st, ...f.inputs].map((x) => ({ op: 'get', map: `${x}@`, key: v('n$') }))]);
+    const t = leanTerms(vars, maps, id);
+    return `${cycFoldLean(id, f, [], vars, maps, t)}
+def ${id}_facts : List Fact := ${list(facts.map(g => `⟨${list(g.keys.map(k2 => String(vars.indexOf(k2))))}, ${t.c(g.holds)}⟩`))}
+${laws.map((l, j) => `-- CHECK ${id} fold law ${j}: ${l.name}
+example : foldOk ${id}_fold ${id}_fenc ${id}_facts (${t.c(l.holds)}) ⟨${list(nodes[j].hyps.map(t.c))}, ${t.c(nodes[j].concl)}, [], [], [], ([], .leaf [] [] [] [])⟩ = true := by ${checkBy}`).join('\n')}`;
+}
+// Bridge.lean's cyc_fold_sound for each law of a cyclic proof made by foldNodes: the fold as Kernel.lean's Fold, the
+// table (its added variables and maps), each law's check and its theorem over trees, as fold_sound states the usual one.
+function cycFoldLean(id, f, laws, vars, maps, t) {
+    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 st = Object.keys(f.leaf);
+    return `def ${id}_fold : Fold := ⟨${list(f.inputs.map(name => String(ix(name))))},
+  ${list(st.map(n2 => `(${ix(n2)}, ${ix(`l_${n2}`)}, ${ix(`r_${n2}`)})`))},
+  ${list(Object.entries(f.leaf).map(([name, e2]) => `(${ix(name)}, ${t.e(e2)})`))},
+  ${list(Object.entries(f.node).map(([name, e2]) => `(${ix(name)}, ${t.e(e2)})`))},
+  ${f.pre ? t.c(f.pre) : TRUE},
+  ${f.assume ? t.c(f.assume) : TRUE}⟩
+def ${id}_fenc : FoldEnc := ⟨${ix('n$')}, ${ix('N$')}, ${mx('Kind@')}, ${mx('Left@')}, ${mx('Right@')}, ${list([...st, ...f.inputs].map(x => `(${ix(x)}, ${mx(`${x}@`)})`))}⟩
+${laws.map((l, j) => `-- ${l.name}
+def ${id}_law${j} : C := ${t.c(l.holds)}
+theorem ${id}_law${j}_ok : foldOk ${id}_fold ${id}_fenc ${id}_facts ${id}_law${j} ${id}_node${j} = true := by ${checkBy}
+theorem ${id}_law${j}_holds : ∀ (maps : Nat → Nat → Nat) ρ, evalC ρ maps ${id}_fold.pre = true → ∀ t, Allowed ${id}_fold ρ maps t →
+    evalC (foldT ${id}_fold ρ maps t) maps ${id}_law${j} = true :=
+  cyc_fold_sound ${id}_fold ${id}_fenc ${id}_facts ${id}_nodes ${id}_check ${id}_law${j} ${id}_node${j} ${id}_node${j}_mem ${id}_law${j}_ok`).join('\n')}`;
+}
+// Bridge.lean's cyc_recur_sound for a cyclic proof made by recurNodes: the recurrence's equations checked against the
+// proof's facts, the nodes of its values (recF), its Lean definition (as recurToLean writes it) shown to be those values,
+// and each lemma and law between two points plainly of the definition.
+function cycRecurLean(id, p, r, vars, maps, t) {
+    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 fn = `${id}_fn`, args = r.args.map(recurArg), binders = args.map(a => `(${a} : Nat)`).join(' ');
+    const call = (x) => `(${[fn, ...args, x].join(' ')})`;
+    const surface = (names) => leanSurface({ ...Object.fromEntries(r.args.map((a, i) => [a, args[i]])), ...names }, id);
+    const renc = `⟨${mx(`${r.name}$`)}, ${ix('x')}, ${ix('prev')}, ${ix('k$')}⟩`;
+    const recF = `recF ${id}_zero ${id}_next ${ix('x')} ${ix('prev')}`;
+    const envAt = (pts) => `(fun i => ${[...pts, ...r.args.map((a, i) => [a, args[i]])].map(([v, val]) => `if i = ${ix(v)} then ${val} else `).join('')}0)`;
+    const node = (j) => `${id}_node${j}`;
+    const n = r.lemmas.length;
+    return `def ${id}_renc : RecEnc := ${renc}
+def ${id}_zero : E := ${t.e(r.zero)}
+def ${id}_next : E := ${t.e(r.next)}
+theorem ${id}_rok : recOk ${id}_renc ${id}_zero ${id}_next [] ${id}_facts = true := by ${checkBy}
+theorem ${id}_values : ∀ maps env, ∀ n ∈ ${id}_nodes, (∀ c ∈ n.hyps, evalC env (withMap maps ${mx(`${r.name}$`)} (${recF} env maps)) c = true) →
+    evalC env (withMap maps ${mx(`${r.name}$`)} (${recF} env maps)) n.concl = true :=
+  fun maps env => cyc_recur_sound ${id}_renc ${id}_zero ${id}_next [] ${id}_facts ${id}_nodes ${id}_check ${id}_rok maps env (by intro f hf; simp at hf)
+-- ${r.name} as Lean defines it (recurToLean's recursion), and the same as the values the proof is about.
+def ${fn} ${binders} : Nat → Nat
+  | 0 => ${surface({}).e(r.zero)}
+  | x + 1 => ${surface({ x: 'x', prev: call('x') }).e(r.next)}
+theorem ${fn}_eq (maps : Nat → Nat → Nat) (env : Nat → Nat) : ∀ n, ${recF} env maps n = ${[fn, ...r.args.map(a => `(env ${ix(a)})`)].join(' ')} n := by
+  intro n
+  induction n with
+  | zero => simp [recF, ${id}_zero, ${fn}, evalE]
+  | succ n ih => simp only [recF]; rw [ih]; simp [${id}_next, ${fn}, evalE, upd]
+${r.lemmas.map((l, j) => `/-- ${r.name}: ${l.name} -/
+theorem ${id}_lemma${j} ${binders} (x : Nat) : ${surface({ x: 'x', fx: call('x') }).c(l.holds)} := by
+  have h := ${id}_values (fun _ _ => 0) ${envAt([['x', 'x']])} _ ${node(j)}_mem (by rw [${node(j)}_hyps]; simp [${id}_hyps${j}])
+  rw [${node(j)}_concl] at h
+  simpa [${id}_concl${j}, evalC, evalE, withMap, ${fn}_eq] using h`).join('\n')}
+${r.between.map((b, j) => `/-- ${r.name}: ${b.name}, for every x ≤ y -/
+theorem ${id}_between${j} ${binders} (x y : Nat) (hxy : x ≤ y) : ${surface({ x: 'x', fx: call('x'), y: 'y', fy: call('y') }).c(b.holds)} := by
+  have h := ${id}_values (fun _ _ => 0) ${envAt([['x', 'x'], ['y', 'y']])} _ ${node(n + j)}_mem (by rw [${node(n + j)}_hyps]; simp [${id}_hyps${n + j}])
+  rw [${node(n + j)}_concl] at h
+  simp [${id}_concl${n + j}, evalC, evalE, withMap, ${fn}_eq] at h
+  first | exact h hxy | omega | exact h.resolve_left (by omega)`).join('\n')}`;
+}
+// Bridge.lean's cyc_machine_sound for each law of a cyclic proof made by machineNodes: the machine as Sets.lean's
+// SMachine, the encoding (its added variables and maps over time), each law's check and theorem, and the laws plainly.
+function cycBridgeLean(id, p, b, vars, maps, t) {
+    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; };
+    if (b.laws.length > p.nodes.length)
+        throw new Error(`${id}: more laws than nodes`);
+    const keysOf = (l) => [...(l.forall ? [l.forall] : []), ...(l.keys ?? [])];
+    const enc = (m) => `⟨${['u$', 'k$', 'T$', 'O$', 't$'].map(ix).join(', ')},
+  ${list([...Object.keys(m.state), ...m.inputs].map(x => `(${ix(x)}, ${mx(`${x}@`)})`))},
+  ${list([...Object.keys(m.maps ?? {}), ...(m.inputMaps ?? [])].map(x => `(${mx(x)}, ${mx(`${x}@`)})`))}⟩`;
+    const keysL = (l) => list(keysOf(l).map(k2 => String(ix(k2))));
+    return `def ${id}_machine : SMachine := ${machineLit(b.machine, t, ix, mx)}
+def ${id}_enc : CycEnc := ${enc(b.machine)}
+${b.laws.map((l, j) => `-- ${l.name}
+def ${id}_law${j} : C := ${t.c(l.holds)}
+def ${id}_l${j} : MLaw := ⟨${id}_law${j}, ${l.forall ? `some ${ix(l.forall)}` : 'none'}⟩
+theorem ${id}_law${j}_ok : cycMOk ${id}_machine ${id}_enc ${id}_facts ${id}_law${j} ${keysL(l)} ${id}_node${j} = true := by ${checkBy}
+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_machine_sound ${id}_machine ${id}_enc ${id}_facts ${id}_nodes ${id}_check ${id}_law${j} ${keysL(l)} ${id}_node${j} ${id}_node${j}_mem ${id}_law${j}_ok`).join('\n')}
+${(b.tampered ?? []).map((tm, j) => `-- TAMPERED: ${tm.what}. Lean computes the check against the proof to false.
+def ${id}_tamperedm${j} : SMachine := ${machineLit(tm.machine, t, ix, mx)}
+example : cycMOk ${id}_tamperedm${j} ${id}_enc ${id}_facts ${id}_law0 ${keysL(b.laws[0])} ${id}_node0 = false := by ${checkBy}`).join('\n')}
+${readable(id, b.laws, vars, maps, { binders: '(ρ : Nat → Nat) (μ : Nat → Nat → Nat)', hyp: `SReach ${id}_machine ρ μ`, call: '',
+        have: j => `have hl : holdsOver ${id}_l${j} μ ${list((b.laws[j].keys ?? []).map(k2 => String(ix(k2))))} ρ := cyc_machine_holds (${id}_law${j}_holds ρ μ h)` })}`;
 }