gdp-wired 0.17.0 → 0.19.0

package/dist/core/cyclic.js

@@ -1,6 +1,7 @@
-import { substC, substE } from "../kernel/kernel.js";
-import { descentGoal, mainGoal, premiseGoal, refuseCyclic } from "../kernel/cyclic.js";
-import { cellProducts, grow } from "../kernel/prove.js";
+import { assumed, boundOf, foldObligations, obligations, substC, substE, witnessesOf } from "../kernel/kernel.js";
+import { baseHyps, descentGoal, instHyps, mainGoal, premiseGoal, refuseCyclic } from "../kernel/cyclic.js";
+import { cellProducts, grow, profile, usedHyps, widen } from "../kernel/prove.js";
+import { carry, decide, readsFirst, renamer, translate, tstats } from "./translate.js";
 const v = (name) => ({ op: 'var', name });
 const k = (value) => ({ op: 'const', value });
 const add = (a, b) => ({ op: 'add', a, b });
@@ -17,49 +18,334 @@ const vars = (s) => ({ vars: s, maps: {}, flags: {} });
 const omega = v('O$');
 export const pair = (u, key) => add(u, { op: 'prod', a: key, b: omega });
 // Every goal grown, then the whole checked by the kernel.
-export function proveCyclic(facts, specs) {
-    const nodes = [];
-    const grown = (g, node) => {
-        const was = cellProducts.on;
+// GDP_CYCLIC_PROF=1: each comparison's line also has where the cyclic proof's time went, by goal kind (main, premise,
+// descent, the kernel's check): ms, goals, hypotheses, solver and row ms.
+export const cyclicProf = {};
+const profOn = () => env()?.GDP_CYCLIC_PROF === '1';
+export function timedKind(kind, hyps, f) {
+    if (!profOn())
+        return f();
+    const was = profile.on, s0 = profile.solveMs, r0 = profile.rowsMs, t0 = performance.now();
+    profile.on = true;
+    try {
+        return f();
+    }
+    finally {
+        profile.on = was;
+        const p = (cyclicProf[kind] ??= { ms: 0, n: 0, hyps: 0, solveMs: 0, rowsMs: 0 });
+        p.ms += performance.now() - t0;
+        p.n++;
+        p.hyps += hyps;
+        p.solveMs += profile.solveMs - s0;
+        p.rowsMs += profile.rowsMs - r0;
+    }
+}
+// Each goal grown first on what it reads: its node's hypotheses and its own last ones (a use's guard, the conclusion
+// negated) kept whole, and of the rest (the facts at the node's terms, the uses) only the parts it reaches: a
+// conjunction's conjuncts (under a guard, as a step's equations are, one per state variable) each a part of its own; an
+// equation that gives a cell (a state variable's value at t, a function's at a key) reached when its cell is, and then
+// its terms' cells and its guard's; any other part reached when it shares a cell with what is, or reads none. The
+// weaker goal's tree is the whole goal's (`widen`); where the weaker goal isn't refuted, the whole is grown as before.
+// GDP_CYCLIC_SLICE=0 grows the whole goal only.
+// A cell by what it may be equal to: a run's map read at time u and any key (two keys the prover may prove equal) is
+// one, by its map and u; a function's read at any key is one, by the function; a run's other reads are themselves.
+const cellsIn = (t, out = new Set()) => {
+    if (t && typeof t === 'object') {
+        const o = t, map = o.map;
+        if (o.op === 'get') {
+            const key = o.key;
+            out.add(key.op === 'add' && key.b.op === 'prod' && JSON.stringify(key.b.b) === JSON.stringify(omega) ? `${map}@${JSON.stringify(key.a)}` : map.endsWith('@') ? JSON.stringify(o) : map);
+        }
+        for (const val of Object.values(o))
+            cellsIn(val, out);
+    }
+    return out;
+};
+function partsOf(c, guards = [], out = []) {
+    if (c.op === 'and')
+        c.xs.forEach(x => partsOf(x, guards, out));
+    else if (c.op === 'or' && c.xs.length === 2 && c.xs[0].op === 'not')
+        partsOf(c.xs[1], [...guards, c.xs[0]], out);
+    else
+        out.push({ c, guards });
+    return out;
+}
+function rebuild(c, keep, at = { j: 0 }) {
+    if (c.op === 'and') {
+        const xs = c.xs.flatMap(x => { const y = rebuild(x, keep, at); return y ? [y] : []; });
+        return xs.length ? and(...xs) : undefined;
+    }
+    if (c.op === 'or' && c.xs.length === 2 && c.xs[0].op === 'not') {
+        const b = rebuild(c.xs[1], keep, at);
+        return b && { op: 'or', xs: [c.xs[0], b] };
+    }
+    return keep(at.j++) ? c : undefined;
+}
+// The hypotheses with a part the goal reaches (whole ones included).
+export function reached(g, whole) { return slice(g, whole, true); }
+export function slice(g, whole, hypsOnly = false) {
+    const reach = new Set(), parts = g.hyps.map(h => partsOf(h));
+    const pieces = [];
+    g.hyps.forEach((h, i) => {
+        if (whole(i)) {
+            cellsIn(h, reach);
+            return;
+        }
+        parts[i].forEach(({ c, guards }, j) => {
+            // (an equation between two reads, a law's, gives neither: it is reached by either)
+            const gives = c.op === '=' && c.a.op === 'get' && c.b.op !== 'get' ? [...cellsIn(c.a)][0] : undefined, cells = cellsIn(c.op === '=' && gives ? c.b : c);
+            for (const x of guards)
+                cellsIn(x, cells);
+            pieces.push({ c, guards, i, j, gives, cells });
+        });
+    });
+    const kept = new Set();
+    for (let grew = true; grew;) {
+        grew = false;
+        for (const [q, p] of pieces.entries()) {
+            if (kept.has(q) || (p.gives ? !reach.has(p.gives) : p.cells.size && ![...p.cells].some(c => reach.has(c))))
+                continue;
+            kept.add(q);
+            grew = true;
+            for (const c of p.cells)
+                reach.add(c);
+            if (p.gives)
+                reach.add(p.gives);
+        }
+    }
+    if (hypsOnly)
+        return new Set(g.hyps.flatMap((_, i) => (whole(i) || pieces.some((p, q) => p.i === i && kept.has(q)) ? [i] : [])));
+    // The equations that give a cell the conclusion reads (a step's, the start's) join the conclusion, under their guards:
+    // the prover splits the conclusion's atoms first, as the usual rule does a law read after the step.
+    const last = g.hyps.length - 1, concl = whole(last) ? cellsIn(g.hyps[last]) : new Set();
+    const joins = (p) => !!p.gives && concl.has(p.gives);
+    if (kept.size === pieces.length && !pieces.some(joins))
+        return undefined;
+    const stays = new Set(), joined = [];
+    for (const [q, p] of pieces.entries())
+        if (kept.has(q)) {
+            if (joins(p))
+                joined.push(p.guards.reduceRight((acc, x) => ({ op: 'or', xs: [x, acc] }), p.c));
+            else
+                stays.add(`${p.i}:${p.j}`);
+        }
+    const from = [], joinedFrom = [...new Set(pieces.flatMap((p, q) => (kept.has(q) && joins(p) ? [p.i] : [])))];
+    const hyps = g.hyps.flatMap((h, i) => {
+        const r = whole(i) || parts[i].every((_, j) => stays.has(`${i}:${j}`)) ? h : rebuild(h, j => stays.has(`${i}:${j}`));
+        if (r)
+            from.push([i]);
+        return r ? [r] : [];
+    });
+    if (joined.length) {
+        hyps[hyps.length - 1] = and(hyps.at(-1), ...joined);
+        from[from.length - 1].push(...joinedFrom);
+    }
+    return { name: g.name, hyps, from };
+}
+const withProducts = (f) => { const was = cellProducts.on; cellProducts.on = true; try {
+    return f();
+}
+finally {
+    cellProducts.on = was;
+} };
+let sliceNow = false;
+const sliceOn = () => sliceNow && env()?.GDP_CYCLIC_SLICE !== '0';
+const afterOn = () => env()?.GDP_CYCLIC_AFTER !== '0';
+const stepNodesOn = () => env()?.GDP_CYCLIC_STEP !== '0';
+const searched = new Map();
+export const translatedCache = new Map();
+// `order`: the order the nodes are grown in, by default those with a weak variant first (a variant that uses a weak node
+// is passed over).
+// `made`: the first nodes already made (a proof of the same facts whose nodes these specs begin with), taken as they are.
+export function proveCyclic(facts, specs, order0, grownBefore = searched, st = tstats(), made = []) {
+    const order = (order0 ?? [...specs.keys()].sort((i, j) => Number(!specs[i].variants?.some(x => x.weak)) - Number(!specs[j].variants?.some(x => x.weak)))).filter(i => i >= made.length);
+    const nodes = [...made], shapes = [...specs], weak = new Set();
+    let later, refuted = false;
+    // A goal's tree, and the hypotheses its leaves read (of the whole goal, a weaker goal's read through where they came from).
+    const grown = (g, node, own) => {
+        const was = cellProducts.on, kind = g.name.endsWith('its rank below') ? 'descent' : g.name.includes(': use of node') ? 'premise' : 'main';
         cellProducts.on = true;
-        let o;
         try {
-            o = grow(g);
+            const sliced = sliceOn() ? slice(g, own) : undefined, part = sliced && hide(sliced);
+            if (part) {
+                // (within two seconds: a weaker goal no easier than the whole is left to the whole)
+                const t0 = performance.now(), p = timedKind(`${kind} sliced`, part.hyps.length, () => grow(part, new Map(), { nodes: 0, until: performance.now() + Math.min(2_000, later ?? 2_000) }));
+                if (env()?.GDP_CYCLIC_DEBUG)
+                    console.error(`[cyc] ${g.name}: ${part.hyps.length} hyps${part !== sliced ? ' (opaque)' : ''}, ${'tree' in p ? `${p.nodes} nodes` : p.stuck}, ${Math.round(performance.now() - t0)} ms`);
+                if ('tree' in p)
+                    return { tree: p.tree, from: part, used: () => new Set([...usedHyps(part, p.tree)].flatMap(i => part.from[i])) };
+                if (part !== sliced) {
+                    const q = timedKind(`${kind} sliced`, sliced.hyps.length, () => grow(sliced, new Map(), { nodes: 0, until: performance.now() + Math.min(2_000, later ?? 2_000) }));
+                    if ('tree' in q)
+                        return { tree: q.tree, from: sliced, used: () => new Set([...usedHyps(sliced, q.tree)].flatMap(i => sliced.from[i])) };
+                }
+            }
+            const o = timedKind(kind, g.hyps.length, () => grow(g, new Map(), { nodes: 0, until: performance.now() + (later ?? Math.max(20_000, 1_000 * g.hyps.length)) }));
+            return 'tree' in o ? { tree: o.tree, from: g, used: () => usedHyps(g, o.tree) } : { proven: false, checked: false, node, goal: g.name, stuck: o.stuck };
         }
         finally {
             cellProducts.on = was;
         }
-        return 'tree' in o ? o.tree : { proven: false, checked: false, node, goal: g.name, stuck: o.stuck };
     };
-    for (const n of specs) {
-        const main = grown(mainGoal(facts, specs, n), n.name);
-        if ('proven' in main)
-            return main;
-        const uses = [];
-        for (const u of n.uses) {
-            const m = specs[u.node];
-            if (!m)
-                return { proven: false, checked: false, node: n.name, goal: `use of node ${u.node}`, stuck: 'no such node' };
-            const premises = [];
-            for (const [i, c] of m.hyps.entries()) {
-                const t = grown(premiseGoal(facts, n, u, c, i), n.name);
-                if ('proven' in t)
-                    return t;
-                premises.push(t);
+    // The tree made the goal's own (a weaker goal's widened), or grown on the goal itself where that fails.
+    const own = (r, g) => (r.from === g ? r.tree : timedKind('widen', 0, () => widen(r.from, g, r.tree, opaqueOf.get(r.from))));
+    const whole = (g, node, mine) => {
+        const key = JSON.stringify(g.hyps), before = grownBefore.get(key);
+        if (before)
+            return before.tree;
+        const r = grown(g, node, mine);
+        if ('proven' in r)
+            return r;
+        const t = own(r, g) ?? (() => { const o = grow(g); return 'tree' in o ? o.tree : undefined; })();
+        if (!t)
+            return { proven: false, checked: false, node, goal: g.name, stuck: 'unknown' };
+        if (grownBefore.size >= 4096)
+            grownBefore.clear();
+        grownBefore.set(key, { tree: t });
+        return t;
+    };
+    // A goal with the node's opaque terms read as variables (z$0, z$1, ...), remembered with them for `widen`.
+    const opaqueOf = new WeakMap();
+    let hidden = [];
+    const hide = (g) => {
+        if (!hidden.length)
+            return g;
+        let text = JSON.stringify(g.hyps);
+        const names = {};
+        hidden.forEach((e, i) => { const id = JSON.stringify(e); if (text.includes(id)) {
+            text = text.replaceAll(id, JSON.stringify(v(`z$${i}`)));
+            names[`z$${i}`] = e;
+        } });
+        if (!Object.keys(names).length)
+            return g;
+        const out = { ...g, hyps: JSON.parse(text) };
+        opaqueOf.set(out, names);
+        return out;
+    };
+    // A node's goal grown; then the node keeps only the facts and uses its tree reads (the fewer, the fewer hypotheses its
+    // goal has for the kernel to read at every leaf, and the fewer uses to prove below); then each use's goals.
+    const attempt = ({ opaque, variants: _v, weak: _w, slice: sl, main: given0, carry: made, ...n0 }) => {
+        hidden = opaque ?? [];
+        sliceNow = !!sl;
+        // A goal's own hypotheses: the node's, and those after its facts and uses.
+        const n1 = { ...n0, insts: n0.insts.filter(p => facts[p.fact]) };
+        const given = given0 ?? (made ? timedKind('carry', 0, () => withProducts(() => carry(mainGoal(facts, shapes, n1), n1.insts.length, n1.uses.length, st, performance.now() + 2_000))) : undefined);
+        if (made && !given0) {
+            if (given)
+                st.carried++;
+            else
+                st.uncarried++;
+        }
+        const base = baseHyps(facts, n1).length, mine = (tail) => (i) => i < n1.hyps.length || i >= base + tail;
+        const g = given ? undefined : mainGoal(facts, shapes, n1), key = g ? JSON.stringify(g.hyps) : '', before = g && grownBefore.get(key);
+        let n = n1, main = given, src;
+        if (!g) { /* the tree given */ }
+        else if (before) {
+            n = { ...n1, insts: before.insts?.map(i => n1.insts[i]) ?? n1.insts, uses: before.uses?.map(j => n1.uses[j]) ?? n1.uses };
+            main = before.tree;
+            src = { tree: main, from: mainGoal(facts, shapes, n) };
+        }
+        else {
+            // First the node with only the facts and uses its goal reaches, its goal grown as it is (within two seconds).
+            const h0 = n1.hyps.length, keep = sliceOn() ? reached(g, mine(n1.uses.length)) : undefined;
+            const n2 = keep && { ...n1, insts: n1.insts.filter((_, i) => keep.has(h0 + i)), uses: n1.uses.filter((_, j) => keep.has(base + j)) };
+            if (n2 && (n2.insts.length < n1.insts.length || n2.uses.length < n1.uses.length)) {
+                const g2 = mainGoal(facts, shapes, n2), part = hide(g2);
+                const p = timedKind('main selected', g2.hyps.length, () => withProducts(() => grow(part, new Map(), { nodes: 0, until: performance.now() + Math.min(2_000, later ?? 2_000) })));
+                if (env()?.GDP_CYCLIC_DEBUG)
+                    console.error(`[cyc] ${g.name}: ${g2.hyps.length} of ${g.hyps.length} hyps selected, ${'tree' in p ? `${p.nodes} nodes` : p.stuck}`);
+                const t = 'tree' in p ? own({ tree: p.tree, from: part }, g2) : undefined;
+                if (t && 'tree' in p) {
+                    n = n2;
+                    main = t;
+                    src = { tree: p.tree, from: part };
+                }
+            }
+            // Then the whole node, its goal sliced; it keeps the facts and uses its tree reads.
+            if (!main) {
+                const r = grown(g, n1.name, mine(n1.uses.length));
+                if ('proven' in r)
+                    return r;
+                const used = sliceOn() ? timedKind('used', 0, r.used) : undefined;
+                const trim = used ? { ...n1, insts: n1.insts.filter((_, i) => used.has(h0 + i)), uses: n1.uses.filter((_, j) => used.has(base + j)) } : n1;
+                const g2 = trim.insts.length < n1.insts.length || trim.uses.length < n1.uses.length ? mainGoal(facts, shapes, trim) : g;
+                const t2 = own(r, g2);
+                main = t2 ?? own(r, g) ?? (() => { const o = grow(g); return 'tree' in o ? o.tree : undefined; })();
+                if (!main)
+                    return { proven: false, checked: false, node: n1.name, goal: g.name, stuck: 'unknown' };
+                if (t2)
+                    n = trim;
+                src = { tree: r.tree, from: r.from };
+            }
+            if (grownBefore.size >= 4096)
+                grownBefore.clear();
+            grownBefore.set(key, { tree: main, insts: n.insts.map(p => n1.insts.indexOf(p)), uses: n.uses.map(u => n1.uses.indexOf(u)) });
+        }
+        hidden = [];
+        // Each use's goals; where one isn't proven with the facts the node kept, again with all of them.
+        const usesOf = (n) => {
+            const nb = baseHyps(facts, n).length, mine2 = (i) => i < n.hyps.length || i >= nb, out = [];
+            for (const u of n.uses) {
+                const m = shapes[u.node];
+                if (!m)
+                    return { proven: false, checked: false, node: n.name, goal: `use of node ${u.node}`, stuck: 'no such node' };
+                const premises = [];
+                for (const [i, c] of m.hyps.entries()) {
+                    const t = whole(premiseGoal(facts, n, u, c, i), n.name, mine2);
+                    if ('proven' in t)
+                        return t;
+                    premises.push(t);
+                }
+                const descent = whole(descentGoal(facts, n, u, m), n.name, mine2);
+                if ('proven' in descent)
+                    return descent;
+                out.push({ ...u, premises, descent });
+            }
+            return out;
+        };
+        const uses = usesOf(n);
+        if (!('proven' in uses))
+            return { ...n, uses, main: main };
+        if (n.insts.length === n1.insts.length || !src)
+            return uses;
+        const n3 = { ...n, insts: n1.insts }, main3 = own(src, mainGoal(facts, shapes, n3)), uses3 = main3 ? usesOf(n3) : uses;
+        return main3 && !('proven' in uses3) ? { ...n3, uses: uses3, main: main3 } : uses;
+    };
+    for (const i of order) {
+        let failed;
+        for (const [j, spec] of [specs[i], ...(specs[i].variants ?? [])].entries()) {
+            // (a variant after the first within a few seconds a goal, one second once a node is refuted: a variant the first
+            // wasn't proven by is seldom needed, and seldom proves a node where another is refuted)
+            later = j ? (refuted ? 1_000 : 3_000) : undefined;
+            if (spec.uses.some(u => weak.has(u.node)))
+                continue;
+            const r = attempt(spec);
+            if ('proven' in r) {
+                failed ??= r;
+                if (r.stuck === 'sat')
+                    refuted = true;
+                continue;
             }
-            const descent = grown(descentGoal(facts, n, u, m), n.name);
-            if ('proven' in descent)
-                return descent;
-            uses.push({ ...u, premises, descent });
+            nodes[i] = r;
+            shapes[i] = spec;
+            failed = undefined;
+            if (spec.weak)
+                weak.add(i);
+            break;
         }
-        nodes.push({ ...n, uses, main });
+        if (failed || !nodes[i])
+            return failed ?? { proven: false, checked: false, node: specs[i].name, goal: specs[i].name, stuck: 'unknown' };
     }
-    const proof = { facts, nodes }, why = refuseCyclic(proof);
+    const proof = { facts, nodes }, why = timedKind('check', 0, () => refuseCyclic(proof));
     return { proven: true, checked: why === undefined, proof, ...(why ? { why } : {}) };
 }
+// An instance's nodes, and their variants, grown first on what their goals read.
+const sliced = (specs) => specs.map(sp => ({ ...sp, slice: true, ...(sp.variants ? { variants: sp.variants.map(x => ({ ...x, slice: true })) } : {}) }));
 // The facts of a machine's functions (laws about every key of them), as cyclic facts.
 const factOf = (l) => ({ name: l.name, keys: [...(l.forall ? [l.forall] : []), ...(l.keys ?? [])], holds: l.holds });
-export function recurNodes(r) {
+// `usual`: the usual proofs of the lemmas (the recurrence run as a machine from x = 0) and of the laws between (y from x),
+// translated (`translatedRecur` below), or no nodes with why not.
+export function recurNodes(r, usual, st = tstats()) {
     const f = `${r.name}$`, x = v('x'), y = v('y'), kk = v('k$');
     const facts = [
         { name: `${r.name}(0)`, keys: [], holds: eq(get(f, k(0)), r.zero) },
@@ -81,11 +367,143 @@ export function recurNodes(r) {
             insts: [{ fact: 1, at: [less1(y)] }],
             uses: [...r.between.map((_, j) => ({ node: n + j, subst: { y: less1(y) }, guard: le(add(x, k(1)), y) })), ...lemmaUses(x, yes), ...lemmaUses(y, yes), ...lemmaUses(less1(y), le(k(1), y))],
         });
-    return { facts, specs: withReads(facts, specs) };
+    if (!stepNodesOn())
+        return { facts, specs: sliced(withReads(facts, specs)) };
+    // Each lemma and law twice, as a machine's laws are (GDP_CYCLIC_STEP=0 states the first alone): at x (rank (0, x, 1)),
+    // from f(0) or from the lemma after a step to x, rank (0, x, 0), read at next(x − 1, f(x − 1)) (the usual rule's step
+    // goal) and using every lemma at x − 1; a law between x and y likewise at y (rank (1, y, ·)), after a step to y using
+    // the laws at y − 1 and the lemmas at x and y − 1.
+    const b = r.between.length, step = (e) => substE(r.next, vars({ x: less1(e), prev: get(f, less1(e)) }));
+    const atStep = (l) => substC(l.holds, vars({ x, fx: step(x) }));
+    const lemmaAfter = r.lemmas.map((l) => {
+        const name = `${r.name}: ${l.name}, after a step`, hyps = [le(k(1), x)];
+        return { name, hyps, concl: atStep(l), rank: [k(0), x, k(0)], insts: [], uses: lemmaUses(less1(x), yes), variants: [{ name, hyps, concl: yes, rank: [k(0), x, k(0)], insts: [], uses: [], weak: true }] };
+    });
+    const betweenAfter = r.between.map((l) => {
+        const name = `${r.name}: ${l.name}, after a step`, hyps = [le(add(x, k(1)), y)];
+        return { name, hyps, concl: substC(l.holds, vars({ x, fx: get(f, x), y, fy: step(y) })), rank: [k(1), y, k(0)], insts: [],
+            uses: [...r.between.map((_, j) => ({ node: n + j, subst: { y: less1(y) }, guard: yes })), ...lemmaUses(x, yes), ...lemmaUses(less1(y), yes)],
+            variants: [{ name, hyps, concl: yes, rank: [k(1), y, k(0)], insts: [], uses: [], weak: true }] };
+    });
+    const own = specs.map((sp, i) => {
+        const lemma = i < n, a = { ...sp, rank: [...sp.rank, k(1)], insts: lemma ? sp.insts : [{ fact: 1, at: [less1(y)] }],
+            uses: lemma ? [{ node: n + b + i, subst: {}, guard: le(k(1), x) }] : [{ node: 2 * n + b + (i - n), subst: {}, guard: le(add(x, k(1)), y) }, ...lemmaUses(x, yes), ...lemmaUses(y, yes)],
+            variants: [{ ...sp, rank: [...sp.rank, k(1)] }] };
+        return a;
+    });
+    if (usual)
+        return { facts, ...translatedRecur() };
+    const all = withReads(facts, [...own, ...lemmaAfter, ...betweenAfter]);
+    for (const [i, a] of all.slice(0, n + b).entries()) {
+        const o = shared(facts, a, all[n + b + i].concl);
+        if (o.length)
+            all[i] = { ...a, opaque: o };
+    }
+    return { facts, specs: sliced(all.map(sp => (sp.variants ? { ...sp, variants: withReads(facts, sp.variants, all) } : sp))) };
+    // The usual proofs translated, as a machine's are: each lemma and law between three nodes. At x (at y), as above, its
+    // goal grown: from f(0) or the lemma at the start (x <= 0), or after a step to x (1 <= x). After a step, rank (0, x, 0):
+    // the usual step goal with x as x − 1 and fx as f(x − 1), the lemmas at x − 1 its uses; a law between likewise at y − 1
+    // (rank (1, y, 0)), fx as f(x), its uses the lemmas at x (the usual machine's facts) and at y − 1 and the laws between
+    // at y − 1 (each antecedent x <= y − 1 split first). At the start, rank (0, 0, 0) and (1, 0, 0): the usual start goal,
+    // fx0 as f(0) (a start that reads a function), fx as f(x).
+    function translatedRecur() {
+        const lemmaAfterT = [], betweenAfterT = [], lemmaStart = [], betweenStart = [];
+        const made = [], N = 2 * n + 2 * b;
+        const factIx = (name) => facts.findIndex((q, i) => i >= 2 && q.name === name);
+        // A usual goal's hypotheses: the machine's facts at the instances, its precondition and assumption, the laws assumed.
+        const layout = (u, i) => {
+            const g = obligations(u.m, u.laws, u.proof.instances, i), inst = u.proof.instances[u.laws[i].name] ?? {};
+            const fs = (u.m.facts ?? []).flatMap(q => { const ks = [...(q.forall ? [q.forall] : []), ...(q.keys ?? [])], flat = inst[q.name] ?? []; return ks.length ? Array.from({ length: Math.floor(flat.length / ks.length) }, (_, j) => ({ fact: q, at: flat.slice(j * ks.length, (j + 1) * ks.length) })) : [{ fact: q, at: [] }]; });
+            const np = u.m.pre ? 1 : 0, na = u.m.assume ? 1 : 0;
+            return { g0: g[0], g1: g[1], t0: u.proof.trees[g[0].name], t1: u.proof.trees[g[1].name], fs, np, na, ok: g[0].hyps.length === fs.length + np + 1 && g[1].hyps.length === fs.length + np + na + u.laws.length + 1 };
+        };
+        const last = (g) => g.hyps.at(-1).x;
+        if (n) {
+            const u = usual.lemmas;
+            if (!u || u.laws.map(l => l.name).join('\0') !== r.lemmas.map(l => l.name).join('\0') || u.laws.some(l => l.forall))
+                return { specs: [], why: 'lemmas: no usual proof of these lemmas' };
+            const sigma = vars({ x: less1(x), fx: get(f, less1(x)) }), sigma0 = vars({ fx0: get(f, k(0)) }), ren = renamer({ s: sigma }), ren0 = renamer({ s: sigma0 });
+            for (const [i] of r.lemmas.entries()) {
+                const lay = layout(u, i);
+                if (!lay.ok || !lay.t0 || !lay.t1)
+                    return { specs: [], why: `${r.lemmas[i].name}: a usual goal of another shape` };
+                const used1 = usedHyps(lay.g1, lay.t1), used0 = usedHyps(lay.g0, lay.t0), insts1 = [], insts0 = [];
+                for (const [q, p] of lay.fs.entries()) {
+                    const zeroFact = p.fact.name.startsWith('fx0 is '), ix = zeroFact ? 0 : factIx(p.fact.name);
+                    for (const [used, out, s] of [[used1, insts1, sigma], [used0, insts0, sigma0]]) {
+                        if (!used.has(q))
+                            continue;
+                        if (ix < 0 || (zeroFact && s === sigma))
+                            return { specs: [], why: `${p.fact.name}: no fact of the recurrence's` };
+                        out.push({ fact: ix, at: p.at.map(e => substE(e, s)) });
+                    }
+                }
+                const pre = u.m.pre ? [substC(u.m.pre, sigma)] : [];
+                lemmaAfterT.push({ name: `${r.name}: ${r.lemmas[i].name}, after a step`, hyps: [le(k(1), x), ...pre, ...(u.m.assume ? [substC(u.m.assume, sigma)] : [])], concl: substC(last(lay.g1), sigma), rank: [k(0), x, k(0)],
+                    insts: insts1, uses: lemmaUses(less1(x), yes).filter((_, j) => used1.has(lay.fs.length + lay.np + lay.na + j)) });
+                lemmaStart.push({ name: `${r.name}: ${r.lemmas[i].name}, at the start`, hyps: u.m.pre ? [u.m.pre] : [], concl: substC(last(lay.g0), sigma0), rank: [k(0), k(0), k(0)], insts: insts0, uses: [] });
+                made.push({ g: lay.g1, tree: lay.t1, node: n + b + i, ren }, { g: lay.g0, tree: lay.t0, node: N + i, ren: ren0 });
+            }
+        }
+        if (b) {
+            const u = usual.between, lemmaAt = (name) => r.lemmas.findIndex(l => `${l.name} at x` === name);
+            if (!u || u.laws.slice(n).map(l => l.name).join('\0') !== r.between.map(l => l.name).join('\0') || u.laws.some(l => l.forall))
+                return { specs: [], why: 'between: no usual proof of these laws' };
+            const sigma = vars({ y: less1(y), fy: get(f, less1(y)), fx: get(f, x) }), sigma0 = vars({ fx: get(f, x) }), ren = renamer({ s: sigma }), ren0 = renamer({ s: sigma0 });
+            for (const [i] of r.between.entries()) {
+                const lay = layout(u, n + i);
+                if (!lay.ok || !lay.t0 || !lay.t1)
+                    return { specs: [], why: `${r.between[i].name}: a usual goal of another shape` };
+                const used1 = usedHyps(lay.g1, lay.t1), used0 = usedHyps(lay.g0, lay.t0);
+                const parts = (used, s, after) => {
+                    const insts = [], uses = [];
+                    for (const [q, p] of lay.fs.entries()) {
+                        if (!used.has(q))
+                            continue;
+                        const j = lemmaAt(p.fact.name), ix = factIx(p.fact.name);
+                        if (j >= 0)
+                            uses.push({ node: j, subst: { x }, guard: yes });
+                        else if (ix >= 0)
+                            insts.push({ fact: ix, at: p.at.map(e => substE(e, s)) });
+                        else
+                            return undefined;
+                    }
+                    if (after)
+                        for (const [j] of u.laws.entries())
+                            if (used.has(lay.fs.length + lay.np + lay.na + j))
+                                uses.push(j < n ? { node: j, subst: { x: less1(y) }, guard: yes } : { node: j, subst: { y: less1(y) }, guard: yes });
+                    return { insts, uses };
+                };
+                const p1 = parts(used1, sigma, true), p0 = parts(used0, sigma0, false);
+                if (!p1 || !p0)
+                    return { specs: [], why: `${r.between[i].name}: a fact of no recurrence's` };
+                const pre = u.m.pre ? [substC(u.m.pre, sigma)] : [];
+                betweenAfterT.push({ name: `${r.name}: ${r.between[i].name}, after a step`, hyps: [le(add(x, k(1)), y), ...pre, ...(u.m.assume ? [substC(u.m.assume, sigma)] : [])], concl: substC(last(lay.g1), sigma), rank: [k(1), y, k(0)], ...p1 });
+                betweenStart.push({ name: `${r.name}: ${r.between[i].name}, at the start`, hyps: u.m.pre ? [u.m.pre] : [], concl: substC(last(lay.g0), sigma0), rank: [k(1), k(0), k(0)], ...p0 });
+                made.push({ g: lay.g1, tree: lay.t1, node: 2 * n + b + i, ren, decide: p1.uses.flatMap(us => (us.node >= n && us.node < n + b ? [le(x, less1(y))] : [])) }, { g: lay.g0, tree: lay.t0, node: N + n + i, ren: ren0 });
+            }
+        }
+        const carried = own.map((sp, i) => ({ ...sp, variants: undefined, carry: true, uses: [...sp.uses, i < n ? { node: N + i, subst: {}, guard: le(x, k(0)) } : { node: N + i, subst: {}, guard: le(y, x) }] }));
+        const rest = [...lemmaAfterT, ...betweenAfterT, ...lemmaStart, ...betweenStart], all = [...withReads(facts, carried, [...carried, ...rest]), ...rest];
+        for (const [i, a] of all.slice(0, n + b).entries()) {
+            const o = [...new Set([...shared(facts, a, all[n + b + i].concl), ...shared(facts, a, all[N + i].concl)].map(e => JSON.stringify(e)))].map(e => JSON.parse(e));
+            if (o.length)
+                all[i] = { ...a, opaque: o };
+        }
+        const until = performance.now() + 10_000;
+        for (const m of made) {
+            const whole = mainGoal(facts, all, all[m.node]);
+            const tree = timedKind('translate', 0, () => withProducts(() => decide(whole, m.decide ?? [], wp => translate(m.g, whole, m.tree, m.ren, st, until, new Map(), wp), st, until)));
+            if (!tree)
+                return { specs: [], why: `${all[m.node].name}: not translated` };
+            all[m.node] = { ...all[m.node], main: tree };
+        }
+        return { specs: sliced(all) };
+    }
 }
 // Function facts at the keys a node's goal reads them at: each fact about every key of a function read f[k] (the key
 // alone) at each key f is read at, twice over (a fact's own reads give more keys).
-function withReads(facts, specs) {
+function withReads(facts, specs, nodes = specs) {
     const simple = facts.flatMap((f, i) => {
         if (f.keys.length !== 1)
             return [];
@@ -104,7 +522,7 @@ function withReads(facts, specs) {
     return specs.map(n => {
         const insts = [...n.insts], seen = new Set(insts.map(p => JSON.stringify(p)));
         for (let round = 0; round < 2; round++) {
-            const goal = [n.hyps, n.concl, insts.map(p => substC(facts[p.fact].holds, vars(Object.fromEntries(facts[p.fact].keys.map((key, i) => [key, p.at[i]]))))), n.uses.map(u => substC(specs[u.node].concl, vars(u.subst)))];
+            const goal = [n.hyps, n.concl, insts.map(p => substC(facts[p.fact].holds, vars(Object.fromEntries(facts[p.fact].keys.map((key, i) => [key, p.at[i]]))))), n.uses.map(u => substC(nodes[u.node].concl, vars(u.subst)))];
             for (const s of simple)
                 for (const key of readsIn(goal, s.map)) {
                     const p = { fact: s.fact, at: [key] }, id = JSON.stringify(p);
@@ -122,7 +540,9 @@ function withReads(facts, specs) {
 // read from a map of the state (a table of nodes: a node's fold at its child), whose cells a run's maps put at keys
 // the prover would have to prove equal through products (`machineNodes` proves those laws far slower than the usual
 // rule, past its budget: research/cyclic/probe.ts).
-export const cyclicMachine = (m, laws = []) => {
+export const cyclicMachine = (m, laws = []) => uncoveredWhy(m, laws) === undefined;
+// Why a machine's laws are no instance's (undefined where they are one).
+export const uncoveredWhy = (m, laws = []) => {
     const maps = Object.keys(m.maps ?? {});
     const nested = (t) => { let found = false; const walk = (x, inKey) => { if (found || !x || typeof x !== 'object')
         return; const o = x; if (o.op === 'get' && inKey && maps.includes(o.map)) {
@@ -133,7 +553,7 @@ export const cyclicMachine = (m, laws = []) => {
         return;
     } for (const val of Object.values(o))
         walk(val, inKey); }; walk(t, false); return found; };
-    return !m.history && !Object.values(m.step.flags ?? {}).some(c => c.op === 'all') && !laws.some(l => nested(l.holds));
+    return m.history ? 'a history' : Object.values(m.step.flags ?? {}).some(c => c.op === 'all') ? 'a flag at every key' : laws.some(l => nested(l.holds)) ? 'a law reading a map at a key read from a map' : undefined;
 };
 // The run as maps over time: names at time u read as their maps there.
 function trace(m) {
@@ -166,7 +586,8 @@ const flagsOf = (m) => {
         out[f] = substC(c, { vars: {}, maps: {}, flags: out });
     return out;
 };
-export function machineNodes(m, laws, instances) {
+// `lawsMade`: the laws' nodes are made already (their trees not translated again).
+export function machineNodes(m, laws, instances, usual, st = tstats()) {
     const { at } = trace(m), flags = flagsOf(m), inline = (t) => substC(t, { vars: {}, maps: {}, flags });
     const t = v('t$'), T = v('T$'), u = v('u$'), key = v('k$');
     const inlineE = (e) => substE(e, { vars: {}, maps: {}, flags });
@@ -197,6 +618,14 @@ export function machineNodes(m, laws, instances) {
         { name: `${m.name}: params are naturals`, keys: [], holds: and(yes, ...m.params.map(x => le(k(0), v(x)))) },
     ];
     const fi = (name) => facts.findIndex(f => f.name === name);
+    // The run's facts at time t: the start and the step (Bridge.lean's cycCanon has them so).
+    const run = (when) => [{ fact: 0, at: [when] }, { fact: 1, at: [when] }];
+    const nexts = new Map(state.flatMap(s => { const e = m.step.state?.[s]; return e && !(e.op === 'var' && e.name === s) && afterOn() ? [[JSON.stringify(inlineE(e)), get(`${s}@`, t)]] : []; }));
+    const afterStep = (e) => {
+        const walk = (x) => (Array.isArray(x) ? x.map(walk) : !x || typeof x !== 'object' ? x
+            : nexts.get(JSON.stringify(x)) ?? Object.fromEntries(Object.entries(x).map(([key, val]) => [key, walk(val)])));
+        return nexts.size ? walk(e) : e;
+    };
     const keysOf = (l) => [...(l.forall ? [l.forall] : []), ...(l.keys ?? [])];
     // A map read at the node's time t at key e: that map's start, step and natural facts at (t, e).
     const mapInsts = (c) => {
@@ -221,12 +650,86 @@ export function machineNodes(m, laws, instances) {
         walk(c);
         return out;
     };
+    // Each law twice (GDP_CYCLIC_STEP=0 states the first alone, its goal the whole step): at time t, rank (t, 1), and after
+    // a step from t − 1, rank (t, 0), the law read at the state the step gives (the usual rule's step goal, over the run's
+    // cells at t − 1). The law at t is the start's at t = 0, and after t's step else: the step's equations carry the law
+    // after the step to the state at t. The law after the step uses every law at t − 1, at the keys the machine's proof
+    // assumes them at, with the functions' facts at the keys it names, as the usual rule's goal does.
+    function stepNodes(single) {
+        const L = laws.length, pre = at(less1(t)), one = le(k(1), t);
+        const fresh = Object.fromEntries(laws.flatMap(x => (x.forall ? [[`${x.forall}#`, v(x.forall)]] : [])));
+        const over = (e, frame) => substE(substE(e, vars(fresh)), frame);
+        // The state the step gives, over the frame before it.
+        const upd = { flags: {}, vars: Object.fromEntries(state.map(st => [st, inlineE(m.step.state?.[st] ?? v(st))])), maps: Object.fromEntries(mapNames.map(map => [map, (kk) => {
+                    const w = m.step.maps?.[map];
+                    // (a write's reads at its key read at the key read instead, as the map's step fact has them: the same cells there)
+                    return !w ? get(map, kk) : 'each' in w ? substE(inlineE(w.value), vars({ [w.each]: kk })) : { op: 'if', c: eq(kk, inlineE(w.key)), then: readsAt(inlineE(w.value), inlineE(w.key), kk), else: get(map, kk) };
+                }])) };
+        const omegaHyp = mapNames.length ? [{ op: '<', a: T, b: omega }] : [];
+        const fnInsts = (inst, frame) => (m.facts ?? []).flatMap(f => {
+            const ks = keysOf(f), flat = inst[f.name] ?? [], fact = fi(f.name);
+            if (!ks.length)
+                return [{ fact, at: [] }];
+            return Array.from({ length: Math.floor(flat.length / ks.length) }, (_, i) => ({ fact, at: flat.slice(i * ks.length, (i + 1) * ks.length).map(e => over(e, frame)) }));
+        });
+        const naturals = (when) => state.map(st => ({ fact: fi(`${m.name}: ${st} is a natural`), at: [when] }));
+        const params = { fact: fi(`${m.name}: params are naturals`), at: [] };
+        // The law at t first with the start's and the step's facts alone, then with the functions' facts at the keys the
+        // machine's proof names (read at t: the start's case), then as one node whose goal is the whole step (its uses the
+        // laws at t − 1), for a law after the step that isn't proven (that node then holds outright, a weak variant).
+        const nowNodes = laws.map((l, i) => {
+            const concl = substC(l.holds, at(t)), inst = instances[l.name] ?? {};
+            const hyps = [...(m.pre ? [m.pre] : []), le(t, T), ...omegaHyp], uses = [{ node: L + i, subst: {}, guard: one }];
+            const lean = [...run(t), ...mapInsts(concl), ...naturals(t), params];
+            const fns = fnInsts(inst, at(t));
+            return { name: `${m.name}: ${l.name}`, hyps, concl, rank: [t, k(1)], insts: lean, uses,
+                variants: [...(fns.length ? [{ name: `${m.name}: ${l.name}`, hyps, concl, rank: [t, k(1)], insts: [...lean, ...fns], uses }] : []), { ...single[i], rank: [t, k(1)] }] };
+        });
+        const stepNodes = laws.map((l) => {
+            const inst = instances[l.name] ?? {}, concl = substC(substC(substC(l.holds, vars(fresh)), upd), pre);
+            const uses = laws.flatMap((l2, j) => {
+                const ks = keysOf(l2);
+                if (!ks.length)
+                    return [{ node: j, subst: { 't$': less1(t) }, guard: one }];
+                const flat = inst[l2.name] ?? [];
+                return Array.from({ length: Math.floor(flat.length / ks.length) }, (_, q) => ({ node: j, subst: { 't$': less1(t), ...Object.fromEntries(ks.map((kn, r) => [kn, over(flat[q * ks.length + r], pre)])) }, guard: one }));
+            });
+            // (the request the step assumes a hypothesis of its own, which the law at t has from the step's fact: the step's
+            // equations are no hypothesis of this goal)
+            const hyps = [...(m.pre ? [m.pre] : []), one, le(t, T), ...omegaHyp, ...(m.assume ? [now(inline(m.assume), less1(t))] : [])], name = `${m.name}: ${l.name}, after a step`;
+            return { name, hyps, concl, rank: [t, k(0)], insts: [...fnInsts(inst, pre), ...naturals(less1(t)), params], uses,
+                variants: [{ name, hyps, concl: yes, rank: [t, k(0)], insts: [], uses: [], weak: true }] };
+        });
+        // The law at t reads the law after the step and the step's facts at t: the terms they share (the state the step
+        // gives) are opaque to its search, so that it carries the one to the other without splitting the step's cases.
+        for (const [i, a] of nowNodes.entries()) {
+            const o = shared(facts, a, stepNodes[i].concl);
+            if (o.length)
+                a.opaque = o;
+        }
+        return [...nowNodes, ...stepNodes];
+    }
     const specs = laws.map(l => {
         const inst = instances[l.name] ?? {};
         // Terms over the frame before the step (the machine's proof proves a law about every key at a fresh key k#: here
         // the node's own k).
         const fresh = Object.fromEntries(laws.flatMap(x => (x.forall ? [[`${x.forall}#`, v(x.forall)]] : [])));
         const pre = at(less1(t)), before = (e) => substE(substE(e, vars(fresh)), pre);
+        // A function's fact also at its keys with the terms the step gives a state variable (the usual proof reads the state
+        // after the step so) as that variable's cell at t, where it then reads the function where the law at t does: at the
+        // key its own reads are at, not one the prover would have to prove equal to it.
+        const fnReads = (x) => { const out = []; const walk = (y) => { if (y && typeof y === 'object') {
+            const o = y;
+            if (o.op === 'get' && !o.map.endsWith('@'))
+                out.push(JSON.stringify(o));
+            Object.values(o).forEach(walk);
+        } }; walk(x); return out; };
+        const concl = substC(l.holds, at(t)), reads = new Set(fnReads(concl));
+        const after = (e) => substE(afterStep(substE(e, vars(fresh))), pre);
+        const both = (tuple, make, read) => {
+            const a = make(tuple.map(before)), b = make(tuple.map(after));
+            return JSON.stringify(a) === JSON.stringify(b) || !fnReads(read(b)).some(c => reads.has(c)) ? [a] : [a, b];
+        };
         // The laws at the step before, at the keys the machine's proof assumes them at.
         const uses = laws.flatMap((l2, j) => {
             const ks = keysOf(l2);
@@ -237,25 +740,431 @@ export function machineNodes(m, laws, instances) {
         });
         // The functions' facts at the keys the proof names, over the frame before the step (at t = 0, the start's).
         const factInsts = (m.facts ?? []).flatMap(f => {
-            const ks = keysOf(f), flat = inst[f.name] ?? [];
+            const ks = keysOf(f), flat = inst[f.name] ?? [], fact = fi(f.name);
             if (!ks.length)
-                return [{ fact: fi(f.name), at: [] }];
-            return Array.from({ length: Math.floor(flat.length / ks.length) }, (_, i) => ({ fact: fi(f.name), at: flat.slice(i * ks.length, (i + 1) * ks.length).map(before) }));
+                return [{ fact, at: [] }];
+            return Array.from({ length: Math.floor(flat.length / ks.length) }, (_, i) => both(flat.slice(i * ks.length, (i + 1) * ks.length), at => ({ fact, at }), p => substC(f.holds, vars(Object.fromEntries(ks.map((kn, q) => [kn, p.at[q]])))))).flat();
         });
-        const concl = substC(l.holds, at(t));
         const useConcls = uses.map(us => substC(substC(laws[us.node].holds, at(t)), vars(us.subst)));
         const base = mapInsts([concl, useConcls]);
         return {
             name: `${m.name}: ${l.name}`, hyps: [...(m.pre ? [m.pre] : []), le(t, T), ...(mapNames.length ? [{ op: '<', a: T, b: omega }] : [])], concl, rank: [t],
-            insts: [{ fact: 0, at: [t] }, { fact: 1, at: [t] }, ...factInsts, ...base, ...state.map(st => ({ fact: fi(`${m.name}: ${st} is a natural`), at: [t] })), { fact: fi(`${m.name}: params are naturals`), at: [] }], uses,
+            insts: [...run(t), ...factInsts, ...base, ...state.map(st => ({ fact: fi(`${m.name}: ${st} is a natural`), at: [t] })), { fact: fi(`${m.name}: params are naturals`), at: [] }], uses,
         };
     });
-    return { facts, specs };
+    if (usual)
+        return { facts, ...translatedNodes() };
+    return { facts, specs: sliced(stepNodesOn() ? stepNodes(specs) : specs) };
+    // The usual proof translated (core/translate.ts): each law three nodes. At t, rank (t, 1), as above (Bridge.lean's
+    // cycMOk reads it), its goal grown: it carries the law at the start or after t's step to the cells at t through the
+    // start's and the step's equations. After a step from t − 1, rank (t, 0): the usual step goal over the run's cells at
+    // t − 1 (each hypothesis of it read so: the functions' facts at the keys the usual proof names, the precondition, the
+    // request's assumption, every law at t − 1 at those keys, each a use guarded by 0 <= 0, its descent from 1 <= t), its
+    // tree the usual one's renamed. At the start, rank (0, 0): the usual start goal (the law at the start's values), the
+    // law's fresh key k# its own k, its tree the usual one's. Only the facts and uses the usual tree reads are kept.
+    function translatedNodes() {
+        const L = laws.length, pre = at(less1(t)), one = le(k(1), t), omegaHyp = mapNames.length ? [{ op: '<', a: T, b: omega }] : [];
+        const fresh = Object.fromEntries(laws.flatMap(x => (x.forall ? [[`${x.forall}#`, v(x.forall)]] : [])));
+        const sigma = { vars: { ...pre.vars, ...fresh }, maps: pre.maps, flags: {} };
+        const ren = renamer({ s: sigma, cells: Object.fromEntries([...mapNames, ...(m.inputMaps ?? [])].map(map => [map, { to: `${map}@`, at: less1(t) }])) }), ren0 = renamer({ s: vars(fresh) });
+        const fnInsts = (inst, frame) => (m.facts ?? []).flatMap(f => {
+            const ks = keysOf(f), flat = inst[f.name] ?? [], fact = fi(f.name);
+            if (!ks.length)
+                return [{ fact, at: [] }];
+            return Array.from({ length: Math.floor(flat.length / ks.length) }, (_, i) => ({ fact, at: flat.slice(i * ks.length, (i + 1) * ks.length).map(e => substE(substE(e, vars(fresh)), frame)) }));
+        });
+        const goals = new Map(obligations(m, laws, instances).map(g => [g.name, g]));
+        // The state the step gives over the frame before it, a write's reads at its key read at the key read instead (as the
+        // map's step fact has them): the usual step goal's conclusion but for those reads, which the translation reads at
+        // the key read where the usual path has the two keys equal (two cells over time then split apart: `close`).
+        const upd = { flags: {}, vars: Object.fromEntries(state.map(st2 => [st2, inlineE(m.step.state?.[st2] ?? v(st2))])), maps: Object.fromEntries(mapNames.map(map => [map, (kk) => {
+                    const w = m.step.maps?.[map];
+                    return !w ? get(map, kk) : 'each' in w ? substE(inlineE(w.value), vars({ [w.each]: kk })) : { op: 'if', c: eq(kk, inlineE(w.key)), then: readsAt(inlineE(w.value), inlineE(w.key), kk), else: get(map, kk) };
+                }])) };
+        // A step law's condition with its primed names read as given, its flags inlined (over the frame before the step).
+        const primedOf = (c, s0) => substC(c, { ...s0, flags });
+        const nows = [], afters = [], starts = [], made = [];
+        // A write's key and the keys the usual conclusion reads its map at (each a condition if(K = W, ...)).
+        const wkeys = new Set(mapNames.flatMap(map => { const w = m.step.maps?.[map]; return w && !('each' in w) ? [JSON.stringify(inlineE(w.key))] : []; }));
+        const readsOf = (c) => {
+            const out = [], seen = new Set();
+            const walk = (x) => {
+                if (!x || typeof x !== 'object')
+                    return;
+                const o = x;
+                if (o.op === 'if' && o.c.op === '=' && wkeys.has(JSON.stringify(o.c.b))) {
+                    const id = JSON.stringify([o.c.a, o.c.b]);
+                    if (!seen.has(id)) {
+                        seen.add(id);
+                        out.push({ k: o.c.a, w: o.c.b });
+                    }
+                }
+                for (const val of Object.values(o))
+                    walk(val);
+            };
+            walk(c);
+            return out;
+        };
+        for (const [i, l] of laws.entries()) {
+            const g0 = goals.get(`${l.name} @start`), g1 = goals.get(`${l.name} @step`), t0 = g0 && usual.trees[g0.name], t1 = g1 && usual.trees[g1.name];
+            if (!g0 || !g1 || !t0 || !t1)
+                return { specs: [], why: `${l.name}: no usual tree` };
+            const inst = instances[l.name] ?? {}, nf = assumed(m.facts ?? [], inst).length, np = m.pre ? 1 : 0, na = m.assume ? 1 : 0;
+            const uses = laws.flatMap((l2, j) => {
+                const ks = keysOf(l2);
+                if (!ks.length)
+                    return [{ node: j, subst: { 't$': less1(t) }, guard: yes }];
+                const flat = inst[l2.name] ?? [];
+                return Array.from({ length: Math.floor(flat.length / ks.length) }, (_, q) => ({ node: j, subst: { 't$': less1(t), ...Object.fromEntries(ks.map((kn, r) => [kn, substE(flat[q * ks.length + r], sigma)])) }, guard: yes }));
+            });
+            const fn1 = fnInsts(inst, pre), fn0 = fnInsts(inst, vars({}));
+            if (g1.hyps.length !== nf + np + na + uses.length + 1 || g0.hyps.length !== nf + np + 1 || fn1.length !== nf)
+                return { specs: [], why: `${l.name}: a usual goal of another shape` };
+            const used1 = usedHyps(g1, t1), used0 = usedHyps(g0, t0), last = (g) => g.hyps.at(-1).x;
+            const concl = substC(l.holds, at(t));
+            afters.push({ name: `${m.name}: ${l.name}, after a step`, hyps: [...(m.pre ? [m.pre] : []), one, le(t, T), ...omegaHyp, ...(m.assume ? [now(inline(m.assume), less1(t))] : [])],
+                concl: substC(substC(substC(l.holds, vars(fresh)), upd), pre), rank: [t, k(0)], insts: [...fn1.filter((_, q) => used1.has(q))], uses: uses.filter((_, j) => used1.has(nf + np + na + j)) });
+            starts.push({ name: `${m.name}: ${l.name}, at the start`, hyps: m.pre ? [m.pre] : [], concl: substC(last(g0), vars(fresh)), rank: [k(0), k(0)], insts: [...fn0.filter((_, q) => used0.has(q))], uses: [] });
+            nows.push({ name: `${m.name}: ${l.name}`, hyps: [...(m.pre ? [m.pre] : []), le(t, T), ...omegaHyp], concl, rank: [t, k(1)], insts: [...run(t), ...mapInsts(concl)],
+                uses: [{ node: L + i, subst: {}, guard: one }, { node: 2 * L + i, subst: {}, guard: le(t, k(0)) }], carry: true });
+            made.push({ g: g1, tree: t1, node: L + i, ren, decide: [one], reads: readsOf(last(g1)) }, { g: g0, tree: t0, node: 2 * L + i, ren: ren0 });
+        }
+        // One-step step laws (`usual.steps`), each two nodes after the laws' (core/cyclic.ts's header has their shape): after a
+        // step from t − 1, rank (t, 0), the usual step law's goal over the run's cells at t − 1 (its `when` and the request's
+        // assumption hypotheses, the laws at t − 1 at its keys uses), the state after it the step's terms; and the step law
+        // itself, rank (t, 2), over the cells at t − 1 and at t (a primed name at t), carried from the first by the step's
+        // facts at t, its hypotheses the precondition, 1 <= t <= T, T < Ω and `when` at t − 1.
+        const stepSpecs = [];
+        for (const [q, u] of (usual.steps ?? []).entries()) {
+            const { sl, inst, goal: g, tree } = u, whens = sl.when === undefined ? [] : Array.isArray(sl.when) ? sl.when : [sl.when], K = sl.steps ?? 1;
+            // (k steps: a machine with no map, the state after each step a cell at its time; one step: any the instances cover)
+            if (K > 1 && (mapNames.length || m.inputMaps?.length))
+                return { specs: [], why: `${sl.name}: steps over a map` };
+            // The times the steps start from (t − k, ..., t − 1), and the frames: the state before step j its cells at t − k + j − 1
+            // (n~j the state after step j, at t − k + j), its request read there (i@j).
+            const time = (back) => (back === 0 ? t : { op: 'sub', a: t, b: k(back) });
+            const frame = { vars: { ...at(time(K)).vars, ...Object.fromEntries(Array.from({ length: K }, (_, j) => j + 1).flatMap(j => [
+                        ...(j >= 2 ? m.inputs.map(i => [`${i}@${j}`, get(`${i}@`, time(K - j + 1))]) : []),
+                        ...(j < K ? state.map(n => [`${n}~${j}`, get(`${n}@`, time(K - j))]) : []),
+                    ])) }, maps: pre.maps, flags: {} };
+            const sig = K === 1 ? sigma : frame, renK = K === 1 ? ren : renamer({ s: frame });
+            // (the usual goal's hypotheses: the precondition, the facts at the instances, then each step's laws, assumption and
+            // `when`, and after each step but the last its state's equations)
+            const nf = assumed(m.facts ?? [], inst).length, np = m.pre ? 1 : 0, na = m.assume ? 1 : 0, nl = assumed(laws, inst).length;
+            const lawsAt = (back) => laws.flatMap((l2, j) => {
+                const ks = keysOf(l2), tb = time(back), ab = at(tb);
+                if (!ks.length)
+                    return [{ node: j, subst: { 't$': tb }, guard: yes }];
+                const flat = inst[l2.name] ?? [];
+                return Array.from({ length: Math.floor(flat.length / ks.length) }, (_, r) => ({ node: j, subst: { 't$': tb, ...Object.fromEntries(ks.map((kn, c) => [kn, substE(flat[r * ks.length + c], ab)])) }, guard: yes }));
+            });
+            const perStep = Array.from({ length: K }, (_, j) => lawsAt(K - j)), fn1 = fnInsts(inst, sig);
+            // Each step's block: its laws, its assumption, its when, then (but after the last) its state's equations.
+            const blocks = [];
+            let pos = np + nf;
+            for (let j = 0; j < K; j++) {
+                blocks.push(pos);
+                pos += nl + na + (whens[j] ? 1 : 0) + (j < K - 1 ? state.length : 0);
+            }
+            if (g.hyps.length !== pos + 1 || fn1.length !== nf || perStep.some(us => us.length !== nl))
+                return { specs: [], why: `${sl.name}: a usual goal of another shape` };
+            const used = usedHyps(g, tree), last = g.hyps.at(-1).x;
+            const assumes = Array.from({ length: K }, (_, j) => (m.assume ? [now(inline(m.assume), time(K - j))] : [])).flat();
+            const when = whens.map((w, j) => now(inline(w), time(K - j)));
+            const bounds = [...(m.pre ? [m.pre] : []), le(k(K), t), le(t, T), ...omegaHyp];
+            const after = K === 1 ? substC(primedOf(sl.then, { vars: Object.fromEntries(state.map(st2 => [`${st2}'`, inlineE(m.step.state?.[st2] ?? v(st2))])), maps: Object.fromEntries(mapNames.map(map => [`${map}'`, upd.maps[map]])), flags: {} }), pre) : substC(last, frame);
+            const later = Object.fromEntries(Array.from({ length: K - 1 }, (_, j) => j + 2).flatMap(j => m.inputs.map(i => [`${i}@${j}`, get(`${i}@`, time(K - j + 1))])));
+            const cells = substC(primedOf(sl.then, { vars: { ...later, ...Object.fromEntries(state.map(st2 => [`${st2}'`, get(`${st2}@`, t)])) }, maps: Object.fromEntries(mapNames.map(map => [`${map}'`, (kk) => get(`${map}@`, pair(t, kk))])), flags: {} }), at(time(K)));
+            const a = 3 * L + 2 * q, steps = Array.from({ length: K - 1 }, (_, j) => ({ fact: 1, at: [time(K - j - 1)] }));
+            // (the state after each step but the last its equations, hypotheses here as in the usual goal: the step's facts at
+            // those times give them where the step law is, `steps` below)
+            const eqs = blocks.slice(0, K - 1).flatMap((b0, j) => g.hyps.slice(b0 + nl + na + (whens[j] ? 1 : 0), b0 + nl + na + (whens[j] ? 1 : 0) + state.length).map(h => substC(h, frame)));
+            stepSpecs.push({ name: `${m.name}: ${sl.name}, after ${K === 1 ? 'a step' : `${K} steps`}`, hyps: [...bounds, ...assumes, ...when, ...eqs], concl: after, rank: [t, k(0)],
+                insts: fn1.filter((_, r) => used.has(np + r)), uses: perStep.flatMap((us, j) => us.filter((_, r) => used.has(blocks[j] + r))) });
+            stepSpecs.push({ name: `${m.name}: ${sl.name}`, hyps: [...bounds, ...when], concl: cells, rank: [t, k(2)],
+                insts: [...run(t), ...steps, ...mapInsts(cells)], uses: [{ node: a, subst: {}, guard: yes }], carry: true });
+            // (each time decided at least the steps before it first: t ∸ j is then t − j)
+            made.push({ g, tree, node: a, ren: renK, decide: Array.from({ length: K }, (_, j) => le(k(j + 1), t)), reads: K === 1 ? readsOf(last) : [] });
+        }
+        const all = [...nows, ...afters, ...starts, ...stepSpecs];
+        for (const [i, a] of nows.entries()) {
+            const o = [...new Set([...shared(facts, a, afters[i].concl), ...shared(facts, a, starts[i].concl)].map(e => JSON.stringify(e)))].map(e => JSON.parse(e));
+            if (o.length)
+                a.opaque = o;
+        }
+        // (a translation is bounded by a minute: a step law over 32 steps has a goal of 32 frames at every leaf)
+        const until = performance.now() + 60_000;
+        for (const x of made) {
+            if (usual.lawsMade && x.node < 3 * L)
+                continue;
+            // (after a step, 1 <= t decided first: t ∸ 1 is then t − 1, and a cell read at a key over the cells at t − 1 has a
+            // linear form)
+            const whole = mainGoal(facts, all, all[x.node]);
+            const tree = timedKind('translate', 0, () => withProducts(() => decide(whole, x.decide ?? [], wp => readsFirst(whole, x.reads ?? [], x.ren, (p, swaps) => translate(x.g, whole, x.tree, x.ren, st, until, new Map(), p, swaps), st, until, wp), st, until)));
+            if (!tree)
+                return { specs: [], why: `${all[x.node].name}: not translated` };
+            all[x.node] = { ...all[x.node], main: tree };
+        }
+        return { specs: sliced(all) };
+    }
+}
+// The terms (not a read, a variable or a constant) of a conclusion that a node's facts read too, largest first; none
+// inside a product (a product of a term's linear form is no linear form).
+function shared(facts, a, concl) {
+    const inst = instHyps(facts, a.insts), theirs = JSON.stringify(inst), seen = new Set(), out = [], factors = new Set();
+    const inProducts = (x, under = false) => {
+        if (!x || typeof x !== 'object')
+            return;
+        if (Array.isArray(x)) {
+            x.forEach(y => inProducts(y, under));
+            return;
+        }
+        const o = x;
+        if (under)
+            factors.add(JSON.stringify(o));
+        for (const val of Object.values(o))
+            inProducts(val, under || o.op === 'prod');
+    };
+    inProducts([concl, inst]);
+    const walk = (x) => {
+        if (!x || typeof x !== 'object')
+            return;
+        if (Array.isArray(x)) {
+            x.forEach(walk);
+            return;
+        }
+        const o = x, id = JSON.stringify(o);
+        if (['if', 'add', 'sub', 'min', 'max', 'mul', 'prod'].includes(o.op) && theirs.includes(id) && !factors.has(id)) {
+            if (!seen.has(id)) {
+                seen.add(id);
+                out.push(o);
+            }
+            return;
+        }
+        for (const val of Object.values(o))
+            walk(val);
+    };
+    walk(concl);
+    return out.sort((x, y) => JSON.stringify(y).length - JSON.stringify(x).length);
+}
+// --- step laws and k-step laws over the run -----------------------------------------------------------------------
+// A k-step law (or a step law, k = 1) as a node over the machine's run (BridgeRules.lean's cycKOk, cyc_kstep_sound
+// carries it to the law): the run's last k steps up to time t, each time one step back from the next (t − 1, t − 1 − 1,
+// …), as a step's fact reads the time before it, so the cells a step gives are those the next one reads. The first state
+// at t − k, the j-th request at t − (k − j), the state after the last at t.
+export const tBack = (n) => (n === 0 ? v('t$') : less1(tBack(n - 1)));
+// The same times read t − n at once (BridgeRules.lean's tSub; core/translate.ts's step laws over several steps).
+export const tSub = (n) => (n === 0 ? v('t$') : { op: 'sub', a: v('t$'), b: k(n) });
+// `then` over the run (BridgeRules.lean's kσ and kRd): the primed names at t, each later request's inputs (input@j) and
+// the maps it carries (map@j) at its time, the plain names at t − k.
+export function kStepAt(m, k, time = tBack) {
+    const { at } = trace(m), first = at(time(k)), last = at(time(0));
+    const vars = { ...first.vars }, maps = { ...first.maps };
+    for (const x of Object.keys(m.state))
+        vars[`${x}'`] = last.vars[x];
+    for (const map of Object.keys(m.maps ?? {}))
+        maps[`${map}'`] = last.maps[map];
+    for (let j = 1; j < k; j++) {
+        const a = at(time(k - j));
+        for (const i of m.inputs)
+            vars[`${i}@${j + 1}`] = a.vars[i];
+        for (const c of m.inputMaps ?? [])
+            maps[`${c}@${j + 1}`] = a.maps[c];
+    }
+    return { vars, maps, flags: {} };
+}
+// A k-step law's `when`s, one per step (none: 0 <= 0), its flags inlined, as Lean's SKStep has them.
+export const kWhens = (m, sl) => {
+    const ws = sl.when === undefined ? [] : Array.isArray(sl.when) ? sl.when : [sl.when], flags = flagsOf(m);
+    return Array.from({ length: sl.steps ?? 1 }, (_, j) => (ws[j] ? substC(ws[j], { vars: {}, maps: {}, flags }) : yes));
+};
+// The nodes of the step laws, after the laws' (`laws` the machine's, `lawNodes` their nodes, the first L at time t, as
+// machineNodes makes them). Each node: the precondition, k <= t <= T, T < Ω and each step's `when` at its time;
+// the run's facts at the times it reads (each step's, each map cell's step back from where it is read, the functions'
+// facts at the keys the usual proof names), every law at each state but the last (at the keys it names), and `then`.
+export function stepLawNodes(m, laws, steps, facts, lawNodes, time = tBack) {
+    const rank = lawNodes[0]?.rank.length ?? 2;
+    const { at } = trace(m), flags = flagsOf(m), inline = (c) => substC(c, { vars: {}, maps: {}, flags });
+    const t = v('t$'), T = v('T$'), mapNames = Object.keys(m.maps ?? {}), traced = [...mapNames, ...(m.inputMaps ?? [])], state = Object.keys(m.state);
+    const fi = (name) => facts.findIndex(f => f.name === name);
+    const keysOf = (l) => [...(l.forall ? [l.forall] : []), ...(l.keys ?? [])];
+    const tuples = (inst, l) => { const ks = keysOf(l), flat = inst[l.name] ?? []; return ks.length ? Array.from({ length: Math.floor(flat.length / ks.length) }, (_, i) => flat.slice(i * ks.length, (i + 1) * ks.length)) : [[]]; };
+    const specs = steps.map(({ law: sl, instances: inst }) => {
+        const K = sl.steps ?? 1, times = Array.from({ length: K + 1 }, (_, j) => time(K - j));
+        const hyps = [...(m.pre ? [m.pre] : []), le(k(K), t), le(t, T), ...(traced.length ? [{ op: '<', a: T, b: omega }] : []),
+            ...kWhens(m, sl).map((w, j) => substC(w, at(times[j])))];
+        const concl = substC(inline(sl.then), kStepAt(m, K, time));
+        // Every law at each state but the last, at the keys the proof names there.
+        const uses = times.slice(0, K).flatMap(u => laws.flatMap((l, i) => tuples(inst, l).map(ts => ({
+            node: i, subst: { 't$': u, ...Object.fromEntries(keysOf(l).map((kn, q) => [kn, substE(ts[q], at(u))])) }, guard: yes
+        }))));
+        const insts = [
+            ...times.slice(1).map(u => ({ fact: fi(`${m.name}: a step`), at: [u] })),
+            ...times.flatMap(u => state.map(st => ({ fact: fi(`${m.name}: ${st} is a natural`), at: [u] }))),
+            { fact: fi(`${m.name}: params are naturals`), at: [] },
+            ...(m.facts ?? []).flatMap(f => tuples(inst, f).map(ts => ({ fact: fi(f.name), at: ts.map(e => substE(e, at(times[0]))) }))),
+        ];
+        // Each map cell the node reads at a time after the first: that map's step there, back to the time before, and so on.
+        const seen = new Set(), ix = new Map(times.map((u, j) => [JSON.stringify(u), j]));
+        const cellFacts = (x) => {
+            if (!x || typeof x !== 'object')
+                return;
+            if (Array.isArray(x)) {
+                x.forEach(cellFacts);
+                return;
+            }
+            const o = x;
+            if (o.op === 'get' && typeof o.map === 'string' && o.map.endsWith('@') && traced.includes(o.map.slice(0, -1))) {
+                const key = o.key;
+                if (key.op === 'add' && key.b.op === 'prod' && JSON.stringify(key.b.b) === JSON.stringify(omega)) {
+                    const j = ix.get(JSON.stringify(key.a)), map = o.map.slice(0, -1), id = `${map}:${JSON.stringify(key)}`, u = key.a, cell = key.b.a;
+                    if (j !== undefined && !seen.has(id) && mapNames.includes(map)) {
+                        seen.add(id);
+                        const more = [...(j > 0 ? ['at a step'] : []), '\'s cells are naturals'].map(what => ({ fact: fi(`${m.name}: ${map}${what.startsWith('\'') ? what : ` ${what}`}`), at: [u, cell] }));
+                        insts.push(...more);
+                        for (const p of more)
+                            cellFacts(substC(facts[p.fact].holds, vars({ 'u$': p.at[0], 'k$': p.at[1] })));
+                    }
+                }
+            }
+            for (const val of Object.values(o))
+                cellFacts(val);
+        };
+        cellFacts([hyps, concl, uses.map(us => substC(laws[us.node].holds, { ...at(us.subst['t$']), vars: { ...at(us.subst['t$']).vars, ...Object.fromEntries(Object.entries(us.subst).filter(([n]) => n !== 't$')) } }))]);
+        for (const p of [...insts])
+            if (p.fact === fi(`${m.name}: a step`))
+                cellFacts(substC(facts[p.fact].holds, vars({ 'u$': p.at[0] })));
+        return { name: `${m.name}: ${sl.name}`, hyps, concl, rank: rank === 1 ? [t] : [t, ...Array.from({ length: rank - 1 }, () => k(2))], insts: insts.filter(p => p.fact >= 0), uses };
+    });
+    return sliced(withReads(facts, specs, [...lawNodes, ...specs]));
+}
+// A request allowed (BridgeRules.lean's cycAOk, cyc_allow_sound carries it to the claim): from every reachable state,
+// every request meeting `w` (a helpful request's region and terms), carrying empty sets, is one the machine allows. A node
+// at time t, the request the run takes at t the claim's (no step reads it): the precondition, t <= T, T < Ω, `w` at t,
+// each carried map's cell the assumption reads at t 0, every law at t (rank (t, 2) above theirs), the run's facts at t;
+// its conclusion the assumption at t, flags inlined.
+export function allowNode(m, laws, inst, w, facts, lawNodes, name, extra = []) {
+    const { at } = trace(m), flags = flagsOf(m), t = v('t$'), T = v('T$'), mapNames = Object.keys(m.maps ?? {}), carried = m.inputMaps ?? [];
+    const traced = [...mapNames, ...carried], state = Object.keys(m.state), now = at(t);
+    const fi = (n) => facts.findIndex(f => f.name === n);
+    const keysOf = (l) => [...(l.forall ? [l.forall] : []), ...(l.keys ?? [])];
+    const tuples = (l) => { const ks = keysOf(l), flat = inst[l.name] ?? []; return ks.length ? Array.from({ length: Math.floor(flat.length / ks.length) }, (_, i) => flat.slice(i * ks.length, (i + 1) * ks.length)) : [[]]; };
+    const concl = substC(substC(m.assume ?? yes, { vars: {}, maps: {}, flags }), now);
+    // Each carried cell the conclusion and the facts given at t read there (a flag's body at its witness, say): 0 (the
+    // request carries empty sets).
+    const zeros = [], seen = new Set();
+    const walk = (x) => {
+        if (!x || typeof x !== 'object')
+            return;
+        const o = x;
+        if (o.op === 'get' && typeof o.map === 'string' && o.map.endsWith('@') && carried.includes(o.map.slice(0, -1))) {
+            const id = JSON.stringify(o);
+            if (!seen.has(id)) {
+                seen.add(id);
+                zeros.push(eq(o, k(0)));
+            }
+        }
+        for (const val of Object.values(o))
+            walk(val);
+    };
+    walk([concl, instHyps(facts, extra)]);
+    const hyps = [...(m.pre ? [m.pre] : []), le(t, T), ...(traced.length ? [{ op: '<', a: T, b: omega }] : []), substC(w, now), ...zeros];
+    const uses = laws.flatMap((l, i) => tuples(l).map(ts => ({ node: i, subst: Object.fromEntries(keysOf(l).map((kn, q) => [kn, substE(ts[q], now)])), guard: yes })));
+    const insts = [{ fact: fi(`${m.name}: the start`), at: [t] }, { fact: fi(`${m.name}: a step`), at: [t] },
+        ...state.map(st => ({ fact: fi(`${m.name}: ${st} is a natural`), at: [t] })), { fact: fi(`${m.name}: params are naturals`), at: [] },
+        ...(m.facts ?? []).flatMap(f => tuples(f).map(ts => ({ fact: fi(f.name), at: ts.map(e => substE(e, now)) }))), ...extra];
+    // Each map cell read at t: its start, its step and that it is a natural there.
+    const cells = new Set();
+    const cellWalk = (x) => {
+        if (!x || typeof x !== 'object')
+            return;
+        const o = x;
+        if (o.op === 'get' && typeof o.map === 'string' && o.map.endsWith('@') && mapNames.includes(o.map.slice(0, -1))) {
+            const key = o.key;
+            if (key.op === 'add' && JSON.stringify(key.a) === JSON.stringify(t) && key.b.op === 'prod') {
+                const map = o.map.slice(0, -1), cell = key.b.a, id = `${map}:${JSON.stringify(cell)}`;
+                if (!cells.has(id)) {
+                    cells.add(id);
+                    insts.push(...['at the start', 'at a step', '\'s cells are naturals'].map(what => ({ fact: fi(`${m.name}: ${map}${what.startsWith('\'') ? what : ` ${what}`}`), at: [t, cell] })));
+                }
+            }
+        }
+        for (const val of Object.values(o))
+            cellWalk(val);
+    };
+    cellWalk([hyps, concl, uses.map(us => substC(laws[us.node].holds, { ...now, vars: { ...now.vars, ...us.subst } }))]);
+    const rank = lawNodes[0]?.rank.length ?? 2;
+    const spec = { name, hyps, concl, rank: [t, ...Array.from({ length: rank - 1 }, () => k(2))], insts: insts.filter(p => p.fact >= 0), uses };
+    return sliced(withReads(facts, [spec], [...lawNodes, spec]))[0];
+}
+// --- flags that hold at every key ------------------------------------------------------------------------------------
+// A machine with flags that hold at every key, read as its sk machine (BridgeRules.lean's SMachine.sk): each such flag
+// ?f and its witnesses inputs a request names, a read of the flag `?f = 1`; the closing conditions facts of the run
+// (`qflagFacts`). Untrusted: BridgeRules.lean's cycQMOk checks the facts against the machine.
+const quantifiedOf = (m) => Object.entries(m.step.flags ?? {}).filter((e) => e[1].op === 'all');
+export const hasQuantified = (m) => quantifiedOf(m).length > 0;
+export function skMachine(m) {
+    const q = quantifiedOf(m);
+    if (!q.length)
+        return m;
+    const flags = Object.fromEntries(Object.entries(m.step.flags ?? {}).map(([f, c]) => [f, c.op === 'all' ? eq(v(`?${f}`), k(1)) : c]));
+    return { ...m, inputs: [...m.inputs, ...q.map(([f]) => `?${f}`), ...q.flatMap(([f, c]) => witnessesOf(f, c))], step: { ...m.step, flags } };
+}
+// Each flag's closing conditions at each time u <= T (BridgeRules.lean's cycQFacts): 0 or 1; 0, or its body at every
+// value of its keys; 1, or its body failing at the witness.
+export function qflagFacts(m) {
+    const { at } = trace(skMachine(m)), u = v('u$'), T = v('T$');
+    const upTo = (c) => implies(le(u, T), substC(c, at(u)));
+    return quantifiedOf(m).flatMap(([f, q]) => {
+        const fv = v(`?${f}`), keys = boundOf(q), wits = witnessesOf(f, q);
+        return [
+            { name: `${m.name}: ?${f} is 0 or 1`, keys: ['u$'], holds: upTo(le(fv, k(1))) },
+            { name: `${m.name}: ?${f} is 0 or its body holds`, keys: ['u$', ...keys], holds: upTo({ op: 'or', xs: [eq(fv, k(0)), q.c] }) },
+            { name: `${m.name}: ?${f} is 1 or its body fails at the witness`, keys: ['u$'],
+                holds: upTo({ op: 'or', xs: [eq(fv, k(1)), { op: 'not', x: substC(q.c, vars(Object.fromEntries(keys.map((key, i) => [key, v(wits[i])])))) }] }) },
+        ];
+    });
+}
+// The closing facts at the times a node reads the run (each flag's at its time, its body at the keys the usual proof
+// closes it at, read there).
+export function closingInsts(m, facts, insts, times, laws = []) {
+    // (a law's fresh key k#, which the usual proof's keys may read, the node's own k)
+    const fresh = vars(Object.fromEntries(laws.flatMap(x => (x.forall ? [[`${x.forall}#`, v(x.forall)]] : []))));
+    const { at } = trace(skMachine(m)), fi = (n) => facts.findIndex(f => f.name === n), out = [], seen = new Set();
+    const push = (p) => { const id = JSON.stringify(p); if (p.fact >= 0 && !seen.has(id)) {
+        seen.add(id);
+        out.push(p);
+    } };
+    for (const [f, q] of quantifiedOf(m)) {
+        const n = boundOf(q).length;
+        for (const u of times) {
+            push({ fact: fi(`${m.name}: ?${f} is 0 or 1`), at: [u] });
+            push({ fact: fi(`${m.name}: ?${f} is 1 or its body fails at the witness`), at: [u] });
+            for (const inst of insts) {
+                const flat = inst[`?${f}`] ?? [];
+                for (let i = 0; i + n <= flat.length; i += n)
+                    push({ fact: fi(`${m.name}: ?${f} is 0 or its body holds`), at: [u, ...flat.slice(i, i + n).map(e => substE(substE(e, fresh), at(u)))] });
+            }
+        }
+    }
+    return out;
+}
+// The laws' nodes of a machine with such flags: its sk machine's (searched), with the closing facts, each node reading
+// them where the run's step before it and its own time are.
+export function qflagNodes(m, laws, instances) {
+    const base = machineNodes(skMachine(m), laws, instances);
+    if (base.why)
+        return base;
+    const facts = [...base.facts, ...qflagFacts(m)], t = v('t$');
+    const close = closingInsts(m, facts, Object.values(instances), [t, less1(t)], laws);
+    const add = (sp) => ({ ...sp, insts: [...sp.insts, ...close], ...(sp.variants ? { variants: sp.variants.map(add) } : {}) });
+    return { facts, specs: base.specs.map(add) };
 }
 // --- folds over trees -----------------------------------------------------------------------------------------------
 // The tree as a table of nodes below its size N: a node n is a leaf (Kind[n] = 0) whose values come from its inputs,
 // or a node (Kind[n] = 1) with children Left[n], Right[n] numbered below n, its values from theirs and its inputs.
-export function foldNodes(f, laws) {
+// `usual`: the usual proof's trees (kernel.ts's foldObligations), translated (`translatedFold` below), or no nodes with why not.
+export function foldNodes(f, laws, usual, st = tstats()) {
     const n = v('n$'), N = v('N$'), names = Object.keys(f.leaf);
     const at = (i) => vars(Object.fromEntries([...names, ...f.inputs].map(x => [x, get(`${x}@`, i)])));
     const kind = (i) => get('Kind@', i), left = (i) => get('Left@', i), right = (i) => get('Right@', i);
@@ -271,14 +1180,71 @@ export function foldNodes(f, laws) {
         insts: [{ fact: 0, at: [n] }, ...[n, left(n), right(n)].map(i => ({ fact: 1, at: [i] })), { fact: 2, at: [] }],
         uses: laws.flatMap((_, j) => [left, right].map(c => ({ node: j, subst: { 'n$': c(n) }, guard: eq(kind(n), k(1)) }))),
     }));
-    return { facts, specs };
+    if (!stepNodesOn())
+        return { facts, specs: sliced(specs) };
+    // Each law twice, as a machine's are (GDP_CYCLIC_STEP=0 states the first alone): at a node n, rank (n, 1), from the
+    // table's leaf case or from the law at a node from its children, rank (n, 0), the law read at the values the node's
+    // case gives (the usual rule's node goal, over the table's cells at its children), using every law at both children.
+    const L = laws.length, hyps = [...(f.pre ? [f.pre] : []), { op: '<', a: n, b: N }], inner = eq(kind(n), k(1));
+    const valuesAt = vars({ ...Object.fromEntries(f.inputs.map(x => [x, get(`${x}@`, n)])), ...Object.fromEntries(names.map(x => [x, substE(f.node[x], nodeAt(n))])) });
+    const fromChildren = laws.map((l) => {
+        const name = `${f.name}: ${l.name}, from its children`, h = [...hyps, inner];
+        return { name, hyps: h, concl: substC(l.holds, valuesAt), rank: [n, k(0)], insts: [{ fact: 0, at: [n] }, ...[left(n), right(n)].map(i => ({ fact: 1, at: [i] })), { fact: 2, at: [] }],
+            uses: laws.flatMap((_, j) => [left, right].map(c => ({ node: j, subst: { 'n$': c(n) }, guard: yes }))), variants: [{ name, hyps: h, concl: yes, rank: [n, k(0)], insts: [], uses: [], weak: true }] };
+    });
+    const atNode = laws.map((l, i) => {
+        const a = { name: `${f.name}: ${l.name}`, hyps, concl: substC(l.holds, at(n)), rank: [n, k(1)], insts: [{ fact: 0, at: [n] }, { fact: 1, at: [n] }, { fact: 2, at: [] }],
+            uses: [{ node: L + i, subst: {}, guard: inner }], variants: [{ ...specs[i], rank: [n, k(1)] }] };
+        const o = shared(facts, a, fromChildren[i].concl);
+        return o.length ? { ...a, opaque: o } : a;
+    });
+    if (usual)
+        return { facts, ...translatedFold() };
+    return { facts, specs: sliced([...atNode, ...fromChildren]) };
+    // The usual proof translated, as a machine's is: each law three nodes. At a node, as above, its goal grown: from the
+    // law at a leaf (Kind[n] = 0) or from its children (Kind[n] = 1). From its children, rank (n, 0): the usual node goal
+    // over the table (an input as its cell at n, l_x and r_x as x at Left[n] and Right[n]), the laws at both children its
+    // uses (each child below n a hypothesis, which the table at n gives where the node is used), the assumption at n
+    // too. At a leaf, rank (n, 0): the usual leaf goal at n.
+    function translatedFold() {
+        const goals = new Map(foldObligations(f, laws).map(g => [g.name, g])), sigma = nodeAt(n), sigma0 = at(n), ren = renamer({ s: sigma }), ren0 = renamer({ s: sigma0 });
+        const na = (f.pre ? 1 : 0) + (f.assume ? 1 : 0), last = (g) => g.hyps.at(-1).x;
+        const kids = [], leaves = [], made = [];
+        for (const [i, l] of laws.entries()) {
+            const g0 = goals.get(`${l.name} @leaf`), g1 = goals.get(`${l.name} @node`), t0 = g0 && usual[g0.name], t1 = g1 && usual[g1.name];
+            if (!g0 || !g1 || !t0 || !t1 || g0.hyps.length !== na + 1 || g1.hyps.length !== na + 2 * L + 1)
+                return { specs: [], why: `${l.name}: no usual tree, or one of another shape` };
+            const used1 = usedHyps(g1, t1);
+            kids.push({ name: `${f.name}: ${l.name}, from its children`, hyps: [...hyps, inner, { op: '<', a: left(n), b: n }, { op: '<', a: right(n), b: n }, ...(f.assume ? [substC(f.assume, sigma0)] : [])], concl: substC(last(g1), sigma), rank: [n, k(0)], insts: [],
+                uses: laws.flatMap((_, j) => [left, right].map(c => ({ node: j, subst: { 'n$': c(n) }, guard: yes }))).filter((_, q) => used1.has(na + q)) });
+            leaves.push({ name: `${f.name}: ${l.name}, at a leaf`, hyps: [...hyps, eq(kind(n), k(0)), ...(f.assume ? [substC(f.assume, sigma0)] : [])], concl: substC(last(g0), sigma0), rank: [n, k(0)], insts: [], uses: [] });
+            made.push({ g: g1, tree: t1, node: L + i, ren }, { g: g0, tree: t0, node: 2 * L + i, ren: ren0 });
+        }
+        const carried = atNode.map((a, i) => {
+            const b = { ...a, variants: undefined, carry: true, uses: [...a.uses, { node: 2 * L + i, subst: {}, guard: eq(kind(n), k(0)) }] };
+            const o = [...new Set([...shared(facts, b, kids[i].concl), ...shared(facts, b, leaves[i].concl)].map(e => JSON.stringify(e)))].map(e => JSON.parse(e));
+            return { ...b, opaque: o.length ? o : undefined };
+        });
+        const all = [...carried, ...kids, ...leaves], until = performance.now() + 10_000;
+        for (const m of made) {
+            const tree = timedKind('translate', 0, () => withProducts(() => translate(m.g, mainGoal(facts, all, all[m.node]), m.tree, m.ren, st, until)));
+            if (!tree)
+                return { specs: [], why: `${all[m.node].name}: not translated` };
+            all[m.node] = { ...all[m.node], main: tree };
+        }
+        return { specs: sliced(all) };
+    }
 }
 // --- the cyclic route beside the usual one (GDP_CYCLIC=1) -------------------------------------------------------------
 // With GDP_CYCLIC=1, every proof the instances above cover is made again as a cyclic proof, and a verdict that differs
-// throws: the suite run so shows the rules are instances. Each comparison is printed to stderr as a line `cyclic: {...}`.
+// throws (GDP_CYCLIC_LAX=1 only prints it, to measure a whole run): the suite run so shows the rules are instances. Each comparison is printed to stderr as a line `cyclic: {...}`.
 const env = () => globalThis.process?.env;
 let quiet = 0;
 export const cyclicOn = () => quiet === 0 && env()?.GDP_CYCLIC === '1';
+// The `cyclic: {...}` lines research/cyclic/ratios.ts reads, printed only with GDP_CYCLIC=1 (the cross-check) or
+// GDP_CYCLIC_LOG=1 (modal/run.py sets it): a user's proofs print nothing.
+export const cycLog = (o) => { if (env()?.GDP_CYCLIC === '1' || env()?.GDP_CYCLIC_LOG === '1')
+    console.error(`cyclic: ${JSON.stringify(o)}`); };
 // A search's many trial proofs (core/discover.ts, core/infer.ts) aren't compared: what it finds is proven again.
 export const quietly = (f) => { quiet++; try {
     return f();
@@ -286,10 +1252,130 @@ export const quietly = (f) => { quiet++; try {
 finally {
     quiet--;
 } };
-export function crossCyclic(kind, name, usual, run, usualMs) {
-    const t0 = performance.now(), out = run(), ms = Math.round(performance.now() - t0);
-    const cyclic = out.proven && out.checked;
-    console.error(`cyclic: ${JSON.stringify({ kind, name, usual, cyclic, ms, ...(usualMs === undefined ? {} : { usualMs: Math.round(usualMs) }), ...(out.proven ? { nodes: out.proof.nodes.length, ...(out.why ? { why: out.why } : {}) } : { goal: out.goal, stuck: out.stuck }) })}`);
-    if (cyclic !== usual)
+// A translated proof by what it was made from (the machine, its laws and instances; a recurrence's or fold's case): a
+// proof made again (a rule proven twice, as the suite does) is the one made and checked before (the same proof: the
+// kernel's check is a function of it, and nothing changes a proof once made). The key's time is GDP_CYCLIC_PROF's `key`.
+const proofsMade = new Map();
+// `base`: the key of a proof made before whose nodes these begin with (a machine's laws, for its step laws), reused where
+// its facts are these.
+export function translatedProof(key, build, st, base) {
+    const k0 = timedKind('key', 0, key), had = proofsMade.get(k0);
+    if (had) {
+        st.cached++;
+        return { verdict: { proven: true, checked: true, proof: had } };
+    }
+    const b = base && proofsMade.get(timedKind('key', 0, base)), { facts, specs, why } = build(!!b);
+    if (why)
+        return { why };
+    const made = b && b.nodes.length <= specs.length && JSON.stringify(b.facts) === JSON.stringify(facts) ? b.nodes : [];
+    if (b && !made.length)
+        return translatedProof(key, () => build(false), st);
+    const v = proveCyclic(facts, specs, undefined, translatedCache, st, made);
+    if (v.proven && v.checked) {
+        if (proofsMade.size >= 1024)
+            proofsMade.clear();
+        proofsMade.set(k0, v.proof);
+    }
+    return { verdict: v };
+}
+export const routeOf = () => env()?.GDP_CYCLIC_ROUTE ?? 'translate';
+const none = () => ({ proven: false, checked: false, node: '', goal: 'no instance searched', stuck: 'unknown' });
+export function crossCyclic(kind, name, usual, run0, usualMs, translated) {
+    const run = run0 ?? none;
+    for (const key of Object.keys(cyclicProf))
+        delete cyclicProf[key];
+    const route = routeOf(), st = tstats(), t0 = performance.now();
+    let out, how = 'searched', why;
+    if (route !== 'search' && usual && translated) {
+        const r = translated(st);
+        if (r.verdict?.proven && r.verdict.checked) {
+            out = r.verdict;
+            how = 'translated';
+        }
+        else {
+            how = 'fallback';
+            why = r.why ?? (r.verdict && !r.verdict.proven ? `${r.verdict.goal}: ${r.verdict.stuck}` : r.verdict?.why);
+        }
+    }
+    out ??= run();
+    const ms = Math.round(performance.now() - t0), cyclic = out.proven && out.checked;
+    const prof = profOn() ? { prof: Object.fromEntries(Object.entries(cyclicProf).map(([key, p]) => [key, Object.fromEntries(Object.entries(p).map(([f, x]) => [f, Math.round(x)]))])) } : {};
+    let search;
+    if (route === 'both' && run0) {
+        const s0 = performance.now(), o = run0();
+        search = { searchMs: Math.round(performance.now() - s0), searchCyclic: o.proven && o.checked };
+    }
+    cycLog({ kind, name, usual, cyclic, ms, ...(usualMs === undefined ? {} : { usualMs: Math.round(usualMs) }), route: how, ...(how !== 'searched' ? st : {}), ...(why ? { fellBack: why } : {}), ...search, ...prof, ...(out.proven ? { nodes: out.proof.nodes.length, ...(out.why ? { why: out.why } : {}) } : { goal: out.goal, stuck: out.stuck }) });
+    const lax = env()?.GDP_CYCLIC_LAX === '1';
+    if (cyclic !== usual && !lax)
         throw new Error(`cyclic route: ${kind} ${name} is ${cyclic ? 'proven' : 'not proven'} as a cyclic proof, ${usual ? 'proven' : 'not proven'} the usual way${out.proven ? (out.why ? ` (${out.why})` : '') : ` (${out.goal}: ${out.stuck})`}`);
+    if (search && search.searchCyclic !== usual && !lax)
+        throw new Error(`cyclic route: ${kind} ${name} is ${search.searchCyclic ? 'proven' : 'not proven'} as a cyclic proof searched, ${usual ? 'proven' : 'not proven'} the usual way`);
+}
+// The certificate of every proof the instances above cover is the cyclic one (GDP_CERT=usual: the usual trees, as
+// before 0.19.0), made from the usual proof (translated, searched where that fails) and checked by kernel/cyclic.ts; the
+// usual trees are then the translation's input, not checked again (kernel/prove.ts, core/dsl.ts). Each logs a line
+// `cyclic: {..., cert: true}` (cycLog).
+export const certOn = () => quiet === 0 && env()?.GDP_CERT !== 'usual';
+// With GDP_CERT=cyclic, what no translation covers (flags that hold at every key, k-step laws over a map) gets a searched
+// certificate too where GDP_CERT_SEARCH=1, each within GDP_CERT_MS (10 s by default), and keeps the usual one where none
+// is found then. Off by default: a search costs seconds a proof.
+export const certSearch = () => env()?.GDP_CERT_SEARCH === '1';
+export const certMs = () => Number(env()?.GDP_CERT_MS ?? 10_000);
+export function certCyclic(kind, name, translated, run0, usualMs) {
+    const run = run0 ?? none;
+    const st = tstats(), t0 = performance.now();
+    let out, how = 'searched', why;
+    if (translated) {
+        const r = translated(st);
+        if (r.verdict?.proven && r.verdict.checked) {
+            out = r.verdict;
+            how = 'translated';
+        }
+        else {
+            how = 'fallback';
+            why = r.why ?? (r.verdict && !r.verdict.proven ? `${r.verdict.goal}: ${r.verdict.stuck}` : r.verdict?.why);
+        }
+    }
+    out ??= run();
+    const checked = out.proven && out.checked;
+    cycLog({ kind, name, cert: true, usual: true, cyclic: checked, ms: Math.round(performance.now() - t0), ...(usualMs === undefined ? {} : { usualMs: Math.round(usualMs) }), route: how, ...(how !== 'searched' ? st : {}), ...(why ? { fellBack: why } : {}) });
+    return { checked, ...(out.proven ? { proof: out.proof } : {}) };
+}
+// The step laws' searched nodes after the laws' (stepLawNodes over the sk machine), with the flags' closing facts read
+// where each node reads the run on a machine with flags that hold at every key: what GDP_CERT=cyclic's search and the
+// Lean export's (lean-kernel/emit.ts) both try.
+export function searchedStepNodes(m, laws, steps, facts, lawNodes) {
+    const q = hasQuantified(m);
+    return stepLawNodes(skMachine(m), laws, steps, facts, lawNodes).map((sp, i) => {
+        if (!q)
+            return sp;
+        const more = closingInsts(m, facts, [steps[i].instances], Array.from({ length: (steps[i].law.steps ?? 1) + 1 }, (_, j) => tBack(j)));
+        const add = (x) => ({ ...x, insts: [...x.insts, ...more], ...(x.variants ? { variants: x.variants.map(add) } : {}) });
+        return add(sp);
+    });
+}
+// Live.lean's reqC: each input named by its term, two parts per and.
+export 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.
+export 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;
 }