gdp-wired 0.18.0 → 0.19.0

package/dist/kernel/prove.js

@@ -1,6 +1,6 @@
 import { add, k, refuteFast, scale, solve, sub, v } from "../core/solver.js";
 import { checkRefutation } from "../core/check.js";
-import { crossCyclic, cyclicMachine, cyclicOn, machineNodes, proveCyclic } from "../core/cyclic.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 { 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) {
@@ -1362,15 +1362,54 @@ function proveLawsAsGiven(m, laws) {
             focus: [...(law.forall ? [`${law.forall}#`] : []), ...(law.keys ?? [])],
         });
     });
-    const t0 = performance.now(), out = proveThinned(m, laws, { ...instances }), usualMs = performance.now() - t0;
+    // (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)
+    // (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 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 } = 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;
     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);
+        if (!why)
+            crossCyclic('machine', m.name, out.proven && out.checked, searched, usualMs, translated);
         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: out.proven && out.checked, uncovered: true, why });
+    }
+    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 {
+            // (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;
+            Object.assign(out.proof, { cyclic: c.proof });
+        }
     }
+    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).
+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 +1455,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 +1470,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 +1490,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 +1545,44 @@ 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 };
+    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())
+        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 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;
+    }
+    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 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);
+            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` : ''}`;
+        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}`);
+    }
+    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`);
+    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 +1597,42 @@ 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]));
+    // (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)
+    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);
+        const allowed = () => {
+            const b = q ? qflagNodes(m, ls, lp.instances) : 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]);
+                return last.proven && last.checked ? last : undefined;
+            });
+            return found?.out ?? last;
+        };
+        const c = withDeadline(until, () => certCyclic('progress', m.name, undefined, allowed, performance.now() - t0));
+        if (!c.checked)
+            uncovered('progress', m.name, `a request allowed: no cyclic proof found${performance.now() > until ? ` within ${certMs()} ms` : ''}`);
+    }
+    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

@@ -101,6 +101,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 +201,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;