gdp-wired 0.19.0 → 0.20.0

package/dist/core/cyclic.js

@@ -1,6 +1,6 @@
 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 { cellProducts, clock, grow, profile, usedHyps, widen, withDeadline, withinDeadline } 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 });
@@ -83,7 +83,7 @@ function rebuild(c, keep, at = { j: 0 }) {
 }
 // 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) {
+export function slice(g, whole, hypsOnly = false, join = true) {
     const reach = new Set(), parts = g.hyps.map(h => partsOf(h));
     const pieces = [];
     g.hyps.forEach((h, i) => {
@@ -118,7 +118,7 @@ export function slice(g, whole, hypsOnly = false) {
     // 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);
+    const joins = (p) => join && !!p.gives && concl.has(p.gives);
     if (kept.size === pieces.length && !pieces.some(joins))
         return undefined;
     const stays = new Set(), joined = [];
@@ -150,8 +150,6 @@ finally {
 } };
 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
@@ -169,18 +167,18 @@ export function proveCyclic(facts, specs, order0, grownBefore = searched, st = t
             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) }));
+                const t0 = performance.now(), p = timedKind(`${kind} sliced`, part.hyps.length, () => grow(part, new Map(), { nodes: 0, until: clock() + 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) }));
+                    const q = timedKind(`${kind} sliced`, sliced.hyps.length, () => grow(sliced, new Map(), { nodes: 0, until: clock() + 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)) }));
+            const o = timedKind(kind, g.hyps.length, () => grow(g, new Map(), { nodes: 0, until: clock() + (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 {
@@ -222,6 +220,22 @@ export function proveCyclic(facts, specs, order0, grownBefore = searched, st = t
         opaqueOf.set(out, names);
         return out;
     };
+    // A node's tree made from its goal (core/translate.ts's `carry`): first on the goal sliced (its facts' parts the
+    // conclusion and the uses reach: a step's equations for state the law doesn't read, whose choices `carry` would
+    // otherwise split at every leaf, left out), the tree then the whole goal's (`widen`); else on the whole goal.
+    const carried = (n1, first) => {
+        const g = mainGoal(facts, shapes, n1), h0 = n1.hyps.length, base = baseHyps(facts, n1).length, last = g.hyps.length - 1;
+        const part = first && sliceOn() ? slice(g, i => i < h0 || i >= base, false, false) : undefined;
+        if (part) {
+            const nf = part.from.filter(f => f[0] >= h0 && f[0] < base).length, nu = part.from.filter(f => f[0] >= base && f[0] < last).length;
+            const tree = carry(part, nf, nu, st, clock() + 2_000), wide = tree && timedKind('widen', 0, () => widen(part, g, tree));
+            if (env()?.GDP_CYCLIC_DEBUG)
+                console.error(`[carry] ${n1.name}: ${part.hyps.length} of ${g.hyps.length} hyps, ${tree ? (wide ? 'carried, widened' : 'carried, not widened') : 'not carried'}`);
+            if (wide)
+                return wide;
+        }
+        return carry(g, n1.insts.length, n1.uses.length, st, clock() + 2_000);
+    };
     // 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 }) => {
@@ -229,7 +243,7 @@ export function proveCyclic(facts, specs, order0, grownBefore = searched, st = t
         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);
+        const given = given0 ?? (made ? timedKind('carry', 0, () => withProducts(() => carried(n1, made === 'sliced'))) : undefined);
         if (made && !given0) {
             if (given)
                 st.carried++;
@@ -251,7 +265,7 @@ export function proveCyclic(facts, specs, order0, grownBefore = searched, st = t
             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) })));
+                const p = timedKind('main selected', g2.hyps.length, () => withProducts(() => grow(part, new Map(), { nodes: 0, until: clock() + 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;
@@ -292,6 +306,8 @@ export function proveCyclic(facts, specs, order0, grownBefore = searched, st = t
                 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 && env()?.GDP_CYCLIC_DEBUG)
+                        console.error(`[premise] ${n.name}: use of node ${u.node}, its hypothesis ${i} (${t.stuck}): ${JSON.stringify(substC(c, vars(u.subst)))}`);
                     if ('proven' in t)
                         return t;
                     premises.push(t);
@@ -316,7 +332,9 @@ export function proveCyclic(facts, specs, order0, grownBefore = searched, st = t
         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;
+            // (a translated node's goals, its uses' among them, within four: past that its translation isn't kept, the usual
+            // trees are)
+            later = j ? (refuted ? 1_000 : 3_000) : spec.main || spec.carry ? 4_000 : undefined;
             if (spec.uses.some(u => weak.has(u.node)))
                 continue;
             const r = attempt(spec);
@@ -336,13 +354,25 @@ export function proveCyclic(facts, specs, order0, grownBefore = searched, st = t
         if (failed || !nodes[i])
             return failed ?? { proven: false, checked: false, node: specs[i].name, goal: specs[i].name, stuck: 'unknown' };
     }
+    // (GDP_CYCLIC_PROF: the nodes made before, checked again within the whole, timed apart too)
+    if (profOn() && made.length)
+        timedKind('check, of the nodes made before', 0, () => refuseCyclic({ facts, nodes: made }));
     const proof = { facts, nodes }, why = timedKind('check', 0, () => refuseCyclic(proof));
     return { proven: true, checked: why === undefined, proof, ...(why ? { why } : {}) };
 }
+// Hypotheses as their conjuncts, each a hypothesis of its own: a node used with them proves each premise apart, a goal
+// as small as the conjunct (a premise that is a conjunction of disjunctions, refuted against itself, would be split
+// case by case through every conjunct), and the rows its goal has are the same.
+const conjuncts = (cs) => cs.flatMap(c => (c.op === 'and' ? conjuncts(c.xs) : [c]));
 // 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 })) } : {}) }));
+// A law's keys (its key at every value, then its further keys); the tuples of terms a proof's instances name it at; the
+// fresh key k# a usual proof proves a law about every key at, as the law's own key.
+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 freshOf = (laws) => Object.fromEntries(laws.flatMap(x => (x.forall ? [[`${x.forall}#`, v(x.forall)]] : [])));
 // 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 });
+const factOf = (l) => ({ name: l.name, keys: keysOf(l), holds: l.holds });
 // `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()) {
@@ -367,9 +397,7 @@ export function recurNodes(r, usual, st = tstats()) {
             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))],
         });
-    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)),
+    // Each lemma and law twice, as a machine's laws are: 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.
@@ -490,15 +518,8 @@ export function recurNodes(r, usual, st = tstats()) {
             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) };
+        const until = withinDeadline(clock() + 10_000);
+        return translateMade(facts, all, made, st, until);
     }
 }
 // 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
@@ -536,8 +557,8 @@ function withReads(facts, specs, nodes = specs) {
     });
 }
 // --- machines -------------------------------------------------------------------------------------------------------
-// The machines this instance covers: no history, no flag holding at every key, and no law that reads a map at a key
-// 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 machines this instance covers: no history (its plain machine is one: kernel.ts's historyMachine), and no law that
+// reads a map at a key 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 = []) => uncoveredWhy(m, laws) === undefined;
@@ -553,7 +574,7 @@ export const uncoveredWhy = (m, laws = []) => {
         return;
     } for (const val of Object.values(o))
         walk(val, inKey); }; walk(t, false); return found; };
-    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;
+    return m.history ? 'a history' : 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) {
@@ -587,7 +608,11 @@ const flagsOf = (m) => {
     return out;
 };
 // `lawsMade`: the laws' nodes are made already (their trees not translated again).
-export function machineNodes(m, laws, instances, usual, st = tstats()) {
+// A machine with flags that hold at every key is read as its sk machine (`skMachine`), the flags' closing conditions facts
+// of the run (`qflagFacts`, BridgeRules.lean's cycQFacts): the usual goals' closing hypotheses (kernel.ts's `closing`)
+// are those facts at the time before the step (`closings`).
+export function machineNodes(given, laws, instances, usual, st = tstats()) {
+    const quant = hasQuantified(given), m = skMachine(given);
     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 });
@@ -616,62 +641,39 @@ export function machineNodes(m, laws, instances, usual, st = tstats()) {
         // value a column of its own (a value read only inside a product would be none, and no two reads of it equal).
         ...state.map((s) => ({ name: `${m.name}: ${s} is a natural`, keys: ['u$'], holds: le(k(0), get(`${s}@`, u)) })),
         { name: `${m.name}: params are naturals`, keys: [], holds: and(yes, ...m.params.map(x => le(k(0), v(x)))) },
+        ...(quant ? qflagFacts(given) : []),
     ];
     const fi = (name) => facts.findIndex(f => f.name === name);
+    const closings = (inst, u, frame) => closingsAt(given, laws, facts, inst, u, frame);
+    // Every law at time u, at the keys the proof names it at, each key's term read by `key`, under `guard`.
+    const lawUses = (inst, u, key, guard) => laws.flatMap((l2, j) => tuples(inst, l2).map(ts => ({ node: j, subst: { 't$': u, ...Object.fromEntries(keysOf(l2).map((kn, r) => [kn, key(ts[r])])) }, guard })));
+    // The usual proof's fresh key k# of a law about every key, the node's own k; the functions' facts at the keys the
+    // proof names, over a frame; 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 same cells there).
+    const fresh = freshOf(laws), mapOmega = mapNames.length ? [{ op: '<', a: T, b: omega }] : [];
+    const fnInsts = (inst, frame) => (m.facts ?? []).flatMap(f => tuples(inst, f).map(ts => ({ fact: fi(f.name), at: ts.map(e => substE(substE(e, vars(fresh)), frame)) })));
+    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];
+                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) };
+            }])) };
     // 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 nexts = new Map(state.flatMap(s => { const e = m.step.state?.[s]; return e && !(e.op === 'var' && e.name === s) ? [[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) => {
-        const out = [], 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('@') && mapNames.includes(o.map.slice(0, -1))) {
-                const kk = o.key;
-                if (kk.op === 'add' && JSON.stringify(kk.a) === JSON.stringify(t) && kk.b.op === 'prod') {
-                    const read = kk.b.a, id = JSON.stringify(read), map = o.map.slice(0, -1);
-                    if (!seen.has(`${map}:${id}`)) {
-                        seen.add(`${map}:${id}`);
-                        out.push(...['at the start', 'at a step', '\'s cells are naturals'].map(what => ({ fact: fi(`${m.name}: ${map}${what.startsWith('\'') ? what : ` ${what}`}`), at: [t, read] })));
-                    }
-                }
-            }
-            for (const val of Object.values(o))
-                walk(val);
-        };
-        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
+    const mapInsts = (c) => cellsAt(m, facts, c);
+    // Each law twice: 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 L = laws.length, pre = at(less1(t)), one = le(k(1), t), omegaHyp = mapOmega;
         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
@@ -687,13 +689,7 @@ export function machineNodes(m, laws, instances, usual, st = tstats()) {
         });
         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 }));
-            });
+            const uses = lawUses(inst, less1(t), e => over(e, pre), 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`;
@@ -709,11 +705,12 @@ export function machineNodes(m, laws, instances, usual, st = tstats()) {
         }
         return [...nowNodes, ...stepNodes];
     }
+    if (usual)
+        return { facts, ...translatedNodes() };
     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
@@ -731,13 +728,7 @@ export function machineNodes(m, laws, instances, usual, st = tstats()) {
             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);
-            if (!ks.length)
-                return [{ node: j, subst: { 't$': less1(t) }, guard: le(k(1), t) }];
-            const flat = inst[l2.name] ?? [];
-            return Array.from({ length: Math.floor(flat.length / ks.length) }, (_, i) => ({ node: j, subst: { 't$': less1(t), ...Object.fromEntries(ks.map((kn, q) => [kn, before(flat[i * ks.length + q])])) }, guard: le(k(1), t) }));
-        });
+        const uses = lawUses(inst, less1(t), before, le(k(1), t));
         // 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] ?? [], fact = fi(f.name);
@@ -752,9 +743,14 @@ export function machineNodes(m, laws, instances, usual, st = tstats()) {
             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,
         };
     });
-    if (usual)
-        return { facts, ...translatedNodes() };
-    return { facts, specs: sliced(stepNodesOn() ? stepNodes(specs) : specs) };
+    const searchedSpecs = sliced(stepNodes(specs));
+    if (!quant)
+        return { facts, specs: searchedSpecs };
+    // (searched, with flags at every key: each node reads the closing facts where the run's step before it and its own time
+    // are)
+    const close = closingInsts(given, facts, Object.values(instances), [t, less1(t)], laws);
+    const withClose = (sp) => ({ ...sp, insts: [...sp.insts, ...close], ...(sp.variants ? { variants: sp.variants.map(withClose) } : {}) });
+    return { facts, specs: searchedSpecs.map(withClose) };
     // 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
@@ -763,24 +759,12 @@ export function machineNodes(m, laws, instances, usual, st = tstats()) {
     // 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 L = laws.length, pre = at(less1(t)), one = le(k(1), t), omegaHyp = mapOmega;
         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) };
-                }])) };
+        const goals = new Map(obligations(given, laws, instances).map(g => [g.name, g]));
+        // (`upd`: the usual step goal's conclusion but for a write's reads at its key, 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`)
         // 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 = [];
@@ -810,24 +794,19 @@ export function machineNodes(m, laws, instances, usual, st = tstats()) {
             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)
+            const uses = lawUses(inst, less1(t), e => substE(e, sigma), yes);
+            const fn1 = fnInsts(inst, pre), fn0 = fnInsts(inst, vars({})), cl = closings(inst, less1(t), pre), nb = nf + np + na + uses.length;
+            if (g1.hyps.length !== nb + cl.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: [] });
+            afters.push({ name: `${m.name}: ${l.name}, after a step`, hyps: conjuncts([...(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)), ...cl.filter((_, j) => used1.has(nb + j))], uses: uses.filter((_, j) => used1.has(nf + np + na + j)) });
+            starts.push({ name: `${m.name}: ${l.name}, at the start`, hyps: conjuncts(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 });
+            // (the closing facts' time t − 1 <= T decided too: their rows are then the closing hypotheses')
+            made.push({ g: g1, tree: t1, node: L + i, ren, decide: [one, ...(cl.length ? [le(less1(t), T)] : [])], 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
@@ -837,54 +816,80 @@ export function machineNodes(m, laws, instances, usual, st = tstats()) {
         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` };
+            // (k steps: the state after each step a cell at its time, a map read after a step the usual goal's term over the
+            // cells at t − k, the step's writes, a map a later request carries (c@j) its cells at its time)
+            const carried = m.inputMaps ?? [], overMaps = K > 1 && mapNames.length > 0;
+            // The times: over a map, one step back at a time (t − 1 − 1, as a step's fact reads the time before it: the cells it
+            // gives are the frames' own, with no key to prove equal); else t − n at once (BridgeRules.lean's cycKOk reads both).
+            // (one step back at a time, a time t − n is a term n deep and a premise's slice follows each state's cell back
+            // through every step's fact before it: the budget rule's 32 steps took 39 s against its usual proof's 1.5 s)
+            const time = overMaps ? tBack : tSub;
+            const laterMaps = Object.fromEntries(Array.from({ length: K - 1 }, (_, j) => j + 2).flatMap(j => carried.map(c => [`${c}@${j}`, { to: `${c}@`, at: time(K - j + 1) }])));
             // 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 });
+                    ])) }, maps: K === 1 ? pre.maps : { ...at(time(K)).maps, ...Object.fromEntries(Object.entries(laterMaps).map(([n, c]) => [n, (kk) => get(c.to, pair(c.at, kk))])) }, flags: {} };
+            const sig = K === 1 ? sigma : frame, renK = K === 1 ? ren : renamer({ s: frame, cells: { ...Object.fromEntries([...mapNames, ...carried].map(map => [map, { to: `${map}@`, at: time(K) }])), ...laterMaps } });
             // (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 lawsAt = (back) => lawUses(inst, time(back), e => substE(e, at(time(back))), 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.
+            // (a flag at every key: each step's closing hypotheses the closing facts at its time)
+            // (its keys over the frame: a key may read a later step's request, a flag read at a later step's witness)
+            const cls = Array.from({ length: K }, (_, j) => closings(inst, time(K - j), K === 1 ? at(time(K - j)) : { vars: { ...frame.vars, ...at(time(K - j)).vars }, maps: { ...frame.maps, ...at(time(K - j)).maps }, flags: {} })), nc = cls[0].length;
+            // Each step's block: its laws, its assumption, its when, its closing hypotheses, 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);
+                pos += nl + na + (whens[j] ? 1 : 0) + nc + (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)));
+            // Over a map, a later step reads it as the usual goal's terms over the cells at t − k: each later step's laws (a use
+            // at its time) must read no map so, and its assumption, `when` and closing hypotheses are the usual goal's renamed
+            // (hypotheses of the node after the steps, which the step law's facts back to t − k give).
+            const renamed = (i) => substC(g.hyps[i], frame), later0 = [];
+            if (overMaps)
+                for (let j = 1; j < K; j++) {
+                    const b0 = blocks[j];
+                    for (const [r, us] of perStep[j].entries())
+                        if (used.has(b0 + r) && JSON.stringify(substC(nows[us.node].concl, vars(us.subst))) !== JSON.stringify(renamed(b0 + r)))
+                            return { specs: [], why: `${sl.name}: a law read over a map after a step` };
+                    for (let r = nl; r < nl + na + (whens[j] ? 1 : 0) + nc; r++)
+                        if (used.has(b0 + r))
+                            later0.push(renamed(b0 + r));
+                }
             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 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))])), ...frame.maps }, 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))) });
+            // (those the usual tree reads: each is a premise of this node where the step law uses it, and over a map one that
+            // reads the map after a step is proven through the map's cells back to t − k)
+            const eqs = blocks.slice(0, K - 1).flatMap((b0, j) => { const e0 = b0 + nl + na + (whens[j] ? 1 : 0) + nc; return g.hyps.slice(e0, e0 + state.length).flatMap((h, r) => (used.has(e0 + r) ? [substC(h, frame)] : [])); });
+            const closed = cls.flatMap((c, j) => (overMaps && j ? [] : c.filter((_, r) => used.has(blocks[j] + nl + na + (whens[j] ? 1 : 0) + r))));
+            const own = overMaps ? [...assumes.slice(0, na), ...when.slice(0, whens[0] ? 1 : 0), ...later0] : [...assumes, ...when];
+            stepSpecs.push({ name: `${m.name}: ${sl.name}, after ${K === 1 ? 'a step' : `${K} steps`}`, hyps: conjuncts([...bounds, ...own, ...eqs]), concl: after, rank: [t, k(0)],
+                insts: [...fn1.filter((_, r) => used.has(np + r)), ...closed], uses: perStep.flatMap((us, j) => us.filter((_, r) => used.has(blocks[j] + r))) });
+            // (over a map, each cell the step law and its `when`s read back to t − k, and the closing facts at each later time)
+            const back = [];
+            if (overMaps)
+                cellChain(m, facts, Array.from({ length: K + 1 }, (_, j) => time(K - j)), back)([cells, when, later0, instHyps(facts, [...run(t), ...steps, ...cls.slice(1).flat()])]);
             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 });
+                insts: [...run(t), ...steps, ...(overMaps ? [...back, ...cls.slice(1).flat()] : mapInsts(cells))], uses: [{ node: a, subst: {}, guard: yes }], carry: overMaps ? 'sliced' : 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) : [] });
+            // (and each closing fact's time at most T)
+            made.push({ g, tree, node: a, ren: renK, decide: [...Array.from({ length: K }, (_, j) => le(k(j + 1), t)), ...(nc ? Array.from({ length: K }, (_, j) => le(time(j + 1), T)) : [])], reads: K === 1 ? readsOf(last) : [] });
         }
         const all = [...nows, ...afters, ...starts, ...stepSpecs];
         for (const [i, a] of nows.entries()) {
@@ -893,20 +898,21 @@ export function machineNodes(m, laws, instances, usual, st = tstats()) {
                 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) };
+        const until = withinDeadline(clock() + 60_000);
+        // (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)
+        return translateMade(facts, all, usual.lawsMade ? made.filter(x => x.node >= 3 * L) : made, st, until);
+    }
+}
+function translateMade(facts, all, made, st, until) {
+    for (const x of made) {
+        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).
@@ -987,8 +993,6 @@ export function stepLawNodes(m, laws, steps, facts, lawNodes, time = tBack) {
     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 }] : []),
@@ -1004,32 +1008,7 @@ export function stepLawNodes(m, laws, steps, facts, lawNodes, time = tBack) {
             { 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);
-        };
+        const cellFacts = cellChain(m, facts, times, insts);
         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`))
@@ -1038,6 +1017,64 @@ export function stepLawNodes(m, laws, steps, facts, lawNodes, time = tBack) {
     });
     return sliced(withReads(facts, specs, [...lawNodes, ...specs]));
 }
+// Each map cell `x` reads at the node's time t: that map's start, its step and that its cells are naturals there.
+function cellsAt(m, facts, x) {
+    const mapNames = Object.keys(m.maps ?? {}), t = JSON.stringify(v('t$')), fi = (name) => facts.findIndex(f => f.name === name);
+    const out = [], seen = new Set();
+    const walk = (y) => {
+        if (!y || typeof y !== 'object')
+            return;
+        const o = y;
+        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) === t && key.b.op === 'prod') {
+                const map = o.map.slice(0, -1), cell = key.b.a, id = `${map}:${JSON.stringify(cell)}`;
+                if (!seen.has(id)) {
+                    seen.add(id);
+                    out.push(...['at the start', 'at a step', '\'s cells are naturals'].map(what => ({ fact: fi(`${m.name}: ${map}${what.startsWith('\'') ? what : ` ${what}`}`), at: [key.a, cell] })));
+                }
+            }
+        }
+        for (const val of Object.values(o))
+            walk(val);
+    };
+    walk(x);
+    return out;
+}
+// Each map cell a node reads at one of `times` (the first the earliest), pushed to `insts`: that map's step there (at a
+// time after the first) and that its cells are naturals, then the same of the cells those facts read, back to the first
+// time: the cells a step gives read back to the run's cells where the node starts.
+function cellChain(m, facts, times, insts) {
+    const mapNames = Object.keys(m.maps ?? {}), traced = [...mapNames, ...(m.inputMaps ?? [])], fi = (name) => facts.findIndex(f => f.name === name);
+    // (a time read either way, t − n or one step back at a time: a step's fact at t − 1 reads t − 1 − 1)
+    const norm = (u) => (u.op === 'sub' && u.b.op === 'const' && u.a.op === 'sub' && u.a.b.op === 'const' ? norm({ op: 'sub', a: u.a.a, b: k(u.a.b.value + u.b.value) }) : u);
+    const seen = new Set(), ix = new Map(times.map((u, j) => [JSON.stringify(norm(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(norm(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);
+    };
+    return cellFacts;
+}
 // 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,
@@ -1047,8 +1084,7 @@ 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 tuplesOf = (l) => tuples(inst, l);
     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).
@@ -1069,34 +1105,66 @@ export function allowNode(m, laws, inst, w, facts, lawNodes, name, extra = []) {
     };
     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 uses = laws.flatMap((l, i) => tuplesOf(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 } }))]);
+        ...(m.facts ?? []).flatMap(f => tuplesOf(f).map(ts => ({ fact: fi(f.name), at: ts.map(e => substE(e, now)) }))), ...extra];
+    insts.push(...cellsAt(m, facts, [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];
 }
+// A request allowed, translated (proveProgress's goal `<name>: the request is allowed`, kernel.ts's progressObligations,
+// read at time t), two nodes after the laws' (`lawNodes`, rank (t, 1) the laws at t): the usual goal over the cells at
+// t, the request's terms as it reads them, rank (t, 2): its hypotheses the precondition, t <= T, T < Ω, `when` at t and
+// the closing hypotheses no closing fact gives (each a conjunct), the laws at t at the keys it names its uses, the
+// functions' and the closing facts its facts, its tree the usual one's; then the request allowed itself, rank (t, 3)
+// (BridgeRules.lean's cycAOk: `w` the region, the request's terms and its witnesses at t, its conclusion the assumption
+// at t), carried from the first by the request's equations.
+export function allowTranslated(given, laws, inst, p, usual, facts, lawNodes, name, st) {
+    const m = skMachine(given), { at } = trace(m), t = v('t$'), T = v('T$'), now = at(t), mapNames = Object.keys(m.maps ?? {});
+    const fi = (n) => facts.findIndex(f => f.name === n), tuplesOf = (l) => tuples(inst, l);
+    const g = usual.goal, used = usedHyps(g, usual.tree), renamed = (c) => substC(c, now);
+    const fns = (m.facts ?? []).flatMap(f => tuplesOf(f).map(ts => ({ fact: fi(f.name), at: ts.map(e => substE(e, now)) })));
+    const uses = laws.flatMap((l, i) => tuplesOf(l).map(ts => ({ node: i, subst: Object.fromEntries(keysOf(l).map((kn, q) => [kn, substE(ts[q], now)])), guard: yes })));
+    const cl = closingsAt(given, laws, facts, inst, t, now), nf = fns.length, np = m.pre ? 1 : 0;
+    if (g.hyps.length !== nf + np + uses.length + 1 + cl.length + 1 || !m.assume)
+        return { specs: [], why: `${name}: a usual goal of another shape` };
+    // (a closing hypothesis the closing fact at t gives as it is, a fact; one whose body reads the request, a hypothesis)
+    const nb = nf + np + uses.length + 1, closeFacts = [], closeHyps = [];
+    for (const [j, q] of cl.entries()) {
+        if (!used.has(nb + j))
+            continue;
+        if (JSON.stringify(instHyps(facts, [q])[0]) === JSON.stringify(renamed(g.hyps[nb + j])))
+            closeFacts.push(q);
+        else
+            closeHyps.push(renamed(g.hyps[nb + j]));
+    }
+    const omegaHyp = mapNames.length ? [{ op: '<', a: T, b: omega }] : [], base = [...(m.pre ? [m.pre] : []), le(t, T), ...omegaHyp];
+    const flags = flagsOf(m), terms = { name: `${name}, its terms`, hyps: conjuncts([...base, renamed(p.when), ...closeHyps]), concl: renamed(g.hyps.at(-1).x), rank: [t, k(2)],
+        insts: [...fns.filter((_, q) => used.has(q)), ...closeFacts], uses: uses.filter((_, j) => used.has(nf + np + j)) };
+    const w = and(p.when, reqTS(Object.entries(p.request)), reqTS([]));
+    const allowed = { name, hyps: [...base, renamed(w)], concl: renamed(substC(m.assume, { vars: {}, maps: {}, flags })), rank: [t, k(3)],
+        insts: closeHyps.length ? cl : [], uses: [{ node: lawNodes.length, subst: {}, guard: yes }], carry: true };
+    const all = [...lawNodes, terms, allowed], whole = mainGoal(facts, all, terms), until = withinDeadline(clock() + 10_000);
+    const ren = renamer({ s: now, cells: Object.fromEntries(mapNames.map(map => [map, { to: `${map}@`, at: t }])) });
+    const tree = timedKind('translate', 0, () => withProducts(() => decide(whole, closeFacts.length ? [le(t, T)] : [], wp => translate(g, whole, usual.tree, ren, st, until, new Map(), wp), st, until)));
+    if (!tree)
+        return { specs: [], why: `${terms.name}: not translated` };
+    return { specs: sliced([{ ...terms, main: tree }, allowed]) };
+}
+// A goal's closing hypotheses (kernel.ts's `closing`, in its order: each flag 0 or 1, its body at each key the proof
+// names, its body failing at the witness) as the closing facts at time u, the keys read over `frame` (a law's fresh key
+// its own k).
+function closingsAt(given, laws, facts, inst, u, frame) {
+    const fi = (n) => facts.findIndex(f => f.name === n), fresh = vars(freshOf(laws));
+    return quantifiedOf(given).flatMap(([f, qf]) => {
+        const n = boundOf(qf).length, flat = inst[`?${f}`] ?? [];
+        return [{ fact: fi(`${given.name}: ?${f} is 0 or 1`), at: [u] },
+            ...Array.from({ length: Math.floor(flat.length / n) }, (_, j) => ({ fact: fi(`${given.name}: ?${f} is 0 or its body holds`), at: [u, ...flat.slice(j * n, (j + 1) * n).map(e => substE(substE(e, fresh), frame))] })),
+            { fact: fi(`${given.name}: ?${f} is 1 or its body fails at the witness`), at: [u] }];
+    });
+}
 // --- 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
@@ -1129,7 +1197,7 @@ export function qflagFacts(m) {
 // 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 fresh = vars(freshOf(laws));
     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);
@@ -1149,17 +1217,8 @@ export function closingInsts(m, facts, insts, times, laws = []) {
     }
     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) };
-}
+// The laws' nodes of a machine with such flags (searched): machineNodes, which reads it as its sk machine.
+export const qflagNodes = (m, laws, instances) => machineNodes(m, laws, instances);
 // --- 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.
@@ -1180,9 +1239,7 @@ export function foldNodes(f, laws, usual, st = tstats()) {
         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)) }))),
     }));
-    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
+    // Each law twice, as a machine's are: 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));
@@ -1225,14 +1282,8 @@ export function foldNodes(f, laws, usual, st = tstats()) {
             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) };
+        const all = [...carried, ...kids, ...leaves], until = withinDeadline(clock() + 10_000);
+        return translateMade(facts, all, made, st, until);
     }
 }
 // --- the cyclic route beside the usual one (GDP_CYCLIC=1) -------------------------------------------------------------
@@ -1280,26 +1331,38 @@ export function translatedProof(key, build, st, base) {
 }
 export const routeOf = () => env()?.GDP_CYCLIC_ROUTE ?? 'translate';
 const none = () => ({ proven: false, checked: false, node: '', goal: 'no instance searched', stuck: 'unknown' });
+// The cyclic proof of what the usual route proved: translated, else (`fallback`, or `searched` where nothing is
+// translated) searched, within `until` where it is given; with why the translation wasn't proven.
+// A translation within the certificate's budget (GDP_CERT_MS) or four times the usual proof's time, whichever is longer
+// (`translateMs`): one that will fail is cut there, not at its goals' own bounds.
+export const translateMs = (usualMs = 0) => Math.max(certMs(), 4 * usualMs);
+function cyclicOf(translated, run, st, until, usualMs) {
+    let how = 'searched', why;
+    if (translated) {
+        const r = withDeadline(clock() + translateMs(usualMs), () => translated(st));
+        if (r.verdict?.proven && r.verdict.checked)
+            return { out: r.verdict, how: 'translated' };
+        how = 'fallback';
+        why = r.why ?? (r.verdict && !r.verdict.proven ? `${r.verdict.goal}: ${r.verdict.stuck}` : r.verdict?.why);
+    }
+    return { out: until === undefined ? run() : withDeadline(until, run), how, ...(why ? { why } : {}) };
+}
+// GDP_CYCLIC_PROF=1: where the proof's time went, by goal kind, in its line.
+const profLine = () => (profOn() ? { prof: Object.fromEntries(Object.entries(cyclicProf).map(([key, p]) => [key, Object.fromEntries(Object.entries(p).map(([f, x]) => [f, Math.round(x)]))])) } : {});
 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();
+    // (a search within GDP_CERT_MS: one cut by it, or none to make where the translation fails, leaves the proof uncovered,
+    // not differing)
+    const route = routeOf(), st = tstats(), t0 = performance.now(), until = clock() + certMs();
+    const { out, how, why } = cyclicOf(route !== 'search' && usual ? translated : undefined, run, st, until, usualMs);
     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)]))])) } : {};
+    if (usual && !cyclic && (!run0 || clock() > until)) {
+        uncovered(kind, name, `no cyclic proof found${run0 ? ` within ${certMs()} ms` : ''}${why ? ` (not translated: ${why})` : ''}`);
+        return;
+    }
+    const prof = profLine();
     let search;
     if (route === 'both' && run0) {
         const s0 = performance.now(), o = run0();
@@ -1313,34 +1376,27 @@ export function crossCyclic(kind, name, usual, run0, usualMs, translated) {
         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.
+// before 0.19.0), translated from the usual proof and checked by kernel/cyclic.ts; the usual trees are then the
+// translation's input, not checked again (kernel/prove.ts, core/dsl.ts). Where no cyclic proof is made, the caller
+// checks the usual trees and counts the proof uncovered (`why`). With GDP_CERT_SEARCH=1 (off by default: a search costs
+// seconds a proof) a proof the translation doesn't cover is searched first, within GDP_CERT_MS (10 s by default). Each
+// logs a line `cyclic: {..., cert: true}` (cycLog).
+export const certMode = () => env()?.GDP_CERT !== 'usual';
+export const certOn = () => quiet === 0 && certMode();
 export const certSearch = () => env()?.GDP_CERT_SEARCH === '1';
 export const certMs = () => Number(env()?.GDP_CERT_MS ?? 10_000);
+// A proof of a kind no cyclic instance covers, or whose cyclic proof wasn't made, counted (`cyclic: {..., uncovered:
+// true, why}`): its certificate the usual trees.
+export const uncovered = (kind, name, why) => cycLog({ kind, name, uncovered: true, why });
 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();
+    for (const key of Object.keys(cyclicProf))
+        delete cyclicProf[key];
+    const st = tstats(), t0 = performance.now(), until = clock() + certMs();
+    const { out, how, why } = cyclicOf(translated, (translated && !certSearch() ? undefined : run0) ?? none, st, until, usualMs);
     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 } : {}) };
+    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 } : {}), ...profLine() });
+    const late = clock() > until ? ` within ${certMs()} ms` : '';
+    return { checked, ...(out.proven ? { proof: out.proof } : {}), why: checked ? '' : `no cyclic proof found${late}${why ? ` (not translated: ${why})` : ''}` };
 }
 // 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