gdp-wired 0.16.0 → 0.18.0

package/dist/core/discover.js

@@ -10,6 +10,7 @@
 //   const out = discover(r, laws, stepLaws)
 //   out.verdict          // the laws, proven of out.rule: r with its functions and lists made again with the lemmas
 //   out.found            // per function or list, the lemmas found, as source to paste into recur(...) or carriesList(...)
+import { quietly } from "./cyclic.js";
 import { any, atMost, compileFunction, evalC, evalE, n, plus, prod, same, times, x } from "./machine.js";
 import { Unproven, lit, proveFold, proveSteps, recur, recurOf } from "./dsl.js";
 const seeded = (seed) => { let s = seed; return (k) => { s = (s * 1103515245 + 12345) % 2 ** 31; return Math.floor(s / 2 ** 31 * k); }; };
@@ -260,7 +261,10 @@ function houdiniList(r, part, cands, params) {
 // The laws of r, and where they aren't proven as r states them, the lemmas found for its functions and lists: all that
 // is proven first, then each dropped in turn while the laws stay proven without it.
 // `first`: the laws' verdict on r alone, when the caller has it.
-export function discover(r, laws, stepLaws = [], first = proveSteps(r, laws, stepLaws, { search: false })) {
+export function discover(r, laws, stepLaws = [], first) {
+    return quietly(() => discoverSearch(r, laws, stepLaws, first ?? proveSteps(r, laws, stepLaws, { search: false })));
+}
+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);
@@ -405,7 +409,8 @@ const eOfSide = (side) => {
     return es.length ? es.slice(1).reduce((acc, t) => plus(acc, t), es[0]) : n(0);
 };
 const cOfCand = (c) => { const { pos, neg } = sides(c.lin), a = eOfSide(pos), b = eOfSide(neg); return c.rel === '=' ? same(a, b) : atMost(a, b); };
-export function discoverFold(f, laws) {
+export function discoverFold(f, laws) { return quietly(() => discoverFoldSearch(f, laws)); }
+function discoverFoldSearch(f, laws) {
     const stated = f.lemmas ?? [], first = proveFold({ fold: f.fold, lemmas: stated }, laws);
     if (first.proven && first.checked)
         return { verdict: first, lemmas: [], found: [] };

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,9 +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 } from "../kernel/prove.js";
+import { factsFor, grow, proveLaws, proveLiveness, proveStepLaws, withDeadline } from "../kernel/prove.js";
+import { crossCyclic, cyclicOn, foldNodes, proveCyclic, quietly, recurNodes } 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)
@@ -1399,6 +1401,10 @@ export const recur = (name, def, lemmas = {}, between = {}) => {
     const stated = Object.entries(lemmas).map(([n, f]) => { const holds = f(named('x'), named('fx'), envAt(own)).c; only(`lemma "${n}"`, holds, ['x', 'fx', ...args], uses.map(([u]) => u)); return { name: n, holds }; });
     const pairs = Object.entries(between).map(([n, f]) => { const holds = f(named('x'), named('fx'), named('y'), named('fy'), envAt(own)).c; only(`law between "${n}"`, holds, ['x', 'fx', 'y', 'fy', ...args], uses.map(([u]) => u)); return { name: n, holds }; });
     const argKinds = Object.fromEntries(args.map(a => [a, nat]));
+    // The recurrence as a cyclic proof's instance (core/cyclic.ts, GDP_CYCLIC=1): the facts of the functions it reads, from
+    // a rule that reads them.
+    const recurCase = (between) => ({ name, args, zero, next, lemmas: stated, between,
+        facts: uses.length ? rule(`${name}'s functions`).fns(def.fns ?? {}).inputs({}).state({ z: 0 }).step((env) => ({ z: env.z })).machine.facts ?? [] : [] });
     const failed = (what, v) => { if (!(v.proven && v.checked))
         throw new Unproven(`${name}'s ${what}`, v); };
     // The lemmas: x counting up from 0 and fx its value, each lemma a law of that machine.
@@ -1413,7 +1419,11 @@ export const recur = (name, def, lemmas = {}, between = {}) => {
         const r = r0.state({ x: 0, fx: ((p) => (zeroReads ? p.fx0 : zeroAt(args.map(a => p[a])))) })
             .step((env) => ({ x: env.x.plus(1), fx: def.next(env.x, env.fx, envAt(args.map(a => env[a]))) }));
         const laws = Object.entries(lemmas).map(([n, f]) => r.law(n, (env) => f(env.x, env.fx, envAt(args.map(a => env[a])))));
-        verdict = proveRule(r, laws, { search: false });
+        // (Its machine's proof timed alone: the recurrence is compared below as its own instance.)
+        const t0 = performance.now();
+        verdict = quietly(() => proveRule(r, laws, { search: false }));
+        if (cyclicOn())
+            crossCyclic('recurrence', name, verdict.proven && verdict.checked, () => { const { facts, specs } = recurNodes(recurCase([])); return proveCyclic(facts, specs); }, performance.now() - t0);
         failed('lemmas', verdict);
         proofs.lemmas = { machine: r.machine, laws };
     }
@@ -1450,7 +1460,9 @@ 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 v = proveRule(r, laws, { search: false });
+        const t0 = performance.now(), v = quietly(() => proveRule(r, laws, { search: false })), usualMs = performance.now() - t0;
+        if (cyclicOn())
+            crossCyclic('recurrence, between', name, v.proven && v.checked, () => { const { facts, specs } = recurNodes(recurCase(pairs)); return proveCyclic(facts, specs); }, usualMs);
         failed('laws between two points', v);
         proofs.between = { machine: r.machine, laws };
         verdict = { proven: true, checked: verdict.checked && v.checked };
@@ -2472,6 +2484,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`);
@@ -2607,12 +2620,19 @@ function searched(r, laws, stepLaws, v, opts) {
     let rule = r, lemmas;
     const { fns, lists } = r.parts;
     if (lists.length || fns.some(([, d]) => recurOf(d))) {
-        const d = discover(r, laws, stepLaws, v);
+        const d = withDeadline(until, () => discover(r, laws, stepLaws, v));
         if (d.verdict.proven && d.verdict.checked)
             return { ...d.verdict, found: { lemmas: d.found } };
         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;
@@ -2656,7 +2676,15 @@ 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 (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) {
@@ -2771,7 +2799,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) => goalsVerdict(foldObligations(f.fold, [...(f.lemmas ?? []), ...laws]));
+export const proveFold = (f, laws) => {
+    const all = [...(f.lemmas ?? []), ...laws], t0 = performance.now(), v = goalsVerdict(foldObligations(f.fold, all)), 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);
+    return v;
+};
 const asTerm = (t) => (t instanceof Term ? t : lit(t));
 // A fold over trees whose nodes have any number of children, as the kernel's binary fold (so the kernel and Lean's
 // fold_sound check it as they check any fold): a node's children become a chain of glue nodes, each folding one child

package/dist/core/infer.js

@@ -13,10 +13,11 @@
 //     its witness is a counterexample to induction, so the candidate that rules it out (and the most of those seen) is
 //     added; a chosen candidate that nothing supports, or that makes a proof slow, is dropped; the set proven as a whole
 //     is the answer, after each chosen candidate the proof doesn't need is taken out again
+import { quietly } from "./cyclic.js";
 import { any, atMost, evalC, get, interpret, n, not, plus, same, times, x } from "./machine.js";
 import { proveRule, proveSteps } from "./dsl.js";
 import { allowed, watch } from "./watch.js";
-import { proveLaw, proveLaws, proveStepLaws } from "../kernel/prove.js";
+import { proveLaw, proveLaws, proveStepLaws, withDeadline } from "../kernel/prove.js";
 const KEY = 'key$found', AT = '@', K = '#';
 const seeded = (seed) => { let s = seed; return k => { s = (s * 1103515245 + 12345) % 2 ** 31; return Math.floor(s / 2 ** 31 * k); }; };
 const isRule = (t) => typeof t.kindsOfState === 'function';
@@ -106,6 +107,9 @@ const keyValue = (cell, w) => {
     return value;
 };
 export function inferLaws(target, laws, stepLaws = [], opts = {}) {
+    return quietly(() => withDeadline(performance.now() + (opts.ms ?? 20000), () => inferLawsSearch(target, laws, stepLaws, opts)));
+}
+function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
     const t0 = performance.now(), until = t0 + (opts.ms ?? 20000), rule = isRule(target) ? target : undefined;
     const m = rule ? rule.machine : target;
     let proofs = 0;

package/dist/kernel/cyclic.d.ts

@@ -0,0 +1,45 @@
+import type { C, E } from '../core/machine.js';
+import { type Goal, type Tree } from './kernel.js';
+export type Fact = {
+    name: string;
+    keys: string[];
+    holds: C;
+};
+export type Use = {
+    node: number;
+    subst: Record<string, E>;
+    guard: C;
+    premises: Tree[];
+    descent: Tree;
+};
+export type CNode = {
+    name: string;
+    hyps: C[];
+    concl: C;
+    rank: E[];
+    insts: {
+        fact: number;
+        at: E[];
+    }[];
+    uses: Use[];
+    main: Tree;
+};
+export type Cyclic = {
+    facts: Fact[];
+    nodes: CNode[];
+};
+export declare const falseC: C;
+export declare const lexLt: (as: E[], bs: E[]) => C;
+export declare const instHyps: (facts: Fact[], insts: CNode["insts"]) => C[];
+export declare const baseHyps: (facts: Fact[], n: Pick<CNode, "hyps" | "insts">) => C[];
+export declare const useHyps: (nodes: Pick<CNode, "concl">[], uses: Pick<Use, "node" | "subst" | "guard">[]) => C[];
+type Shape = Pick<CNode, 'name' | 'hyps' | 'concl' | 'rank' | 'insts'> & {
+    uses: Pick<Use, 'node' | 'subst' | 'guard'>[];
+};
+export declare const mainGoal: (facts: Fact[], nodes: Shape[], n: Shape) => Goal;
+export declare const premiseGoal: (facts: Fact[], n: Shape, u: Shape["uses"][number], c: C, i: number) => Goal;
+export declare const descentGoal: (facts: Fact[], n: Shape, u: Shape["uses"][number], m: Shape) => Goal;
+export declare const factsAvoid: (facts: Fact[], subst: Record<string, E>) => boolean;
+export declare function refuseCyclic(p: Cyclic): string | undefined;
+export declare const checkCyclic: (p: Cyclic) => boolean;
+export {};

package/dist/kernel/cyclic.js

@@ -0,0 +1,54 @@
+import { check, substC, substE } from "./kernel.js";
+const zero = { op: 'const', value: 0 };
+export const falseC = { op: '<', a: zero, b: zero };
+// as below bs in order: the first place they differ, as's is smaller (Lean's lexLtC, built the same way).
+export const lexLt = (as, bs) => (as.length && bs.length
+    ? { op: 'or', xs: [{ op: '<', a: as[0], b: bs[0] }, { op: 'and', xs: [{ op: '=', a: as[0], b: bs[0] }, lexLt(as.slice(1), bs.slice(1))] }] }
+    : falseC);
+const sub = (s) => ({ vars: s, maps: {}, flags: {} });
+// A fact at the terms a node names: its keys paired with the terms (the shorter list decides, as Lean's zip does).
+const keyed = (keys, at) => Object.fromEntries(keys.slice(0, at.length).map((key, i) => [key, at[i]]));
+export const instHyps = (facts, insts) => insts.flatMap(p => { const f = facts[p.fact]; return f ? [substC(f.holds, sub(keyed(f.keys, p.at)))] : []; });
+export const baseHyps = (facts, n) => [...n.hyps, ...instHyps(facts, n.insts)];
+export const useHyps = (nodes, uses) => uses.flatMap(u => {
+    const m = nodes[u.node];
+    return m ? [{ op: 'or', xs: [{ op: 'not', x: u.guard }, substC(m.concl, sub(u.subst))] }] : [];
+});
+export const mainGoal = (facts, nodes, n) => ({ name: `${n.name}`, hyps: [...baseHyps(facts, n), ...useHyps(nodes, n.uses), { op: 'not', x: n.concl }] });
+export const premiseGoal = (facts, n, u, c, i) => ({ name: `${n.name}: use of node ${u.node}, its hypothesis ${i}`, hyps: [...baseHyps(facts, n), u.guard, { op: 'not', x: substC(c, sub(u.subst)) }] });
+export const descentGoal = (facts, n, u, m) => ({ name: `${n.name}: use of node ${u.node}, its rank below`, hyps: [...baseHyps(facts, n), u.guard, { op: 'not', x: lexLt(m.rank.map(e => substE(e, sub(u.subst))), n.rank) }] });
+const occurs = (name, t) => JSON.stringify(t).includes(`"op":"var","name":${JSON.stringify(name)}`);
+// The language Lean's twin has: no flag, no quantifier.
+const plain = (t) => !/"op":"(?:flag|all)"/.test(JSON.stringify(t));
+export const factsAvoid = (facts, subst) => Object.keys(subst).every(v => facts.every(f => f.keys.includes(v) || !occurs(v, f.holds)));
+// Why a cyclic proof is refused, or undefined when it checks.
+export function refuseCyclic(p) {
+    const { facts, nodes } = p;
+    if (!plain(facts) || !plain(nodes.map(n => [n.hyps, n.concl, n.rank, n.insts, n.uses.map(u => [u.subst, u.guard])])))
+        return 'a flag or a quantifier (no cyclic proof reads one)';
+    for (const f of facts)
+        if (new Set(f.keys).size !== f.keys.length)
+            return `fact ${f.name}: a key twice`;
+    for (const n of nodes) {
+        if (!check(mainGoal(facts, nodes, n), n.main))
+            return `${n.name}: its goal`;
+        for (const [j, u] of n.uses.entries()) {
+            const m = nodes[u.node];
+            if (!m)
+                return `${n.name}: use ${j} names no node`;
+            if (m.rank.length !== n.rank.length)
+                return `${n.name}: use ${j} compares ranks of different lengths`;
+            if (!factsAvoid(facts, u.subst))
+                return `${n.name}: use ${j} assigns a variable a fact reads`;
+            if (m.hyps.length !== u.premises.length)
+                return `${n.name}: use ${j} has ${u.premises.length} premise trees for ${m.hyps.length} hypotheses`;
+            for (const [i, c] of m.hyps.entries())
+                if (!check(premiseGoal(facts, n, u, c, i), u.premises[i]))
+                    return `${n.name}: use ${j}, hypothesis ${i} of ${m.name}`;
+            if (!check(descentGoal(facts, n, u, m), u.descent))
+                return `${n.name}: use ${j} doesn't lower the rank`;
+        }
+    }
+    return undefined;
+}
+export const checkCyclic = (p) => refuseCyclic(p) === undefined;

package/dist/kernel/prove.d.ts

@@ -1,5 +1,8 @@
 import type { C, E, Law, Machine } from '../core/machine.js';
 import { type Goal, type Instances, type Liveness, type Path, type StepLaw, type Tree } from './kernel.js';
+export declare const pairedKeys: {
+    skip: boolean;
+};
 export declare const profile: {
     on: boolean;
     goals: {
@@ -21,6 +24,11 @@ export declare const solveKinds: Record<string, {
     ms: number;
     rows: number;
 }>;
+export declare let proveDump: ((goal: Goal) => void) | undefined;
+export declare const setProveDump: (f: ((goal: Goal) => void) | undefined) => void;
+export declare const cellProducts: {
+    on: boolean;
+};
 export type Outcome = {
     tree: Tree;
     nodes: number;
@@ -30,10 +38,17 @@ export type Outcome = {
     path: Path;
     why?: string;
 };
+export declare function withDeadline<T>(until: number, f: () => T): T;
 export declare function grow(goal: Goal, path?: Path, budget?: {
     nodes: number;
     until?: number;
+    units?: boolean;
 }): Outcome;
+export declare function widen(part: Goal, whole: Goal, tree: Tree, opaque?: Record<string, E>, pp?: Path, wp?: Path): Tree | undefined;
+export declare const minimal: {
+    on: boolean;
+};
+export declare function usedHyps(goal: Goal, tree: Tree, path?: Path, out?: Set<number>): Set<number>;
 export type Report = {
     proven: boolean;
     nodes: number;