gdp-wired 0.18.0 → 0.19.0

package/dist/core/dsl.js

@@ -18,8 +18,8 @@
 import { carriedView, compileFunction, evalC, evalE, interpret, loadJs, numbersOf, pairedArgs } from "./machine.js";
 import { allowed, keysOf, requestEnv, watch } from "./watch.js";
 import { check, foldObligations, loopObligations } from "../kernel/kernel.js";
-import { factsFor, grow, proveLaws, proveLiveness, proveStepLaws, withDeadline } from "../kernel/prove.js";
-import { crossCyclic, cyclicOn, foldNodes, proveCyclic, quietly, recurNodes } from "./cyclic.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 { discover } from "./discover.js";
 import { inferLaws } from "./infer.js";
 import { cycleLemmas, findRank } from "./cycles.js";
@@ -1410,6 +1410,10 @@ export const recur = (name, def, lemmas = {}, between = {}) => {
     // The lemmas: x counting up from 0 and fx its value, each lemma a law of that machine.
     let verdict = { proven: true, checked: true };
     const proofs = {};
+    // The usual proofs, to translate (core/cyclic.ts's recurNodes): the lemmas' machine's, the laws between's.
+    let lemmaProof;
+    const translatedRecur = (u) => (u.lemmas || !stated.length)
+        ? st => translatedProof(() => JSON.stringify(['recurrence', recurCase(u.between ? pairs : [])]), () => recurNodes(recurCase(u.between ? pairs : []), u, st), st) : undefined;
     if (stated.length) {
         // A start that reads a function is a param given as that start by a fact (a start reads the params alone).
         const zeroReads = JSON.stringify(zero).includes('"op":"get"');
@@ -1421,9 +1425,13 @@ export const recur = (name, def, lemmas = {}, between = {}) => {
         const laws = Object.entries(lemmas).map(([n, f]) => r.law(n, (env) => f(env.x, env.fx, envAt(args.map(a => env[a])))));
         // (Its machine's proof timed alone: the recurrence is compared below as its own instance.)
         const t0 = performance.now();
+        usualProof.last = undefined;
         verdict = quietly(() => proveRule(r, laws, { search: false }));
+        lemmaProof = usualProof.last;
         if (cyclicOn())
-            crossCyclic('recurrence', name, verdict.proven && verdict.checked, () => { const { facts, specs } = recurNodes(recurCase([])); return proveCyclic(facts, specs); }, performance.now() - t0);
+            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 };
         failed('lemmas', verdict);
         proofs.lemmas = { machine: r.machine, laws };
     }
@@ -1460,9 +1468,12 @@ export const recur = (name, def, lemmas = {}, between = {}) => {
             .step((env) => ({ y: env.y.plus(1), fy: def.next(env.y, env.fy, envAt(at(env))) }));
         const laws = [...Object.entries(lemmas).map(([n, l]) => r.law(`${n} at y`, (env) => l(env.y, env.fy, envAt(at(env))))),
             ...Object.entries(between).map(([n, l]) => r.law(n, (env) => l(env.x, env.fx, env.y, env.fy, envAt(at(env)))))];
-        const t0 = performance.now(), v = quietly(() => proveRule(r, laws, { search: false })), usualMs = performance.now() - t0;
+        usualProof.last = undefined;
+        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);
+            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;
         failed('laws between two points', v);
         proofs.between = { machine: r.machine, laws };
         verdict = { proven: true, checked: verdict.checked && v.checked };
@@ -2504,7 +2515,7 @@ export class Unproven extends Error {
         this.verdict = verdict;
     }
 }
-const goalsVerdict = (goals) => {
+const goalsVerdict = (goals, checkIt = true) => {
     const trees = {};
     for (const g of goals) {
         const out = grow(g);
@@ -2512,7 +2523,7 @@ const goalsVerdict = (goals) => {
             return { proven: false, checked: false, goal: g.name, stuck: out.stuck, ...(out.witness ? { witness: out.witness } : {}), ...(out.why ? { why: out.why } : {}) };
         trees[g.name] = out.tree;
     }
-    return { proven: true, checked: goals.every(g => check(g, trees[g.name])), trees };
+    return { proven: true, checked: !checkIt || goals.every(g => check(g, trees[g.name])), trees };
 };
 // The kinds' laws first, those the caller didn't pass already (by name).
 const withKinds = (r, laws) => [...r.kindLaws().filter(k => !laws.some(l => l.name === k.name)), ...laws];
@@ -2679,6 +2690,8 @@ export function crossCheckDecision(d, opts = {}) {
 // With no rank stated, the rank is searched for from the loop's runs (core/cycles.ts's findRank), with the invariants it
 // 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' });
     if (l.hasRank)
         return goalsVerdict(loopObligations(l.loop, laws, l.rankTerms));
     const out = findRank(l.loop, laws, opts);
@@ -2800,9 +2813,12 @@ 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) => {
-    const all = [...(f.lemmas ?? []), ...laws], t0 = performance.now(), v = goalsVerdict(foldObligations(f.fold, all)), usualMs = performance.now() - t0;
+    // (GDP_CERT=cyclic: the certificate a cyclic proof, core/cyclic.ts's certCyclic, the usual trees its input)
+    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);
+        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;
     return v;
 };
 const asTerm = (t) => (t instanceof Term ? t : lit(t));

package/dist/core/translate.d.ts

@@ -0,0 +1,30 @@
+import type { C, E } from './machine.js';
+import { type Lin } from './solver.js';
+import { type Goal, type Path, type Subst, type Tree } from '../kernel/kernel.js';
+export type Rename = {
+    s: Subst;
+    cells?: Record<string, {
+        to: string;
+        at: E;
+    }>;
+};
+export type Renamer = (lin: Lin, wp: Path) => Lin | undefined;
+export declare function renamer(r: Rename): Renamer;
+export type TStats = {
+    leaves: number;
+    regrown: number;
+    splits: number;
+    carried: number;
+    uncarried: number;
+    cached: number;
+};
+export declare const tstats: () => TStats;
+export declare function translate(part: Goal, whole: Goal, tree: Tree, ren0: Renamer, st: TStats, until: number, pp?: Path, wp?: Path, swaps?: [string, string][]): Tree | undefined;
+export type Reads = {
+    k: E;
+    w: E;
+}[];
+export declare function readsFirst(whole: Goal, reads: Reads, ren: Renamer, inner: (wp: Path, swaps: [string, string][]) => Tree | undefined, st: TStats, until: number, wp?: Path, swaps?: [string, string][]): Tree | undefined;
+export declare function decide(whole: Goal, conds: C[], inner: (wp: Path) => Tree | undefined, st: TStats, until: number, wp?: Path): Tree | undefined;
+export declare function close(g: Goal, wp: Path, st: TStats, until: number): Tree | undefined;
+export declare function carry(g: Goal, nFacts: number, nUses: number, st: TStats, until: number): Tree | undefined;