gdp-wired 0.17.0 → 0.19.0

package/dist/core/dsl.d.ts

@@ -781,6 +781,7 @@ export declare class LoopRule<P extends Obj = {}, I extends Obj = {}, S extends
     law(name: string, f: (env: P & S) => Cond): Law;
     private env;
     get loop(): Loop;
+    get hasRank(): boolean;
     get rankTerms(): E[];
     randomParams(rand: Rand, bound: number): Record<string, number>;
     randomInput(rand: Rand, bound: number): Record<string, number>;
@@ -810,10 +811,13 @@ export type Found = {
         lemmas?: string[];
         between?: string[];
     }>;
+    facts?: string[];
+    rank?: string;
 };
 export type ProveOptions = {
     search?: boolean | {
         ms?: number;
+        cycles?: boolean;
     };
 };
 export declare class Unproven extends Error {
@@ -834,7 +838,9 @@ export declare function crossCheckDecision(d: Decision, opts?: {
     checked: number;
     failure?: string;
 };
-export declare const proveLoop: (l: LoopRule<Obj, Obj, Obj>, laws: Law[]) => Verdict;
+export declare const proveLoop: (l: LoopRule<Obj, Obj, Obj>, laws: Law[], opts?: {
+    ms?: number;
+}) => Verdict;
 export type TreeValue<I> = {
     leaf: I;
 } | {

package/dist/core/dsl.js

@@ -18,10 +18,11 @@
 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";
 // --- terms and conditions -------------------------------------------------------------------------------------------
 const naturalConst = (v) => {
     if (!Number.isSafeInteger(v) || v < 0)
@@ -1409,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"');
@@ -1420,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 };
     }
@@ -1459,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 };
@@ -2483,6 +2495,7 @@ export class LoopRule {
             ...(assume.length ? { assume: assume.length === 1 ? assume[0] : { op: 'and', xs: assume } } : {}),
         };
     }
+    get hasRank() { return !!this.spec.rank; }
     get rankTerms() {
         if (!this.spec.rank)
             throw new Error(`${this.spec.name}: no rank`);
@@ -2502,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);
@@ -2510,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];
@@ -2624,6 +2637,13 @@ function searched(r, laws, stepLaws, v, opts) {
         if (Object.keys(d.found).length)
             (rule = d.rule, lemmas = d.found);
     }
+    // Functions known by their facts alone (not a recurrence): lemmas about them, fitted to their values and proven from
+    // the facts as cyclic claims, the laws proven with them as facts.
+    if ((typeof opts.search !== 'object' || opts.search.cycles !== false) && fns.some(([, d]) => !recurOf(d)) && rule.machine.facts?.length && until - performance.now() > 500) {
+        const c = withDeadline(until, () => cycleLemmas(rule.machine, withKinds(rule, laws), stepLaws, { ms: (until - performance.now()) / 2 }));
+        if (c.proven && c.checked)
+            return { proven: true, checked: true, found: { ...(lemmas ? { lemmas } : {}), facts: c.found.map(f => f.text) } };
+    }
     const ms = until - performance.now();
     if (ms < 500)
         return v;
@@ -2667,7 +2687,17 @@ export function crossCheckDecision(d, opts = {}) {
     }
     return { checked };
 }
-export const proveLoop = (l, laws) => goalsVerdict(loopObligations(l.loop, laws, l.rankTerms));
+// 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);
+    return { proven: out.proven, checked: out.checked, ...(out.trees ? { trees: out.trees } : {}), ...(out.goal ? { goal: out.goal, stuck: out.stuck } : {}), ...(out.witness ? { witness: out.witness } : {}), ...(out.why ? { why: out.why } : {}),
+        ...(out.found ? { found: { rank: out.found.rank, ...(out.laws?.length ? { laws: out.laws.map((law, i) => ({ law, text: out.found.laws[i] ?? law.name })) } : {}) } } : {}) };
+};
 export class FoldRule {
     spec;
     constructor(spec) {
@@ -2783,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;