gdp-wired 0.19.0 → 0.20.0

package/dist/core/discover.js

@@ -83,8 +83,8 @@ function linearCands(target, forms, samples, show) {
     return dedupe(out.filter(c => samples.every(s => holds(c, s))));
 }
 const dedupe = (cs) => [...new Map(cs.map(c => [c.name, c])).values()];
-// A polynomial in x of degree 2 at most, exact over the rationals, as d·f = a·x·x + b·x + c with whole numbers: fitted to
-// three points, kept when every sample meets it.
+// A polynomial in x of degree 3 at most, exact over the rationals, as d·f = a·x·x·x + b·x·x + c·x + e with whole
+// numbers: fitted to four points (Newton's differences), kept when every sample meets it.
 function closedForm(samples, show) {
     const at = new Map();
     for (const s of samples) {
@@ -95,22 +95,30 @@ function closedForm(samples, show) {
     if (![0, 1, 2].every(x => at.has(x)))
         return [];
     const [f0, f1, f2] = [at.get(0), at.get(1), at.get(2)];
+    const keep = (lin) => {
+        const g = Object.values(lin).reduce((p, q) => gcd(p, Math.abs(q)), 0);
+        const c = { name: '', rel: '=', lin: Object.fromEntries(Object.entries(lin).map(([a, k]) => [a, k / g]).filter(([, k]) => k !== 0)) };
+        c.name = nameOf(c, show, 'f');
+        return samples.every(s => holds(c, s)) ? [c] : [];
+    };
     // f = a x² + b x + c: c = f0, a = (f2 - 2 f1 + f0) / 2, b = f1 - f0 - a; times 2 to keep whole numbers.
     const A = f2 - 2 * f1 + f0, B = 2 * (f1 - f0) - A, C = 2 * f0;
-    if (A === 0)
-        return []; // linear: the bounds find it
-    const g = [A, B, C, 2].reduce((p, q) => gcd(p, Math.abs(q)), 0);
-    const c = { name: '', rel: '=', lin: Object.fromEntries(Object.entries({ f: 2 / g, xx: -A / g, x: -B / g, 1: -C / g }).filter(([, k]) => k !== 0)) };
-    c.name = nameOf(c, show, 'f');
-    return samples.every(s => holds(c, s)) ? [c] : [];
+    const square = A === 0 ? [] : keep({ f: 2, xx: -A, x: -B, 1: -C });
+    if (square.length || !at.has(3))
+        return square;
+    // f = Δ0 + Δ1·x + Δ2·x(x − 1)/2 + Δ3·x(x − 1)(x − 2)/6, times 6: x³ by Δ3, x² by 3Δ2 − 3Δ3, x by 6Δ1 − 3Δ2 + 2Δ3.
+    const d1 = f1 - f0, d2 = f2 - 2 * f1 + f0, d3 = at.get(3) - 3 * f2 + 3 * f1 - f0;
+    if (d3 === 0)
+        return []; // degree 2 at most: above, or linear (the bounds find it)
+    return keep({ f: 6, xxx: -d3, xx: -(3 * d2 - 3 * d3), x: -(6 * d1 - 3 * d2 + 2 * d3), 1: -6 * f0 });
 }
 // The law a goal is of (the kernel names each goal after its law: '<law> @step').
 const lawOfGoal = (goal) => goal.replace(/ @(start|step|step law|\d+ steps|leaf|node)$/, '');
 const isGoalOf = (goal) => (c) => { const law = lawOfGoal(goal); return law === c.name || law === `${c.name} at y`; };
 const gcd = (a, b) => (b === 0 ? Math.abs(a) : gcd(b, a % b));
 // --- recurrences ---------------------------------------------------------------------------------------------------
-const showRecur = (a) => (a === 'f' ? 'f(x)' : a === 'g' ? 'f(y)' : a === 'xx' ? 'x·x' : a);
-const srcRecur = (a) => (a === 'xx' ? 'x.mul(x)' : a);
+const showRecur = (a) => (a === 'f' ? 'f(x)' : a === 'g' ? 'f(y)' : a === 'xx' ? 'x·x' : a === 'xxx' ? 'x·x·x' : a);
+const srcRecur = (a) => (a === 'xx' ? 'x.mul(x)' : a === 'xxx' ? 'x.mul(x).mul(x)' : a);
 // The function's values: x from 0 to 40 at a few values of each further argument (all of them for two at most).
 function recurSamples(d, args) {
     const f = (typeof d.js === 'function' ? d.js : compileFunction([], `return (${d.js})`)());
@@ -128,7 +136,7 @@ function recurSamples(d, args) {
                     break;
                 throw e;
             }
-            out.push({ x, f: y, xx: x * x, ...Object.fromEntries(args.map((a, i) => [a, t[i]])) });
+            out.push({ x, f: y, xx: x * x, xxx: x * x * x, ...Object.fromEntries(args.map((a, i) => [a, t[i]])) });
         }
     return out;
 }
@@ -167,9 +175,9 @@ function recurCands(samples, args) {
         c.name = nameOf(c, showRecur, 'g');
     return { lemmas, between };
 }
-const recurAtoms = (args, x, f, env, y, g) => ({ x, f, xx: x.mul(x), ...(y && g ? { y, g } : {}), ...Object.fromEntries(args.map(a => [a, env[a]])) });
+const recurAtoms = (args, x, f, env, y, g) => ({ x, f, xx: x.mul(x), xxx: x.mul(x).mul(x), ...(y && g ? { y, g } : {}), ...Object.fromEntries(args.map(a => [a, env[a]])) });
 const recurSrc = (c, args, between) => {
-    const reads = (a) => Object.keys(c.lin).includes(a) || (a === 'x' && 'xx' in c.lin);
+    const reads = (a) => Object.keys(c.lin).includes(a) || (a === 'x' && ('xx' in c.lin || 'xxx' in c.lin));
     const names = between ? ['x', 'f', 'y', 'g'] : ['x', 'f'];
     let unused = 0;
     const params = [...names.map(n => (reads(n) ? n : '_'.repeat(++unused))), ...(args.some(reads) ? [`{${args.filter(reads).join(', ')}}`] : [])];
@@ -268,27 +276,40 @@ function discoverSearch(r, laws, stepLaws, first) {
     if (first.proven && first.checked)
         return { verdict: first, rule: r, found: {} };
     const { params, fns, lists } = r.parts, ps = natParams(params);
-    // Per function and per list: what is proven, made into the rule.
-    const fnMade = {};
-    for (const [n, d] of fns) {
-        const src = recurOf(d);
-        if (!src)
-            continue;
-        const args = [...(src.def.args ?? [])], { lemmas, between } = recurCands(recurSamples(d, args), args);
-        const made = houdiniRecur(d, lemmas, between);
-        if (made && (made.lemmas.length || made.between.length))
-            fnMade[n] = made;
-    }
-    let rule = r.withParts(Object.fromEntries(Object.entries(fnMade).map(([n, m]) => [n, m.d])));
-    const listKept = {};
-    for (const part of lists) {
-        const out = houdiniList(rule, part, listCands(part, params, listSamples(part, params)), ps);
-        if (out && out.kept.length) {
-            rule = out.rule;
-            listKept[part[0]] = out.kept;
+    // Per function and per list: what is proven, made into the rule. A function with a closed form (of degree 2 or 3,
+    // fitted exactly) first with it alone: it decides the function, and the bounds beside it, which the closed form
+    // implies only through products, are slow to prove by induction; the rest where the laws aren't proven with it.
+    const cands = new Map(fns.flatMap(([n, d]) => { const src = recurOf(d); if (!src)
+        return []; const args = [...(src.def.args ?? [])]; return [[n, recurCands(recurSamples(d, args), args)]]; }));
+    const exact = (c) => c.rel === '=' && ('xx' in c.lin || 'xxx' in c.lin);
+    const makeFns = (closedOnly) => {
+        const out = {};
+        for (const [n, d] of fns) {
+            const cs = cands.get(n);
+            if (!cs)
+                continue;
+            const closed = cs.lemmas.filter(exact), made = closedOnly && closed.length ? houdiniRecur(d, closed, []) : houdiniRecur(d, cs.lemmas, cs.between);
+            if (made && (made.lemmas.length || made.between.length))
+                out[n] = made;
         }
-    }
-    const verdict = proveSteps(rule, laws, stepLaws, { search: false });
+        return out;
+    };
+    const withLists = (fnMade) => {
+        let rule = r.withParts(Object.fromEntries(Object.entries(fnMade).map(([n, m]) => [n, m.d])));
+        const listKept = {};
+        for (const part of lists) {
+            const out = houdiniList(rule, part, listCands(part, params, listSamples(part, params)), ps);
+            if (out && out.kept.length) {
+                rule = out.rule;
+                listKept[part[0]] = out.kept;
+            }
+        }
+        return { fnMade, rule, listKept, verdict: proveSteps(rule, laws, stepLaws, { search: false }) };
+    };
+    let made = [...cands.values()].some(cs => cs.lemmas.some(exact)) ? withLists(makeFns(true)) : undefined;
+    if (!made || !(made.verdict.proven && made.verdict.checked))
+        made = withLists(makeFns(false));
+    const { fnMade, rule, listKept, verdict } = made;
     const found = () => ({
         ...Object.fromEntries(Object.entries(fnMade).map(([n, m]) => { const args = [...(recurOf(m.d).def.args ?? [])]; return [n, { ...(m.lemmas.length ? { lemmas: m.lemmas.map(c => recurSrc(c, args, false)) } : {}), ...(m.between.length ? { between: m.between.map(c => recurSrc(c, args, true)) } : {}) }]; })),
         ...Object.fromEntries(Object.entries(listKept).map(([n, cs]) => [n, { lemmas: cs.map(c => listSrc(c, Object.keys(lists.find(l => l[0] === n)[2]), ps, c.target)) }])),

package/dist/core/dsl.d.ts

@@ -594,7 +594,7 @@ export declare class Rule<P extends Obj = {}, I extends Obj = {}, S extends Obj
     leadsTo(name: string, spec: {
         from: (env: P & S & M & Su) => Cond;
         to: (env: P & S & M & Su) => Cond;
-        rank: (env: P & S & M & Su) => TermLike | TermLike[];
+        rank?: (env: P & S & M & Su) => TermLike | TermLike[];
         helpful: ((env: P & S & M & Su) => Record<string, TermLike>) | {
             when?: (env: P & S & M & Su) => Cond;
             request: (env: P & S & M & Su) => Record<string, TermLike>;
@@ -828,7 +828,9 @@ export declare function proveRule(r: Rule<Obj, Obj, Obj, Obj, Obj, Obj, Obj, Obj
 export declare function proveSteps(r: Rule<Obj, Obj, Obj, Obj, Obj, Obj, Obj, Obj>, laws: Law[], stepLaws: StepLaw[], opts?: ProveOptions): Verdict;
 export type { StepLaw };
 export type { Liveness };
-export declare function proveLeadsTo(r: Rule<Obj, Obj, Obj, Obj, Obj, Obj, Obj, Obj>, laws: Law[], l: Liveness): Verdict;
+export declare function proveLeadsTo(r: Rule<Obj, Obj, Obj, Obj, Obj, Obj, Obj, Obj>, laws: Law[], l: Liveness, opts?: {
+    ms?: number;
+}): Verdict;
 export declare const proveDecision: (d: Decision) => Verdict;
 export declare function crossCheckDecision(d: Decision, opts?: {
     trials?: number;

package/dist/core/dsl.js

@@ -19,10 +19,10 @@ import { carriedView, compileFunction, evalC, evalE, interpret, loadJs, numbersO
 import { allowed, keysOf, requestEnv, watch } from "./watch.js";
 import { check, foldObligations, loopObligations } from "../kernel/kernel.js";
 import { factsFor, grow, proveLaws, proveLiveness, proveStepLaws, usualProof, withDeadline } from "../kernel/prove.js";
-import { certCyclic, certOn, crossCyclic, cyclicOn, cycLog, foldNodes, proveCyclic, quietly, recurNodes, translatedProof } from "./cyclic.js";
+import { certCyclic, certOn, crossCyclic, cyclicOn, foldNodes, proveCyclic, quietly, recurNodes, translatedProof, uncovered } from "./cyclic.js";
 import { discover } from "./discover.js";
 import { inferLaws } from "./infer.js";
-import { cycleLemmas, findRank } from "./cycles.js";
+import { cycleLemmas, findLeadsTo, findRank } from "./cycles.js";
 // --- terms and conditions -------------------------------------------------------------------------------------------
 const naturalConst = (v) => {
     if (!Number.isSafeInteger(v) || v < 0)
@@ -1430,8 +1430,12 @@ export const recur = (name, def, lemmas = {}, between = {}) => {
         lemmaProof = usualProof.last;
         if (cyclicOn())
             crossCyclic('recurrence', name, verdict.proven && verdict.checked, () => { const { facts, specs } = recurNodes(recurCase([])); return proveCyclic(facts, specs); }, performance.now() - t0, translatedRecur({ lemmas: lemmaProof }));
-        if (certOn() && verdict.proven && verdict.checked)
-            verdict = { ...verdict, checked: certCyclic('recurrence', name, translatedRecur({ lemmas: lemmaProof }), () => { const { facts, specs } = recurNodes(recurCase([])); return proveCyclic(facts, specs); }, performance.now() - t0).checked };
+        // (the usual trees checked already, inside quietly: where no cyclic proof is made they are the certificate)
+        if (certOn() && verdict.proven && verdict.checked) {
+            const c = certCyclic('recurrence', name, translatedRecur({ lemmas: lemmaProof }), () => { const { facts, specs } = recurNodes(recurCase([])); return proveCyclic(facts, specs); }, performance.now() - t0);
+            if (!c.checked)
+                uncovered('recurrence', name, c.why);
+        }
         failed('lemmas', verdict);
         proofs.lemmas = { machine: r.machine, laws };
     }
@@ -1472,8 +1476,11 @@ export const recur = (name, def, lemmas = {}, between = {}) => {
         const t0 = performance.now(), v = quietly(() => proveRule(r, laws, { search: false })), usualMs = performance.now() - t0, betweenProof = usualProof.last;
         if (cyclicOn())
             crossCyclic('recurrence, between', name, v.proven && v.checked, () => { const { facts, specs } = recurNodes(recurCase(pairs)); return proveCyclic(facts, specs); }, usualMs, betweenProof && translatedRecur({ lemmas: lemmaProof, between: betweenProof }));
-        if (certOn() && v.proven && v.checked)
-            v.checked = certCyclic('recurrence, between', name, betweenProof && translatedRecur({ lemmas: lemmaProof, between: betweenProof }), () => { const { facts, specs } = recurNodes(recurCase(pairs)); return proveCyclic(facts, specs); }, usualMs).checked;
+        if (certOn() && v.proven && v.checked) {
+            const c = certCyclic('recurrence, between', name, betweenProof && translatedRecur({ lemmas: lemmaProof, between: betweenProof }), () => { const { facts, specs } = recurNodes(recurCase(pairs)); return proveCyclic(facts, specs); }, usualMs);
+            if (!c.checked)
+                uncovered('recurrence, between', name, c.why);
+        }
         failed('laws between two points', v);
         proofs.between = { machine: r.machine, laws };
         verdict = { proven: true, checked: verdict.checked && v.checked };
@@ -1839,10 +1846,11 @@ export class Rule {
     //     rank: ({t, served}) => t.plus(1).minus(served), helpful: () => ({op: 1})})
     //   batches.leadsTo('every batch is done', {from: () => yes, to: ({waiting, items}) => waiting.eq(0).and(items.eq(0)),
     //     rank: ({waiting, items}) => [waiting, items], helpful: [{when: ({items}) => items.gt(0), request: () => ({op: 1})}, {when: ({items}) => items.eq(0), request: () => ({op: 0})}]})
+    // With no rank, proveLeadsTo finds one from the rule's runs (core/cycles.ts's findLeadsTo).
     leadsTo(name, spec) {
         const env = this.env({ flags: false, inputs: false, queries: false });
         const req = (f) => Object.fromEntries(Object.entries(f(env)).map(([n, t]) => [n, termOf(t)]));
-        const r = spec.rank(env), rank = Array.isArray(r) ? r.map(termOf) : termOf(r);
+        const r = spec.rank ? spec.rank(env) : [], rank = Array.isArray(r) ? r.map(termOf) : termOf(r);
         const base = { name, from: spec.from(env).c, to: spec.to(env).c, rank };
         return typeof spec.helpful === 'function' ? { ...base, request: req(spec.helpful) } : { ...base, helpful: spec.helpful.map(h => ({ ...(h.when ? { when: h.when(env).c } : {}), request: req(h.request) })) };
     }
@@ -2654,7 +2662,12 @@ function searched(r, laws, stepLaws, v, opts) {
     void _stats;
     return { ...verdict, found: { laws: found, ...(lemmas ? { lemmas } : {}) } };
 }
-export function proveLeadsTo(r, laws, l) {
+export function proveLeadsTo(r, laws, l, opts = {}) {
+    if (Array.isArray(l.rank) && !l.rank.length) {
+        const f = findLeadsTo(r.machine, withKinds(r, laws), l, { params: (rand, bound) => r.randomParams(rand, bound), input: (rand, bound, ps) => r.randomInput(rand, bound, ps) }, opts);
+        return { proven: f.proven, checked: f.checked, ...(f.goal ? { goal: f.goal, stuck: f.stuck } : {}), ...(f.witness ? { witness: f.witness } : {}), ...(f.why ? { why: f.why } : {}),
+            ...(f.found ? { found: { rank: f.found.rank, ...(f.laws?.length ? { laws: f.laws.map((law, i) => ({ law, text: f.found.laws[i] ?? law.name })) } : {}) } } : {}) };
+    }
     const out = proveLiveness(r.machine, withKinds(r, laws), l);
     return { proven: out.proven, checked: out.checked, ...(out.failed ? { goal: out.failed.goal, stuck: out.failed.stuck, ...(out.failed.witness ? { witness: out.failed.witness } : {}), ...(out.failed.why ? { why: out.failed.why } : {}) } : {}) };
 }
@@ -2691,7 +2704,7 @@ export function crossCheckDecision(d, opts = {}) {
 // needs (inferLaws), within `ms` (10 s); the verdict is the kernel's on the rank and the laws found, in `found`.
 export const proveLoop = (l, laws, opts = {}) => {
     if (cyclicOn() || certOn())
-        cycLog({ kind: 'loop', name: l.loop.name, uncovered: true, why: 'a claim about runs that never end' });
+        uncovered('loop', l.loop.name, 'a claim about runs that never end');
     if (l.hasRank)
         return goalsVerdict(loopObligations(l.loop, laws, l.rankTerms));
     const out = findRank(l.loop, laws, opts);
@@ -2813,12 +2826,18 @@ export class FoldRule {
 export const fold = (name) => new FoldRule({ name, params: [], inputs: [], pre: [], assume: [] });
 // A fold's laws proven over every tree (a rose fold's own laws, its children's lemmas, with them).
 export const proveFold = (f, laws) => {
-    // (GDP_CERT=cyclic: the certificate a cyclic proof, core/cyclic.ts's certCyclic, the usual trees its input)
+    // (by default the certificate a cyclic proof, core/cyclic.ts's certCyclic, the usual trees its input; where none is
+    // made, the usual trees checked)
     const all = [...(f.lemmas ?? []), ...laws], t0 = performance.now(), v = goalsVerdict(foldObligations(f.fold, all), !certOn()), usualMs = performance.now() - t0;
     if (cyclicOn())
         crossCyclic('fold', f.fold.name, v.proven && v.checked, () => { const { facts, specs } = foldNodes(f.fold, all); return proveCyclic(facts, specs); }, usualMs, v.trees && (st => translatedProof(() => JSON.stringify(['fold', f.fold, all]), () => foldNodes(f.fold, all, v.trees, st), st)));
-    if (certOn() && v.proven)
-        v.checked = certCyclic('fold', f.fold.name, v.trees && (st => translatedProof(() => JSON.stringify(['fold', f.fold, all]), () => foldNodes(f.fold, all, v.trees, st), st)), () => { const { facts, specs } = foldNodes(f.fold, all); return proveCyclic(facts, specs); }, usualMs).checked;
+    if (certOn() && v.proven) {
+        const c = certCyclic('fold', f.fold.name, v.trees && (st => translatedProof(() => JSON.stringify(['fold', f.fold, all]), () => foldNodes(f.fold, all, v.trees, st), st)), () => { const { facts, specs } = foldNodes(f.fold, all); return proveCyclic(facts, specs); }, usualMs);
+        if (!c.checked) {
+            uncovered('fold', f.fold.name, c.why);
+            v.checked = foldObligations(f.fold, all).every(g => v.trees?.[g.name] !== undefined && check(g, v.trees[g.name]));
+        }
+    }
     return v;
 };
 const asTerm = (t) => (t instanceof Term ? t : lit(t));

package/dist/core/solver.d.ts

@@ -50,5 +50,8 @@ export type Verdict = {
     kind: 'unknown';
     point?: Record<string, number>;
 };
+export declare const work: {
+    n: number;
+};
 export declare function solve(constraints: Constraint[], maxRows?: number): Verdict;
 export declare function refuteFast(constraints: Constraint[], maxRows?: number): Verdict | undefined;

package/dist/core/solver.js

@@ -56,7 +56,10 @@ const gcd = (a, b) => (b === 0 ? Math.abs(a) : gcd(b, a % b));
 const vars = (lin) => Object.keys(lin).filter(key => key !== '1');
 // maxRows: elimination can square the rows each round; past this many live rows, or a round that would make more than
 // five times as many before merging them, it gives up with `unknown`.
+// The rows the solver has read and made, which a counted search reads as its clock (kernel/prove.ts's `counted`).
+export const work = { n: 0 };
 export function solve(constraints, maxRows = 20_000) {
+    work.n += constraints.length;
     const steps = [];
     const lins = [];
     const push = (step, lin) => (steps.push(step), lins.push(lin), lins.length - 1);
@@ -173,6 +176,7 @@ export function solve(constraints, maxRows = 20_000) {
             break;
         if (choice.pos.length * choice.neg.length > 5 * maxRows)
             return { kind: 'unknown' };
+        work.n += choice.pos.length * choice.neg.length;
         exact &&= choice.isExact;
         eliminated.push({ x: choice.x, rows: [...choice.pos, ...choice.neg] });
         const next = rows.filter(r => (lins[r][choice.x] ?? 0) === 0);
@@ -295,6 +299,7 @@ export function refuteFast(constraints, maxRows = 2_000) {
                 z[j] -= T[r][j];
     const eps = 1e-9;
     for (let iter = 0; iter < 50 * (R + m); iter++) {
+        work.n += 1 + ((R * cols) >> 8);
         // Bland's rule: the first column with a negative reduced cost enters (no cycling on degenerate systems).
         let enter = -1;
         for (let j = 0; j < cols; j++)

package/dist/core/translate.js

@@ -1,8 +1,9 @@
 import { add, refuteFast, scale, solve } from "./solver.js";
 import { checkRefutation } from "./check.js";
 import { canon, canonFlip, columnTerm, factorsOf, isCell, isMonomial, leafConstraintsReusing, linear, substE, truth, withProducts } from "../kernel/kernel.js";
-import { cellProducts, grow } from "../kernel/prove.js";
+import { cellProducts, clock, grow } from "../kernel/prove.js";
 const omega = 'O$';
+const debugOn = () => !!globalThis.process?.env?.GDP_CYCLIC_DEBUG;
 // The kernel's product of two linear forms (kernel.ts's `times`): each monomial its factors sorted, joined by '*'.
 function times(a, b) {
     const out = [];
@@ -209,6 +210,10 @@ export function translate(part, whole, tree, ren0, st, until, pp = new Map(), wp
     }
     if (ok && checkRefutation(withProducts(rw, products, squares), leaf))
         return { leaf, ...(tree.products ? { products } : {}), ...(tree.squares ? { squares: squares } : {}) };
+    if (debugOn()) {
+        const missing = tree.leaf.flatMap(s => (s.kind === 'input' && s.index < rp.length && map(s.index) === undefined ? [s.index] : []));
+        console.error(`[leaf] ${whole.name}: ${ok ? 'rows found, refutation refused' : `${missing.length} rows missing`}${missing.slice(0, 3).map(i => `; ${JSON.stringify(rp[i].lin)} as ${JSON.stringify(ren(rp[i].lin, wp) ?? 'no form')}${rp[i].src ? ` (${JSON.stringify(rp[i].src)})` : ''}`).join('')}`);
+    }
     return close(whole, wp, st, until);
 }
 export function readsFirst(whole, reads, ren, inner, st, until, wp = new Map(), swaps = []) {
@@ -289,7 +294,8 @@ export function decide(whole, conds, inner, st, until, wp = new Map()) {
         const lin = atoms[0], id = canon(lin);
         st.splits++;
         const yes = decide(whole, conds.slice(i), inner, st, until, new Map(wp).set(id, { lin, holds: true }));
-        const no = yes && regrow(whole, new Map(wp).set(id, { lin, holds: false }), until);
+        // (the other side refuted by the node's rows as they are, a time below the steps before it say, before it is grown)
+        const np = new Map(wp).set(id, { lin, holds: false }), no = yes && (leafAt(whole, np, true, st) ?? regrow(whole, np, until));
         return yes && no ? { split: lin, yes, no } : undefined;
     }
     return inner(wp);
@@ -439,7 +445,7 @@ export function close(g, wp, st, until) {
     if (l)
         return l;
     const pick = choiceAtom(g, wp) ?? cellAtom(g, wp), om = pick ? undefined : omegaPair(g, wp), next = pick ?? om?.l;
-    if (next && performance.now() < until) {
+    if (next && clock() < until) {
         st.splits++;
         const id = canon(next), y = close(g, new Map(wp).set(id, { lin: next, holds: true }), st, until);
         const no = new Map(wp).set(id, { lin: next, holds: false }), n = y && (om?.q ? apart(g, no, next, om.q, st, until) : close(g, no, st, until));
@@ -509,7 +515,7 @@ export function carry(g, nFacts, nUses, st, until) {
     };
     const leafOf = (wp, solveIt) => leafAt(g, wp, solveIt, st), final = (wp) => close(g, wp, st, until);
     const node = (wp, guardsDone) => {
-        if (performance.now() > until)
+        if (clock() > until)
             return undefined;
         // A hypothesis false at the path: the law at t holds there, or a law it is carried from (its guard true) fails.
         if (truth(law, wp) === true || parts.some(p => (p.guard === undefined || truth(p.guard, wp) === true) && truth(p.concl, wp) === false))

package/dist/kernel/prove.d.ts

@@ -38,6 +38,9 @@ export type Outcome = {
     path: Path;
     why?: string;
 };
+export declare const clock: () => number;
+export declare function counted<T>(perMs: number, f: () => T): T;
+export declare const withinDeadline: (until: number) => number;
 export declare function withDeadline<T>(until: number, f: () => T): T;
 export declare function grow(goal: Goal, path?: Path, budget?: {
     nodes: number;

package/dist/kernel/prove.js

@@ -1,6 +1,6 @@
-import { add, k, refuteFast, scale, solve, sub, v } from "../core/solver.js";
+import { add, k, refuteFast, scale, solve, sub, v, work } from "../core/solver.js";
 import { checkRefutation } from "../core/check.js";
-import { allowNode, certCyclic, certMs, certOn, certSearch, closingInsts, crossCyclic, cyclicOn, cycLog, hasQuantified, machineNodes, proveCyclic, qflagNodes, reqTS, searchedStepNodes, skMachine, timedKind, withWitness, translatedProof, uncoveredWhy } from "../core/cyclic.js";
+import { allowNode, allowTranslated, certCyclic, certOn, certSearch, closingInsts, crossCyclic, cyclicOn, cycLog, hasQuantified, machineNodes, proveCyclic, reqTS, searchedStepNodes, skMachine, timedKind, withWitness, translatedProof, uncovered, uncoveredWhy } from "../core/cyclic.js";
 import { assumed, atomOf, boundOf, canon, canonFlip, columnTerm, decided, factorsOf, isCell, isMonomial, stepZone, check, checkLaws, checkStepLaws, historyMachine, leafConstraints, leafConstraintsReusing, reusing, linear, livenessHelpful, livenessParts, obligations, plainKey, progressObligations, stepLawObligations, trueC, truth, unreachable, witnessesOf, withProducts } from "./kernel.js";
 // The atoms the path leaves open, in evaluation order: deciding any of them makes progress.
 function openE(e, path, out) {
@@ -193,6 +193,28 @@ export const cellProducts = { on: false };
 // A deadline every goal grown inside `withDeadline` keeps, beside its own budget: a search that proves many things (core/
 // infer.ts, core/discover.ts, the search proveRule falls back on) bounds them all; a goal past it is left `unknown`.
 let deadline = Infinity;
+// The clock every budget here reads (grow's `until`, withDeadline's; core/cyclic.ts's and core/data.ts's searches): wall
+// time, or within `counted` the work the prover has done (the solver's rows read and made, each node's rows), `perMs`
+// units a millisecond, so that what a search's budget lets it try, and so its verdict, doesn't depend on the machine's
+// speed. A counted search inside another reads the outer's clock.
+let rate = 0;
+export const clock = () => (rate ? work.n / rate : performance.now());
+export function counted(perMs, f) {
+    if (rate)
+        return f();
+    const outer = deadline;
+    rate = perMs;
+    deadline = Infinity;
+    try {
+        return f();
+    }
+    finally {
+        rate = 0;
+        deadline = outer;
+    }
+}
+// A budget's end, within the deadline (a translation's own bound, core/cyclic.ts's, kept by the export's GDP_CERT_MS).
+export const withinDeadline = (until) => Math.min(until, deadline);
 export function withDeadline(until, f) {
     const outer = deadline;
     deadline = Math.min(outer, until);
@@ -205,7 +227,7 @@ export function withDeadline(until, f) {
 }
 // `units: false`: the goal's own order, no units first (a caller after a model, not a proof: a run guided by the
 // prover's witnesses, say, whose models units would steer).
-export function grow(goal, path = new Map(), budget = { nodes: 0, until: performance.now() + Math.max(20_000, 1_000 * goal.hyps.length) }) {
+export function grow(goal, path = new Map(), budget = { nodes: 0, until: clock() + Math.max(20_000, 1_000 * goal.hyps.length) }) {
     if (deadline < (budget.until ?? Infinity))
         budget.until = deadline;
     if (budget.units === false && unitsNow) {
@@ -263,11 +285,12 @@ function growPlain(goal, path, budget) {
         return { stuck: 'unknown', path, why: 'cap' };
     if (profile.on)
         profile.nodes++;
-    if (++budget.nodes > 200_000 || (budget.until !== undefined && performance.now() > budget.until))
+    if (++budget.nodes > 200_000 || (budget.until !== undefined && clock() > budget.until))
         return { stuck: 'unknown', path, why: outOfBudget(goal, budget.nodes > 200_000 ? 'nodes' : 'time', path.size) };
     // Rows that read a term column only once a cut has put one on the path; before, the rows a choice-free search uses
     // (what it saw before term columns), renumbered to the whole leaf's when a leaf is found.
     const full = timed(() => rowsAt(goal, path), ms => { profile.rowsMs += ms; });
+    work.n += 1 + full.length;
     const columns = [...path.values()].some(a => Object.keys(a.lin).some(key => key.startsWith('⟦')));
     const idx = full.flatMap((r, i) => (columns || !Object.keys(r.lin).some(key => key.startsWith('⟦')) ? [i] : []));
     const rows = idx.map(i => full[i]), at = (i) => (i < rows.length ? idx[i] : full.length + i - rows.length);
@@ -1362,16 +1385,14 @@ function proveLawsAsGiven(m, laws) {
             focus: [...(law.forall ? [`${law.forall}#`] : []), ...(law.keys ?? [])],
         });
     });
-    // (GDP_CERT=cyclic: a covered machine's certificate is its cyclic proof, core/cyclic.ts's certCyclic; the usual trees
-    // are its input, not checked again)
+    // (by default a covered machine's certificate is its cyclic proof, core/cyclic.ts's certCyclic, the usual trees its
+    // input, not checked again; where none is made, the usual trees are checked and the proof counted uncovered)
     // (what no instance covers, read only where a cyclic mode is on: the usual route's own proofs, inferLaws' trial ones
     // among them, do nothing more than before)
     // A machine with a history: its laws are its plain machine's (historyMachine; the record goals leaf goals beside them).
     const modes = cyclicOn() || certOn(), hist = modes && m.history ? historyMachine(m) : undefined, mc = hist ? hist.machine : m;
-    const why = modes ? uncoveredWhy(mc, laws) : undefined;
-    // (flags that hold at every key: searched, where GDP_CERT_SEARCH=1)
-    const q = why === 'a flag at every key' && certOn() && certSearch(), cert = certOn() && (!why || q);
-    usualCheck.on = !cert || q;
+    const why = modes ? uncoveredWhy(mc, laws) : undefined, cert = certOn() && !why;
+    usualCheck.on = !cert;
     const t0 = performance.now(), out = (() => { try {
         return proveThinned(m, laws, { ...instances });
     }
@@ -1381,31 +1402,35 @@ function proveLawsAsGiven(m, laws) {
     if (out.proof)
         usualProof.last = { m, laws, proof: out.proof };
     const inst = out.proof?.instances ?? instances;
-    const searched = () => { const { facts, specs } = q ? qflagNodes(mc, laws, inst) : machineNodes(mc, laws, inst); return proveCyclic(facts, specs); };
-    const translated = !q && out.proof ? ((st) => translatedProof(() => JSON.stringify(['machine', mc, laws, inst]), () => timedKind('instance', 0, () => machineNodes(mc, laws, inst, out.proof, st)), st)) : undefined;
+    const searched = () => { const { facts, specs } = machineNodes(mc, laws, inst); return proveCyclic(facts, specs); };
+    const translated = out.proof ? ((st) => translatedProof(() => JSON.stringify(['machine', mc, laws, inst]), () => timedKind('instance', 0, () => machineNodes(mc, laws, inst, out.proof, st)), st)) : undefined;
     if (cyclicOn()) {
-        if (!why)
-            crossCyclic('machine', m.name, out.proven && out.checked, searched, usualMs, translated);
+        const usual = out.proven && out.checked;
+        // (a history: its plain machine's cyclic proof, and its record goals as the leaf goals they are; a machine with flags
+        // that hold at every key the usual route doesn't prove: not searched, as before 0.19.0, a search there costs seconds)
+        const records = !hist || hist.goals.every(g => { const tr = out.proof?.trees[g.name] ?? (() => { const o = grow(g); return 'tree' in o ? o.tree : undefined; })(); return tr !== undefined && check(g, tr); });
+        const recordFails = () => ({ proven: false, checked: false, node: m.name, goal: 'a record goal', stuck: 'not proven' });
+        if (!why && (usual || !hasQuantified(mc)))
+            crossCyclic('machine', m.name, usual, records ? searched : recordFails, usualMs, records ? translated : undefined);
         else
-            cycLog({ kind: 'machine', name: m.name, usual: out.proven && out.checked, uncovered: true, why });
+            cycLog({ kind: 'machine', name: m.name, usual, uncovered: true, why: why ?? 'a flag at every key the usual route does not prove' });
     }
     if (cert && out.proven && out.proof) {
-        const until = performance.now() + certMs(), c = q ? withDeadline(until, () => certCyclic('machine', m.name, undefined, searched, usualMs)) : certCyclic('machine', m.name, translated, searched, usualMs);
-        if (q && !c.checked)
-            uncovered('machine', m.name, `${why}: no cyclic proof found${performance.now() > until ? ` within ${certMs()} ms` : ''}`);
-        else {
+        const c = certCyclic('machine', m.name, translated, searched, usualMs);
+        if (c.checked) {
             // (a history's record goals checked as they are: leaf goals)
-            const records = !hist || hist.goals.every(g => out.proof.trees[g.name] !== undefined && check(g, out.proof.trees[g.name]));
-            out.checked = c.checked && records;
+            out.checked = !hist || hist.goals.every(g => out.proof.trees[g.name] !== undefined && check(g, out.proof.trees[g.name]));
             Object.assign(out.proof, { cyclic: c.proof });
         }
+        else {
+            out.checked = checkLaws(m, laws, out.proof);
+            uncovered('machine', m.name, c.why);
+        }
     }
     else if (certOn() && why && out.proven)
         cycLog({ kind: 'machine', name: m.name, cert: true, uncovered: true, why });
     return out;
 }
-// A proof of a kind no cyclic instance covers, counted (`cyclic: {..., uncovered: true}`).
-const uncovered = (kind, name, why) => cycLog({ kind, name, uncovered: true, why });
 // Whether the usual proof's trees are checked (off while GDP_CERT=cyclic makes the certificate a cyclic proof).
 export const usualCheck = { on: true };
 // The last machine proof made (core/dsl.ts's recurrences read their machine's, to translate it: core/cyclic.ts).
@@ -1545,38 +1570,52 @@ function proveStepLawsAsGiven(m, laws, stepLaws, base) {
             leaves += countLeaves(out.tree);
         }
     const proof = { laws: base.proof, instances, ...(Object.keys(perStep).length ? { perStep } : {}), trees };
-    const out = { proven: true, nodes, leaves, checked: checkStepLaws(m, laws, stepLaws, proof), proof };
     // Step laws of a machine the cyclic instances cover (one step, or several over no map) are translated with the laws
     // (core/cyclic.ts); the rest are counted as no instance's.
-    if (!cyclicOn() && !certOn())
+    // (a machine with a history: its plain machine's; a flag at every key through its sk machine; k-step laws over a map
+    // searched, where GDP_CERT_SEARCH=1; where no cyclic proof is made the usual trees, checked above, stay the certificate)
+    const modes = cyclicOn() || certOn(), why = modes ? uncoveredWhy(plain, laws) : undefined, one = stepLaws;
+    // Where the cyclic certificate is made below (GDP_CERT, not the cross-check; the laws' certificate checked), the usual
+    // trees are its input, as a machine's laws' are: checkStepLaws (the laws' usual trees again, then the step laws') runs
+    // only where no certificate is made.
+    const byCert = certOn() && !cyclicOn() && !why && one.length > 0 && base.checked;
+    const out = { proven: true, nodes, leaves, checked: byCert || checkStepLaws(m, laws, stepLaws, proof), proof };
+    if (!modes)
         return out;
-    // (a machine with a history: its plain machine's; flags at every key and k-step laws over a map searched, where
-    // GDP_CERT_SEARCH=1)
-    const why = uncoveredWhy(plain, laws), one = stepLaws.filter(sl => (sl.steps ?? 1) === 1 || (!Object.keys(plain.maps ?? {}).length && !plain.inputMaps?.length));
     if (!why && one.length && out.checked) {
-        const steps = one.map(sl => { const inst = perStep[sl.name] ?? instances, goal = stepLawObligations(m, laws, inst, sl)[0]; return { sl, inst, goal, tree: trees[goal.name] }; });
-        const translated = (st) => translatedProof(() => JSON.stringify(['steps', plain, laws, base.proof.instances, steps.map(x => [x.sl, x.inst])]), reused => timedKind('instance', 0, () => machineNodes(plain, laws, base.proof.instances, { trees: base.proof.trees, steps, lawsMade: reused }, st)), st, () => JSON.stringify(['machine', plain, laws, base.proof.instances]));
+        const all = one.map(sl => { const inst = perStep[sl.name] ?? instances, goal = stepLawObligations(m, laws, inst, sl)[0]; return { sl, inst, goal, tree: trees[goal.name] }; });
+        const translatedOf = (steps) => (st) => translatedProof(() => JSON.stringify(['steps', plain, laws, base.proof.instances, steps.map(x => [x.sl, x.inst])]), reused => timedKind('instance', 0, () => machineNodes(plain, laws, base.proof.instances, { trees: base.proof.trees, steps, lawsMade: reused }, st)), st, () => JSON.stringify(['machine', plain, laws, base.proof.instances]));
         const usualMs = performance.now() - t0;
         if (cyclicOn())
-            crossCyclic('step law', m.name, true, undefined, usualMs, translated);
-        if (certOn())
-            out.checked = certCyclic('step law', m.name, translated, undefined, usualMs).checked;
+            crossCyclic('step law', m.name, true, undefined, usualMs, translatedOf(all));
+        // (where the step laws' proof together isn't made, each step law's alone: one the translation misses leaves the
+        // others theirs; and the usual trees, unchecked where the certificate was to be the verdict, are checked)
+        const together = certOn() ? certCyclic('step law', m.name, translatedOf(all), undefined, usualMs) : undefined;
+        if (together && !together.checked) {
+            if (byCert)
+                out.checked = checkStepLaws(m, laws, stepLaws, proof);
+            for (const x of all) {
+                const c = all.length > 1 ? certCyclic('step law', m.name, translatedOf([x]), undefined, usualMs) : together;
+                if (!c.checked)
+                    uncovered((x.sl.steps ?? 1) > 1 ? 'k-step law' : 'step law', m.name, c.why);
+            }
+        }
     }
-    const rest = stepLaws.filter(sl => why || !one.includes(sl));
-    if (certOn() && certSearch() && out.checked && rest.length && (!why || why === 'a flag at every key')) {
+    // (the rest: k steps over a map a request carries, or a machine no instance covers)
+    const rest = stepLaws.filter(sl => why || !one.includes(sl)), restWhy = (sl) => why ?? `${sl.steps} steps over a map a request carries`;
+    if (certOn() && certSearch() && out.checked && rest.length && !why) {
         // The rest searched: the laws' nodes (searched), each step law's node (core/cyclic.ts's stepLawNodes).
         const searchedSteps = () => {
-            const b = why ? qflagNodes(plain, laws, base.proof.instances) : machineNodes(plain, laws, base.proof.instances);
+            const b = machineNodes(plain, laws, base.proof.instances);
             return proveCyclic(b.facts, [...b.specs, ...searchedStepNodes(plain, laws, rest.map(sl => ({ law: sl, instances: perStep[sl.name] ?? instances })), b.facts, b.specs)]);
         };
-        const until = performance.now() + certMs(), c = withDeadline(until, () => certCyclic('step law', m.name, undefined, searchedSteps, performance.now() - t0));
-        const none = `no cyclic proof found${performance.now() > until ? ` within ${certMs()} ms` : ''}`;
+        const c = certCyclic('step law', m.name, undefined, searchedSteps, performance.now() - t0);
         for (const sl of c.checked ? [] : rest)
-            uncovered((sl.steps ?? 1) > 1 ? 'k-step law' : 'step law', m.name, `${why ?? `${sl.steps} steps over a map`}: ${none}`);
+            uncovered((sl.steps ?? 1) > 1 ? 'k-step law' : 'step law', m.name, `${restWhy(sl)}: ${c.why}`);
     }
     else if (cyclicOn() || certOn())
         for (const sl of rest)
-            uncovered((sl.steps ?? 1) > 1 ? 'k-step law' : 'step law', m.name, why ?? `${sl.steps} steps over a map`);
+            uncovered((sl.steps ?? 1) > 1 ? 'k-step law' : 'step law', m.name, restWhy(sl));
     return out;
 }
 // Progress (kernel.ts's progressObligations): the laws proven first, then each goal, the every-key laws assumed at every
@@ -1598,20 +1637,26 @@ export function proveProgress(m, laws, p) {
         leaves += countLeaves(out.tree);
     }
     const checked = progressObligations(m, ls, instances, p).every(g => check(g, trees[g.name]));
-    // (GDP_CERT=cyclic with GDP_CERT_SEARCH=1: a request allowed whose claim is that alone, over a machine without a history
-    // or carried maps, gets core/cyclic.ts's allowNode after the laws' nodes, BridgeRules.lean's cycAOk: from every
-    // reachable state, every request meeting the region, its terms and the witnesses withWitness finds is allowed)
+    // (a request allowed whose claim is that alone, over a machine without a history or carried maps: the laws' nodes,
+    // then the allowed goal translated, core/cyclic.ts's allowTranslated, its last node BridgeRules.lean's cycAOk: from
+    // every reachable state, every request meeting the region and its terms is allowed; where GDP_CERT_SEARCH=1 and that
+    // isn't proven, allowNode searched with the witnesses withWitness finds)
     const alone = JSON.stringify(p.then) === JSON.stringify(trueC) && !m.history && !m.inputMaps?.length && m.assume !== undefined;
-    if (certOn() && certSearch() && alone && checked && base.proof) {
-        const until = performance.now() + certMs(), lp = base.proof, q = hasQuantified(m);
+    if (certOn() && alone && checked && base.proof) {
+        const lp = base.proof, q = hasQuantified(m), goal = progressObligations(m, ls, instances, p)[0];
+        const translated = (st) => translatedProof(() => JSON.stringify(['allowed', m, ls, lp.instances, instances, p]), reused => {
+            const b = machineNodes(m, ls, lp.instances, { ...lp, lawsMade: reused }, st);
+            if (b.why)
+                return b;
+            const a = allowTranslated(m, ls, instances, p, { goal, tree: trees[goal.name] }, b.facts, b.specs, `${m.name}: allowed`, st);
+            return a.why ? { facts: b.facts, specs: [], why: a.why } : { facts: b.facts, specs: [...b.specs, ...a.specs] };
+        }, st, () => JSON.stringify(['machine', m, ls, lp.instances]));
         const allowed = () => {
-            const b = q ? qflagNodes(m, ls, lp.instances) : machineNodes(m, ls, lp.instances, lp);
+            const b = machineNodes(m, ls, lp.instances, lp);
             if (b.why || (b.specs[0]?.rank.length ?? 2) < 2)
                 return { proven: false, checked: false, node: m.name, goal: 'allowed', stuck: b.why ?? 'laws ranked by time alone' };
             let last = { proven: false, checked: false, node: m.name, goal: 'allowed', stuck: 'no witness' };
             const found = withWitness(m, p.request, wit => {
-                if (performance.now() > until)
-                    return undefined;
                 const w = { op: 'and', xs: [p.when, reqTS(Object.entries(p.request)), reqTS(wit)] };
                 const spec = allowNode(skMachine(m), ls, instances, w, b.facts, b.specs, `${m.name}: allowed`, q ? closingInsts(m, b.facts, [instances, ...Object.values(lp.instances)], [{ op: 'var', name: 't$' }], ls) : []);
                 last = proveCyclic(b.facts, [...b.specs, spec]);
@@ -1619,9 +1664,9 @@ export function proveProgress(m, laws, p) {
             });
             return found?.out ?? last;
         };
-        const c = withDeadline(until, () => certCyclic('progress', m.name, undefined, allowed, performance.now() - t0));
+        const c = certCyclic('progress', m.name, translated, certSearch() ? allowed : undefined, performance.now() - t0);
         if (!c.checked)
-            uncovered('progress', m.name, `a request allowed: no cyclic proof found${performance.now() > until ? ` within ${certMs()} ms` : ''}`);
+            uncovered('progress', m.name, `a request allowed: ${c.why}`);
     }
     else if (cyclicOn() || certOn())
         uncovered('progress', m.name, alone ? 'a request allowed' : 'a request allowed and a claim after it');