gdp-wired 0.18.0 → 0.20.0

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 { crossCyclic, cyclicMachine, cyclicOn, machineNodes, proveCyclic } 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,15 +1385,56 @@ function proveLawsAsGiven(m, laws) {
             focus: [...(law.forall ? [`${law.forall}#`] : []), ...(law.keys ?? [])],
         });
     });
-    const t0 = performance.now(), out = proveThinned(m, laws, { ...instances }), usualMs = performance.now() - t0;
+    // (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, cert = certOn() && !why;
+    usualCheck.on = !cert;
+    const t0 = performance.now(), out = (() => { try {
+        return proveThinned(m, laws, { ...instances });
+    }
+    finally {
+        usualCheck.on = true;
+    } })(), usualMs = performance.now() - t0;
+    if (out.proof)
+        usualProof.last = { m, laws, proof: out.proof };
+    const inst = out.proof?.instances ?? instances;
+    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 (cyclicMachine(m, laws))
-            crossCyclic('machine', m.name, out.proven && out.checked, () => { const { facts, specs } = machineNodes(m, laws, instances); return proveCyclic(facts, specs); }, usualMs);
+        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
-            console.error(`cyclic: ${JSON.stringify({ kind: 'machine', name: m.name, usual: out.proven && out.checked, uncovered: true })}`);
+            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 c = certCyclic('machine', m.name, translated, searched, usualMs);
+        if (c.checked) {
+            // (a history's record goals checked as they are: leaf goals)
+            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;
 }
+// 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).
+export const usualProof = {};
 // Each law with its instances thinned (`triggered`) where that proves it, else with all of them.
 function proveThinned(m, laws, instances) {
     const trees = {}, fulls = { ...instances };
@@ -1416,7 +1480,7 @@ function proveThinned(m, laws, instances) {
         leaves += countLeaves(out.tree);
     }
     const proof = { instances, trees };
-    return { proven: true, nodes, leaves, checked: checkLaws(m, laws, proof), proof };
+    return { proven: true, nodes, leaves, checked: !usualCheck.on || checkLaws(m, laws, proof), proof };
 }
 // Every goal of the laws with these instances.
 function proveWith(m, laws, instances) {
@@ -1431,7 +1495,7 @@ function proveWith(m, laws, instances) {
         leaves += countLeaves(out.tree);
     }
     const proof = { instances, trees };
-    return { proven: true, nodes, leaves, checked: checkLaws(m, laws, proof), proof };
+    return { proven: true, nodes, leaves, checked: !usualCheck.on || checkLaws(m, laws, proof), proof };
 }
 export function proveStepLaws(m, given, stepLaws) {
     const base = proveLaws(m, given);
@@ -1451,6 +1515,7 @@ export function proveStepLaws(m, given, stepLaws) {
 function proveStepLawsAsGiven(m, laws, stepLaws, base) {
     if (!base.proof)
         return { proven: false, nodes: base.nodes, leaves: base.leaves, checked: false };
+    const t0 = performance.now();
     const plain = m.history ? historyMachine(m).machine : m;
     // Each step law its own instances, from its own goal: the keys the step and the laws read, and its own (a k-step
     // law's later frames read keys no other step law has); where positions shift or a law is about several keys, the
@@ -1505,12 +1570,58 @@ function proveStepLawsAsGiven(m, laws, stepLaws, base) {
             leaves += countLeaves(out.tree);
         }
     const proof = { laws: base.proof, instances, ...(Object.keys(perStep).length ? { perStep } : {}), trees };
-    return { 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.
+    // (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;
+    if (!why && one.length && out.checked) {
+        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, 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);
+            }
+        }
+    }
+    // (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 = 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 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, `${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, restWhy(sl));
+    return out;
 }
 // Progress (kernel.ts's progressObligations): the laws proven first, then each goal, the every-key laws assumed at every
 // key the goals read a map at.
 export function proveProgress(m, laws, p) {
-    const base = proveLaws(m, laws);
+    const t0 = performance.now(), base = proveLaws(m, laws);
     if (!base.proven || !base.checked)
         return { proven: false, nodes: base.nodes, leaves: base.leaves, ...(base.failed ? { failed: base.failed } : {}), checked: false };
     const ls = base.laws ?? laws;
@@ -1525,12 +1636,48 @@ export function proveProgress(m, laws, p) {
         nodes += out.nodes;
         leaves += countLeaves(out.tree);
     }
-    return { proven: true, nodes, leaves, checked: progressObligations(m, ls, instances, p).every(g => check(g, trees[g.name])), instances, trees };
+    const checked = progressObligations(m, ls, instances, p).every(g => check(g, trees[g.name]));
+    // (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() && 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 = 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 => {
+                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]);
+                return last.proven && last.checked ? last : undefined;
+            });
+            return found?.out ?? last;
+        };
+        const c = certCyclic('progress', m.name, translated, certSearch() ? allowed : undefined, performance.now() - t0);
+        if (!c.checked)
+            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');
+    return { proven: true, nodes, leaves, checked, instances, trees };
 }
 // Liveness (kernel.ts's livenessParts): its step laws, proven together. The claim needs no more (a run takes the
 // request, so it is allowed); but a request never allowed would leave the claim about no run, so where a helpful request
 // names every input a client sends and carries no maps, it is proven allowed in its region too.
 export function proveLiveness(m, laws, l) {
+    if (cyclicOn() || certOn())
+        uncovered('liveness', m.name, 'a claim about runs that never end');
     const { stay, cover, helps } = livenessParts(m, l);
     const a = proveStepLaws(m, laws, [stay, cover, ...helps]);
     if (!a.proven || !a.checked)

package/dist/lean-kernel/emit.d.ts

@@ -16,8 +16,9 @@ export declare function leaves(t: Tree, path: Path, visit: (t: Tree & {
     products?: [number, number][];
     squares?: Lin[];
 }, path: Path) => void): void;
-export declare function encode(ex: Exported, tamper?: boolean, dropStep?: boolean, globalVars?: string[], globalMaps?: string[]): {
+export declare function encode(ex: Exported, tamper?: boolean, dropStep?: boolean, globalVars?: string[], globalMaps?: string[], slim?: boolean): {
     tab: string;
+    tabCols: string[];
     hyps: string;
     tree: string;
     cols: string[];
@@ -101,6 +102,39 @@ export declare function smachineToLean(id: string, given: Machine, laws: Law[],
     };
     noFacts?: boolean;
 }): string;
+export declare const cyclicCerts: () => boolean;
+export declare const certReport: {
+    cyclic: string[];
+    usual: {
+        id: string;
+        why: string;
+    }[];
+    translatedSteps: string[];
+};
+export declare function cycMachineToLean(id: string, given: Machine, laws: Law[], opts?: {
+    stepLaws?: StepLaw[];
+    liveness?: Liveness[];
+    simp?: string[];
+    free?: string[];
+    ghosts?: string[];
+    after?: (ix: (name: string) => number) => string;
+    loop?: {
+        loop: Loop;
+    };
+    noFacts?: boolean;
+    refined?: {
+        impl: Machine;
+        spec: Machine;
+        wit: Record<string, E>;
+        stutter: C;
+        specPre: number;
+        step: StepLaw;
+    };
+}): {
+    text: string;
+} | {
+    why: string;
+};
 type Uses = Record<string, {
     lean?: string;
     recur?: Recurrence;
@@ -168,6 +202,7 @@ export type LeanItem = {
 export declare function toLean(items: LeanItem[], opts?: {
     title?: string;
     native?: boolean;
+    cyclic?: boolean;
 }): string;
 export declare function leanProject(file: string, opts?: {
     name?: string;