gdp-wired 0.17.0 → 0.18.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

@@ -22,6 +22,7 @@ import { factsFor, grow, proveLaws, proveLiveness, proveStepLaws, withDeadline }
 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)
@@ -2483,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`);
@@ -2624,6 +2626,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 +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) {

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: {
@@ -41,9 +44,11 @@ export declare function grow(goal: Goal, path?: Path, budget?: {
     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;

package/dist/kernel/prove.js

@@ -1,4 +1,5 @@
 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 { 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.
@@ -77,7 +78,10 @@ function openH(c, path, out, positive = true) {
     if (out.length === before && !positive && c.op === '=' && truth(c, path) === undefined)
         openC(c, path, out);
 }
-// Pairs of reads of one map whose keys the path doesn't yet compare.
+// Pairs of reads of one map whose keys the path doesn't yet compare. With `pairedKeys.skip` (core/data.ts), reads at
+// keys a pairing builds ((a + b)² + b, keys whose difference has monomials) are left uncompared: that encoding states
+// their congruence as facts, and comparing their keys only brings products into leaves its linear rows decide.
+export const pairedKeys = { skip: false };
 function openCells(rows, path) {
     const names = [...new Set(rows.flatMap(r => Object.keys(r.lin)))].filter(isCell);
     const out = [];
@@ -87,7 +91,27 @@ function openCells(rows, path) {
             if (p.slice(0, p.indexOf('[')) !== q.slice(0, q.indexOf('[')))
                 continue;
             const d = sub(parse(keyText(p)), parse(keyText(q)));
+            if (pairedKeys.skip && Object.keys(d).some(isMonomial))
+                continue;
             const dec = (lin) => path.get(canon(lin))?.holds ?? (path.has(canonFlip(lin)) ? !path.get(canonFlip(lin)).holds : undefined);
+            // Two cells of a run's map (core/cyclic.ts: time u and key k at u + k·Ω) at keys k·Ω and k'·Ω: k = k' first, a
+            // linear atom; the keys' own difference only where k = k' (its other side then refuted by (k − k')·Ω = 0, a product).
+            const q0 = cellProducts.on ? quotient(d) : undefined;
+            if (q0) {
+                const qa = dec(q0), qb = dec(scale(q0, -1));
+                if (qa === undefined) {
+                    out.push(q0);
+                    continue;
+                }
+                if (qa === true && qb === undefined) {
+                    out.push(scale(q0, -1));
+                    continue;
+                }
+                if (!(qa && qb))
+                    continue;
+                cellDiffs.set(canon(d), q0);
+                cellDiffs.set(canon(scale(d, -1)), scale(q0, -1));
+            }
             const a = dec(d), b = dec(scale(d, -1));
             if (a === undefined)
                 out.push(d);
@@ -96,6 +120,24 @@ function openCells(rows, path) {
         }
     return out;
 }
+// A key difference q·F over monomials that share one factor F (Ω), with no other part: q, else undefined.
+const quotient = (d) => {
+    const keys = Object.keys(d);
+    if (!keys.length || keys.some(key => key === '1' || !isMonomial(key)))
+        return undefined;
+    const shared = factorsOf(keys[0]).find(f => keys.every(key => factorsOf(key).includes(f)));
+    if (!shared)
+        return undefined;
+    const out = {};
+    for (const key of keys) {
+        const fs = [...factorsOf(key)];
+        fs.splice(fs.indexOf(shared), 1);
+        out[fs.join('*')] = (out[fs.join('*')] ?? 0) + d[key];
+    }
+    return out;
+};
+// The cells' key differences split at their quotient's equality, by canonical text: their quotient.
+const cellDiffs = new Map();
 function parse(text) {
     const out = {};
     let depth = 0, start = 0;
@@ -225,7 +267,7 @@ function growPlain(goal, path, budget) {
         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(() => leafConstraintsReusing(goal, path), ms => { profile.rowsMs += ms; });
+    const full = timed(() => rowsAt(goal, path), ms => { profile.rowsMs += ms; });
     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);
@@ -278,6 +320,21 @@ function growPlain(goal, path, budget) {
             return { tree: { leaf: fast.steps }, nodes: budget.nodes };
     }
     let split = next ?? (verdict.kind === 'unknown' ? bisect(rows, path) ?? fractional(verdict.point, path) : undefined);
+    // A cell difference's failing side (k = k' on the path, the keys apart): (k − k')·Ω = 0 refutes it, a product of each
+    // of the path's two atoms k − k' <= 0 and k' − k <= 0 with Ω >= 0.
+    if (cellProducts.on && path.size) {
+        const [id, last] = [...path].at(-1), q0 = !last.holds ? cellDiffs.get(id) : undefined;
+        if (q0) {
+            const at = (lin) => rows.findIndex(r => canon(r.lin) === canon(lin));
+            const d = last.lin, f = factorsOf(Object.keys(d)[0]).find(x => !Object.keys(q0).includes(x) && Object.keys(d).every(key => factorsOf(key).includes(x)));
+            const e1 = at(q0), e2 = at(scale(q0, -1)), sign = f === undefined ? -1 : at({ [f]: -1 });
+            if (e1 >= 0 && e2 >= 0 && sign >= 0) {
+                const pairs = [[e1, sign], [e2, sign]], out = solve(withProducts(rows, pairs));
+                if (out.kind === 'refuted')
+                    return { tree: leafOf(out.steps, pairs), nodes: budget.nodes };
+            }
+        }
+    }
     // Products: with monomials about, try every pair of rows multiplied; failing that, split a factor at zero.
     const monomials = rows.some(r => Object.keys(r.lin).some(isMonomial));
     // A witness that multiplies out (each monomial's value is its factors' product) is a real model: nothing to refute.
@@ -500,6 +557,24 @@ function squareForms(rows) {
 // the decision's own row, and any row only it makes, are not there), every split kept. The derivations are the same
 // arithmetic over the same rows, and the kernel checks the whole tree in the end. Undefined at the first leaf that
 // needs the decision.
+// A leaf's rows, by its path's decisions in order (what they are a function of): a lift reads every leaf of a subtree
+// at its own path, found when it was grown, and at the path without the split, which the next lift up reads again.
+const rowsSeen = new WeakMap();
+function rowsAt(goal, path) {
+    let byPath = rowsSeen.get(goal);
+    if (!byPath)
+        rowsSeen.set(goal, (byPath = new Map()));
+    let id = '';
+    for (const [key, a] of path)
+        id += `${a.holds ? '+' : '-'}${key}|`;
+    let rows = byPath.get(id);
+    if (!rows) {
+        if (byPath.size >= 4096)
+            byPath.clear();
+        byPath.set(id, (rows = leafConstraintsReusing(goal, path)));
+    }
+    return rows;
+}
 function lift(goal, tree, from, to) {
     const own = to.size; // the decision's row: the last of `from`'s path rows, below every later split's
     const reads = (t) => ('leaf' in t ? t.leaf.some(st => st.kind === 'input' && st.index === own) || (t.products ?? []).some(([i, j]) => i === own || j === own) : reads(t.yes) || reads(t.no));
@@ -514,7 +589,7 @@ function lift(goal, tree, from, to) {
             const no = yes && go(t.no, new Map(a).set(sid, { lin: t.split, holds: false }), new Map(b).set(sid, { lin: t.split, holds: false }));
             return yes && no ? { split: t.split, yes, no } : undefined;
         }
-        const ra = leafConstraintsReusing(goal, a), rb = leafConstraintsReusing(goal, b), at = new Map();
+        const ra = rowsAt(goal, a), rb = rowsAt(goal, b), at = new Map();
         rb.forEach((r, i) => { const key = canon(r.lin); if (!at.has(key))
             at.set(key, i); });
         const map = (i) => (i < ra.length ? at.get(canon(ra[i].lin)) : undefined);
@@ -540,6 +615,86 @@ function lift(goal, tree, from, to) {
     };
     return go(tree, from, to);
 }
+// A tree for a weaker goal (some hypotheses left out, some conjuncts of one left out) made a tree for the whole: at any
+// path a leaf's rows are among the whole goal's (each hypothesis' facts are a hypothesis' own, the cells, terms and
+// naturals they read a subset), so each input is renumbered to the same row there, a square or product past the rows
+// moved by the difference. Where a dropped conjunct makes the whole hypothesis false under the path, its row 1 <= 0
+// refutes the leaf alone; a leaf neither maps is grown again on the whole goal.
+// `opaque`: variables the weaker goal has for terms of the whole (a step's value, read the same in two hypotheses), each
+// read as the term's linear form at the whole goal's path; a split the whole's path already decides is followed, not
+// made again.
+export function widen(part, whole, tree, opaque = {}, pp = new Map(), wp = pp) {
+    const names = Object.keys(opaque);
+    const rename = (lin) => {
+        if (!names.length)
+            return lin;
+        let out = {};
+        for (const [key, c] of Object.entries(lin)) {
+            const e = opaque[key];
+            if (e) {
+                const l = linear(e, wp);
+                if (!l)
+                    return undefined;
+                out = add(out, scale(l, c));
+            }
+            else if (names.some(n => key.includes(n)))
+                return undefined;
+            else
+                out = add(out, { [key]: c });
+        }
+        return out;
+    };
+    if (!('leaf' in tree)) {
+        const id = canon(tree.split), wl = rename(tree.split);
+        if (!wl) {
+            const o = grow(whole, wp);
+            return 'tree' in o ? o.tree : undefined;
+        }
+        const wid = canon(wl), known = Object.keys(wl).every(key => key === '1') ? (wl['1'] ?? 0) <= 0 : wp.has(wid) ? wp.get(wid).holds : wp.has(canonFlip(wl)) ? !wp.get(canonFlip(wl)).holds : undefined;
+        if (known !== undefined)
+            return widen(part, whole, known ? tree.yes : tree.no, opaque, new Map(pp).set(id, { lin: tree.split, holds: known }), wp);
+        const yes = widen(part, whole, tree.yes, opaque, new Map(pp).set(id, { lin: tree.split, holds: true }), new Map(wp).set(wid, { lin: wl, holds: true }));
+        const no = yes && widen(part, whole, tree.no, opaque, new Map(pp).set(id, { lin: tree.split, holds: false }), new Map(wp).set(wid, { lin: wl, holds: false }));
+        return yes && no ? { split: wl, yes, no } : undefined;
+    }
+    const rp = rowsAt(part, pp), rw = rowsAt(whole, wp), at = new Map();
+    rw.forEach((r, i) => { const key = canon(r.lin); if (!at.has(key))
+        at.set(key, i); });
+    const map = (i) => { if (i >= rp.length)
+        return i - rp.length + rw.length; const l = rename(rp[i].lin); return l && at.get(canon(l)); };
+    const leaf = [], products = [], squares = (tree.squares ?? []).map(rename);
+    let ok = squares.every(Boolean);
+    for (const st of ok ? tree.leaf : []) {
+        if (st.kind !== 'input') {
+            leaf.push(st);
+            continue;
+        }
+        const j = map(st.index);
+        if (j === undefined) {
+            ok = false;
+            break;
+        }
+        leaf.push({ ...st, index: j });
+    }
+    for (const [i, j] of ok ? tree.products ?? [] : []) {
+        const pi = map(i), pj = map(j);
+        if (pi === undefined || pj === undefined) {
+            ok = false;
+            break;
+        }
+        products.push([pi, pj]);
+    }
+    // (renamed, a derivation through products or cuts is replayed: a cut's divisor may not divide the terms' coefficients)
+    if (ok && names.length && !checkRefutation(withProducts(rw, products, squares), leaf))
+        ok = false;
+    if (ok)
+        return { leaf, ...(tree.products ? { products } : {}), ...(tree.squares ? { squares: squares } : {}) };
+    const absurd = rw.findIndex(r => Object.keys(r.lin).every(key => key === '1') && (r.lin['1'] ?? 0) > 0);
+    if (absurd >= 0)
+        return { leaf: [{ kind: 'input', index: absurd }] };
+    const out = grow(whole, wp);
+    return 'tree' in out ? out.tree : undefined;
+}
 // Whether each hypothesis reads only names the goal's conclusion (its last hypothesis) reads.
 const nearSeen = new WeakMap();
 const namesOf = (t) => (t === undefined ? [] : [...JSON.stringify(t).matchAll(/"(?:name|map)":"([^"]+)"/g)].map(m => m[1]));
@@ -1051,9 +1206,9 @@ function triggered(m, laws, inst, build, focus = []) {
 // fewer hypotheses (a law about pairs of items with 900 instance hypotheses and 30 leaves using a few of them, say).
 export const minimal = { on: false };
 // The hypotheses a tree's leaves read: each leaf's input rows, and the rows its products multiply.
-function usedHyps(goal, tree, path = new Map(), out = new Set()) {
+export function usedHyps(goal, tree, path = new Map(), out = new Set()) {
     if ('leaf' in tree) {
-        const rows = leafConstraints(goal, path), n = rows.length, sq = tree.squares?.length ?? 0;
+        const rows = rowsAt(goal, path), n = rows.length, sq = tree.squares?.length ?? 0;
         const mark = (i) => {
             if (i < n) {
                 const s = rows[i].src;

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

@@ -37,6 +37,7 @@ export declare function readable(id: string, laws: Law[], vars: string[], maps:
     binders: string;
     hyp: string;
     call: string;
+    have?: (j: number) => string;
 }): string;
 export type ProgressCase = {
     id: string;
@@ -61,6 +62,10 @@ export declare function mmachineToLean(id: string, m: Machine, laws: Law[], opts
     stepLaws?: StepLaw[];
 }): string;
 export declare const hasSets: (m: Machine) => boolean;
+export declare function machineLit(mm: Machine, t: {
+    e: (x: E) => string;
+    c: (x: C) => string;
+}, ix: (name: string) => number, mx: (name: string) => number): string;
 export declare function smachineToLean(id: string, given: Machine, laws: Law[], opts?: {
     stepLaws?: StepLaw[];
     liveness?: Liveness[];
@@ -152,6 +157,13 @@ export type LeanItem = {
         proof: Cyclic;
     }[];
     after?: (ix: (name: string) => number, mx: (map: string) => number) => string;
+    bridge?: CycBridge;
+    recur?: CycRecur;
+    fold?: {
+        fold: Fold;
+        laws: Law[];
+    };
+    data?: true;
 };
 export declare function toLean(items: LeanItem[], opts?: {
     title?: string;
@@ -160,7 +172,55 @@ export declare function toLean(items: LeanItem[], opts?: {
 export declare function leanProject(file: string, opts?: {
     name?: string;
 }): Record<string, string>;
+export type CycBridge = {
+    machine: Machine;
+    laws: Law[];
+    tampered?: {
+        what: string;
+        machine: Machine;
+    }[];
+};
+export type CycRecur = {
+    name: string;
+    args: string[];
+    zero: E;
+    next: E;
+    lemmas: {
+        name: string;
+        holds: C;
+    }[];
+    between: {
+        name: string;
+        holds: C;
+    }[];
+};
 export declare function cyclicToLean(id: string, p: Cyclic, tampered?: {
     what: string;
     proof: Cyclic;
-}[], after?: (ix: (name: string) => number, mx: (map: string) => number) => string): string;
+}[], after?: (ix: (name: string) => number, mx: (map: string) => number) => string, bridge?: CycBridge, recur?: CycRecur, fold?: {
+    fold: Fold;
+    laws: Law[];
+}): string;
+export declare function cycEncodingLean(id: string, facts: {
+    name: string;
+    keys: string[];
+    holds: C;
+}[], nodes: {
+    name: string;
+    hyps: C[];
+    concl: C;
+}[], b: CycBridge): string;
+export declare function cycRecurCheckLean(id: string, facts: {
+    name: string;
+    keys: string[];
+    holds: C;
+}[], r: CycRecur): string;
+export declare function cycFoldCheckLean(id: string, facts: {
+    name: string;
+    keys: string[];
+    holds: C;
+}[], nodes: {
+    name: string;
+    hyps: C[];
+    concl: C;
+}[], f: Fold, laws: Law[]): string;