gdp-wired 0.16.0 → 0.17.0

package/README.md

@@ -120,6 +120,7 @@ sound.
 | Part | Trusted? | What it does |
 | --- | --- | --- |
 | `kernel/kernel.ts`, `core/check.ts` | **Yes** | Turns a rule and its laws into goals, and checks a proof tree for each: case splits on linear facts, then a linear refutation at each leaf |
+| `kernel/cyclic.ts` | **Yes** | Cyclic proofs: builds each node's goals (its own, and for each node it uses, that node's hypotheses and that the rank drops) and checks each tree with kernel.ts's check. Its twin is `lean-kernel/Cyclic.lean` (`cyclic_sound`) |
 | `kernel/prove.ts` | No | Finds the proof trees. If it's wrong, the kernel rejects the tree |
 | `lean-kernel/` | Optional | The kernel's twin in Lean 4.34.0, every rule proven sound there with the standard axioms only. The exporter sends the kernel's real trees; tampered ones compute to false |
 | `research/search/`, `research/synth/`, `research/hw/` | No | The GPU searches for breaking runs, and invariant and rank synthesis. Every hit is replayed or proven before it counts |

package/dist/core/cyclic.d.ts

@@ -0,0 +1,51 @@
+import type { C, E, Law, Machine } from './machine.js';
+import type { Fold, Instances } from '../kernel/kernel.js';
+import { type CNode, type Cyclic, type Fact, type Use } from '../kernel/cyclic.js';
+export type NodeSpec = Omit<CNode, 'uses' | 'main'> & {
+    uses: Omit<Use, 'premises' | 'descent'>[];
+};
+export type CyclicVerdict = {
+    proven: true;
+    checked: boolean;
+    proof: Cyclic;
+    why?: string;
+} | {
+    proven: false;
+    checked: false;
+    node: string;
+    goal: string;
+    stuck: string;
+};
+export declare const pair: (u: E, key: E) => E;
+export declare function proveCyclic(facts: Fact[], specs: NodeSpec[]): CyclicVerdict;
+export type RecurCase = {
+    name: string;
+    args: string[];
+    zero: E;
+    next: E;
+    lemmas: {
+        name: string;
+        holds: C;
+    }[];
+    between: {
+        name: string;
+        holds: C;
+    }[];
+    facts: Law[];
+};
+export declare function recurNodes(r: RecurCase): {
+    facts: Fact[];
+    specs: NodeSpec[];
+};
+export declare const cyclicMachine: (m: Machine, laws?: Law[]) => boolean;
+export declare function machineNodes(m: Machine, laws: Law[], instances: Record<string, Instances>): {
+    facts: Fact[];
+    specs: NodeSpec[];
+};
+export declare function foldNodes(f: Fold, laws: Law[]): {
+    facts: Fact[];
+    specs: NodeSpec[];
+};
+export declare const cyclicOn: () => boolean;
+export declare const quietly: <T>(f: () => T) => T;
+export declare function crossCyclic(kind: string, name: string, usual: boolean, run: () => CyclicVerdict, usualMs?: number): void;

package/dist/core/cyclic.js

@@ -0,0 +1,295 @@
+import { substC, substE } from "../kernel/kernel.js";
+import { descentGoal, mainGoal, premiseGoal, refuseCyclic } from "../kernel/cyclic.js";
+import { cellProducts, grow } from "../kernel/prove.js";
+const v = (name) => ({ op: 'var', name });
+const k = (value) => ({ op: 'const', value });
+const add = (a, b) => ({ op: 'add', a, b });
+const less1 = (a) => ({ op: 'sub', a, b: k(1) });
+const get = (map, key) => ({ op: 'get', map, key });
+const le = (a, b) => ({ op: '<=', a, b });
+const eq = (a, b) => ({ op: '=', a, b });
+const and = (...xs) => (xs.length === 1 ? xs[0] : { op: 'and', xs });
+const implies = (a, b) => ({ op: 'or', xs: [{ op: 'not', x: a }, b] });
+const yes = le(k(0), k(0));
+const vars = (s) => ({ vars: s, maps: {}, flags: {} });
+// A map's cell at time u and key k, in the run's one map over both: u + k·Ω, where Ω is above the run's length T, so
+// that no two (u, k) with u <= T meet (u < Ω). Linear in u, and two keys' cells differ by (k − k')·Ω.
+const omega = v('O$');
+export const pair = (u, key) => add(u, { op: 'prod', a: key, b: omega });
+// Every goal grown, then the whole checked by the kernel.
+export function proveCyclic(facts, specs) {
+    const nodes = [];
+    const grown = (g, node) => {
+        const was = cellProducts.on;
+        cellProducts.on = true;
+        let o;
+        try {
+            o = grow(g);
+        }
+        finally {
+            cellProducts.on = was;
+        }
+        return 'tree' in o ? o.tree : { proven: false, checked: false, node, goal: g.name, stuck: o.stuck };
+    };
+    for (const n of specs) {
+        const main = grown(mainGoal(facts, specs, n), n.name);
+        if ('proven' in main)
+            return main;
+        const uses = [];
+        for (const u of n.uses) {
+            const m = specs[u.node];
+            if (!m)
+                return { proven: false, checked: false, node: n.name, goal: `use of node ${u.node}`, stuck: 'no such node' };
+            const premises = [];
+            for (const [i, c] of m.hyps.entries()) {
+                const t = grown(premiseGoal(facts, n, u, c, i), n.name);
+                if ('proven' in t)
+                    return t;
+                premises.push(t);
+            }
+            const descent = grown(descentGoal(facts, n, u, m), n.name);
+            if ('proven' in descent)
+                return descent;
+            uses.push({ ...u, premises, descent });
+        }
+        nodes.push({ ...n, uses, main });
+    }
+    const proof = { facts, nodes }, why = refuseCyclic(proof);
+    return { proven: true, checked: why === undefined, proof, ...(why ? { why } : {}) };
+}
+// The facts of a machine's functions (laws about every key of them), as cyclic facts.
+const factOf = (l) => ({ name: l.name, keys: [...(l.forall ? [l.forall] : []), ...(l.keys ?? [])], holds: l.holds });
+export function recurNodes(r) {
+    const f = `${r.name}$`, x = v('x'), y = v('y'), kk = v('k$');
+    const facts = [
+        { name: `${r.name}(0)`, keys: [], holds: eq(get(f, k(0)), r.zero) },
+        { name: `${r.name}(x + 1)`, keys: ['k$'], holds: eq(get(f, add(kk, k(1))), substE(r.next, vars({ x: kk, prev: get(f, kk) }))) },
+        ...r.facts.map(factOf),
+    ];
+    const at = (t) => vars({ x: t, fx: get(f, t) });
+    const n = r.lemmas.length;
+    const lemmaUses = (to, guard) => r.lemmas.map((_, j) => ({ node: j, subst: { x: to }, guard }));
+    const specs = r.lemmas.map(l => ({
+        name: `${r.name}: ${l.name}`, hyps: [], concl: substC(l.holds, at(x)), rank: [k(0), x],
+        insts: [{ fact: 0, at: [] }, { fact: 1, at: [less1(x)] }], uses: lemmaUses(less1(x), le(k(1), x)),
+    }));
+    // A law between two points: for every x <= y, by induction on y from x, the lemmas at x, at y and at y − 1.
+    for (const b of r.between)
+        specs.push({
+            name: `${r.name}: ${b.name}`, hyps: [], rank: [k(1), y],
+            concl: implies(le(x, y), substC(b.holds, vars({ x, fx: get(f, x), y, fy: get(f, y) }))),
+            insts: [{ fact: 1, at: [less1(y)] }],
+            uses: [...r.between.map((_, j) => ({ node: n + j, subst: { y: less1(y) }, guard: le(add(x, k(1)), y) })), ...lemmaUses(x, yes), ...lemmaUses(y, yes), ...lemmaUses(less1(y), le(k(1), y))],
+        });
+    return { facts, specs: withReads(facts, specs) };
+}
+// Function facts at the keys a node's goal reads them at: each fact about every key of a function read f[k] (the key
+// alone) at each key f is read at, twice over (a fact's own reads give more keys).
+function withReads(facts, specs) {
+    const simple = facts.flatMap((f, i) => {
+        if (f.keys.length !== 1)
+            return [];
+        const reads = [...JSON.stringify(f.holds).matchAll(/"op":"get","map":"([^"]+)","key":\{"op":"var","name":"([^"]+)"\}/g)].filter(m => m[2] === f.keys[0]);
+        return reads.map(m => ({ fact: i, map: m[1] }));
+    });
+    if (!simple.length)
+        return specs;
+    const readsIn = (t, map) => { const out = []; const walk = (x) => { if (x && typeof x === 'object') {
+        const o = x;
+        if (o.op === 'get' && o.map === map)
+            out.push(o.key);
+        for (const val of Object.values(o))
+            walk(val);
+    } }; walk(t); return out; };
+    return specs.map(n => {
+        const insts = [...n.insts], seen = new Set(insts.map(p => JSON.stringify(p)));
+        for (let round = 0; round < 2; round++) {
+            const goal = [n.hyps, n.concl, insts.map(p => substC(facts[p.fact].holds, vars(Object.fromEntries(facts[p.fact].keys.map((key, i) => [key, p.at[i]]))))), n.uses.map(u => substC(specs[u.node].concl, vars(u.subst)))];
+            for (const s of simple)
+                for (const key of readsIn(goal, s.map)) {
+                    const p = { fact: s.fact, at: [key] }, id = JSON.stringify(p);
+                    if (!seen.has(id)) {
+                        seen.add(id);
+                        insts.push(p);
+                    }
+                }
+        }
+        return { ...n, insts };
+    });
+}
+// --- machines -------------------------------------------------------------------------------------------------------
+// The machines this instance covers: no history, no flag holding at every key, and no law that reads a map at a key
+// read from a map of the state (a table of nodes: a node's fold at its child), whose cells a run's maps put at keys
+// the prover would have to prove equal through products (`machineNodes` proves those laws far slower than the usual
+// rule, past its budget: research/cyclic/probe.ts).
+export const cyclicMachine = (m, laws = []) => {
+    const maps = Object.keys(m.maps ?? {});
+    const nested = (t) => { let found = false; const walk = (x, inKey) => { if (found || !x || typeof x !== 'object')
+        return; const o = x; if (o.op === 'get' && inKey && maps.includes(o.map)) {
+        found = true;
+        return;
+    } if (o.op === 'get') {
+        walk(o.key, true);
+        return;
+    } for (const val of Object.values(o))
+        walk(val, inKey); }; walk(t, false); return found; };
+    return !m.history && !Object.values(m.step.flags ?? {}).some(c => c.op === 'all') && !laws.some(l => nested(l.holds));
+};
+// The run as maps over time: names at time u read as their maps there.
+function trace(m) {
+    const maps = [...Object.keys(m.maps ?? {}), ...(m.inputMaps ?? [])];
+    const at = (u) => ({
+        vars: Object.fromEntries([...Object.keys(m.state), ...m.inputs].map(n => [n, get(`${n}@`, u)])),
+        maps: Object.fromEntries(maps.map(map => [map, (key) => get(`${map}@`, pair(u, key))])), flags: {},
+    });
+    return { at };
+}
+// Every map read at `from` (the same term) read at `to`.
+const readsAt = (t, from, to) => {
+    const id = JSON.stringify(from);
+    const walk = (x) => {
+        if (Array.isArray(x))
+            return x.map(walk);
+        if (!x || typeof x !== 'object')
+            return x;
+        const o = x;
+        if (o.op === 'get' && JSON.stringify(o.key) === id)
+            return { ...o, key: to };
+        return Object.fromEntries(Object.entries(o).map(([key, val]) => [key, walk(val)]));
+    };
+    return walk(t);
+};
+// A machine's flags, each its condition over the frame before the step (through the flags before it).
+const flagsOf = (m) => {
+    const out = {};
+    for (const [f, c] of Object.entries(m.step.flags ?? {}))
+        out[f] = substC(c, { vars: {}, maps: {}, flags: out });
+    return out;
+};
+export function machineNodes(m, laws, instances) {
+    const { at } = trace(m), flags = flagsOf(m), inline = (t) => substC(t, { vars: {}, maps: {}, flags });
+    const t = v('t$'), T = v('T$'), u = v('u$'), key = v('k$');
+    const inlineE = (e) => substE(e, { vars: {}, maps: {}, flags });
+    const now = (c, when) => substC(c, at(when)), nowE = (e, when) => substE(inlineE(e), at(when));
+    const state = Object.keys(m.state), mapNames = Object.keys(m.maps ?? {});
+    // The start and a step, each stated at the time u it gives (a start at u <= 0, a step at 1 <= u <= T from u − 1), so a
+    // node reads them at its own time t: the cells they give are the cells it reads, with no key to prove equal.
+    const start = le(u, k(0)), stepped = and(le(k(1), u), le(u, T)), prev = less1(u);
+    const facts = [
+        { name: `${m.name}: the start`, keys: ['u$'], holds: implies(start, and(yes, ...state.map(s => eq(get(`${s}@`, u), m.state[s])))) },
+        { name: `${m.name}: a step`, keys: ['u$'], holds: implies(stepped, and(yes, ...(m.assume ? [now(inline(m.assume), prev)] : []), ...state.map(s => eq(get(`${s}@`, u), nowE(m.step.state?.[s] ?? v(s), prev))))) },
+        ...mapNames.flatMap((map) => {
+            const w = m.step.maps?.[map], cell = (when) => get(`${map}@`, pair(when, key));
+            // A write at one key: where the key is the write's, the value with every read at the write's key read at the key
+            // instead (the same cell there), so the cells the step gives are at the key the node reads.
+            const next = !w ? cell(prev) : 'each' in w ? substE(substE(w.value, { vars: { [w.each]: key }, maps: {}, flags }), at(prev))
+                : { op: 'if', c: eq(key, nowE(w.key, prev)), then: substE(readsAt(inlineE(w.value), inlineE(w.key), key), at(prev)), else: cell(prev) };
+            return [
+                { name: `${m.name}: ${map} at the start`, keys: ['u$', 'k$'], holds: implies(start, eq(cell(u), k(m.maps[map]))) },
+                { name: `${m.name}: ${map} at a step`, keys: ['u$', 'k$'], holds: implies(stepped, eq(cell(u), next)) },
+                { name: `${m.name}: ${map}'s cells are naturals`, keys: ['u$', 'k$'], holds: le(k(0), cell(u)) },
+            ];
+        }),
+        ...(m.facts ?? []).map(factOf),
+        // That a state variable's value at a time is a natural holds of every model: read at the node's time, it makes the
+        // value a column of its own (a value read only inside a product would be none, and no two reads of it equal).
+        ...state.map((s) => ({ name: `${m.name}: ${s} is a natural`, keys: ['u$'], holds: le(k(0), get(`${s}@`, u)) })),
+        { name: `${m.name}: params are naturals`, keys: [], holds: and(yes, ...m.params.map(x => le(k(0), v(x)))) },
+    ];
+    const fi = (name) => facts.findIndex(f => f.name === name);
+    const keysOf = (l) => [...(l.forall ? [l.forall] : []), ...(l.keys ?? [])];
+    // A map read at the node's time t at key e: that map's start, step and natural facts at (t, e).
+    const mapInsts = (c) => {
+        const out = [], seen = new Set();
+        const walk = (x) => {
+            if (!x || typeof x !== 'object')
+                return;
+            const o = x;
+            if (o.op === 'get' && typeof o.map === 'string' && o.map.endsWith('@') && mapNames.includes(o.map.slice(0, -1))) {
+                const kk = o.key;
+                if (kk.op === 'add' && JSON.stringify(kk.a) === JSON.stringify(t) && kk.b.op === 'prod') {
+                    const read = kk.b.a, id = JSON.stringify(read), map = o.map.slice(0, -1);
+                    if (!seen.has(`${map}:${id}`)) {
+                        seen.add(`${map}:${id}`);
+                        out.push(...['at the start', 'at a step', '\'s cells are naturals'].map(what => ({ fact: fi(`${m.name}: ${map}${what.startsWith('\'') ? what : ` ${what}`}`), at: [t, read] })));
+                    }
+                }
+            }
+            for (const val of Object.values(o))
+                walk(val);
+        };
+        walk(c);
+        return out;
+    };
+    const specs = laws.map(l => {
+        const inst = instances[l.name] ?? {};
+        // Terms over the frame before the step (the machine's proof proves a law about every key at a fresh key k#: here
+        // the node's own k).
+        const fresh = Object.fromEntries(laws.flatMap(x => (x.forall ? [[`${x.forall}#`, v(x.forall)]] : [])));
+        const pre = at(less1(t)), before = (e) => substE(substE(e, vars(fresh)), pre);
+        // The laws at the step before, at the keys the machine's proof assumes them at.
+        const uses = laws.flatMap((l2, j) => {
+            const ks = keysOf(l2);
+            if (!ks.length)
+                return [{ node: j, subst: { 't$': less1(t) }, guard: le(k(1), t) }];
+            const flat = inst[l2.name] ?? [];
+            return Array.from({ length: Math.floor(flat.length / ks.length) }, (_, i) => ({ node: j, subst: { 't$': less1(t), ...Object.fromEntries(ks.map((kn, q) => [kn, before(flat[i * ks.length + q])])) }, guard: le(k(1), t) }));
+        });
+        // The functions' facts at the keys the proof names, over the frame before the step (at t = 0, the start's).
+        const factInsts = (m.facts ?? []).flatMap(f => {
+            const ks = keysOf(f), flat = inst[f.name] ?? [];
+            if (!ks.length)
+                return [{ fact: fi(f.name), at: [] }];
+            return Array.from({ length: Math.floor(flat.length / ks.length) }, (_, i) => ({ fact: fi(f.name), at: flat.slice(i * ks.length, (i + 1) * ks.length).map(before) }));
+        });
+        const concl = substC(l.holds, at(t));
+        const useConcls = uses.map(us => substC(substC(laws[us.node].holds, at(t)), vars(us.subst)));
+        const base = mapInsts([concl, useConcls]);
+        return {
+            name: `${m.name}: ${l.name}`, hyps: [...(m.pre ? [m.pre] : []), le(t, T), ...(mapNames.length ? [{ op: '<', a: T, b: omega }] : [])], concl, rank: [t],
+            insts: [{ fact: 0, at: [t] }, { fact: 1, at: [t] }, ...factInsts, ...base, ...state.map(st => ({ fact: fi(`${m.name}: ${st} is a natural`), at: [t] })), { fact: fi(`${m.name}: params are naturals`), at: [] }], uses,
+        };
+    });
+    return { facts, specs };
+}
+// --- folds over trees -----------------------------------------------------------------------------------------------
+// The tree as a table of nodes below its size N: a node n is a leaf (Kind[n] = 0) whose values come from its inputs,
+// or a node (Kind[n] = 1) with children Left[n], Right[n] numbered below n, its values from theirs and its inputs.
+export function foldNodes(f, laws) {
+    const n = v('n$'), N = v('N$'), names = Object.keys(f.leaf);
+    const at = (i) => vars(Object.fromEntries([...names, ...f.inputs].map(x => [x, get(`${x}@`, i)])));
+    const kind = (i) => get('Kind@', i), left = (i) => get('Left@', i), right = (i) => get('Right@', i);
+    const side = (child, p) => Object.fromEntries(names.map(x => [`${p}${x}`, get(`${x}@`, child)]));
+    const nodeAt = (i) => vars({ ...Object.fromEntries(f.inputs.map(x => [x, get(`${x}@`, i)])), ...side(left(i), 'l_'), ...side(right(i), 'r_') });
+    const assume = (i) => (f.assume ? [substC(f.assume, at(i))] : []);
+    const facts = [{ name: `${f.name}: the table`, keys: ['n$'], holds: implies({ op: '<', a: n, b: N }, and(le(kind(n), k(1)), implies(eq(kind(n), k(0)), and(yes, ...assume(n), ...names.map(x => eq(get(`${x}@`, n), substE(f.leaf[x], at(n)))))), implies(eq(kind(n), k(1)), and({ op: '<', a: left(n), b: n }, { op: '<', a: right(n), b: n }, ...assume(n), ...names.map(x => eq(get(`${x}@`, n), substE(f.node[x], nodeAt(n)))))))) },
+        // Each value a natural (true of every model), so a value read only inside a product is a column of its own.
+        { name: `${f.name}: values are naturals`, keys: ['n$'], holds: and(yes, ...names.map(x => le(k(0), get(`${x}@`, n)))) },
+        { name: `${f.name}: params are naturals`, keys: [], holds: and(yes, ...f.params.map(x => le(k(0), v(x)))) }];
+    const specs = laws.map(l => ({
+        name: `${f.name}: ${l.name}`, hyps: [...(f.pre ? [f.pre] : []), { op: '<', a: n, b: N }], concl: substC(l.holds, at(n)), rank: [n],
+        insts: [{ fact: 0, at: [n] }, ...[n, left(n), right(n)].map(i => ({ fact: 1, at: [i] })), { fact: 2, at: [] }],
+        uses: laws.flatMap((_, j) => [left, right].map(c => ({ node: j, subst: { 'n$': c(n) }, guard: eq(kind(n), k(1)) }))),
+    }));
+    return { facts, specs };
+}
+// --- the cyclic route beside the usual one (GDP_CYCLIC=1) -------------------------------------------------------------
+// With GDP_CYCLIC=1, every proof the instances above cover is made again as a cyclic proof, and a verdict that differs
+// throws: the suite run so shows the rules are instances. Each comparison is printed to stderr as a line `cyclic: {...}`.
+const env = () => globalThis.process?.env;
+let quiet = 0;
+export const cyclicOn = () => quiet === 0 && env()?.GDP_CYCLIC === '1';
+// A search's many trial proofs (core/discover.ts, core/infer.ts) aren't compared: what it finds is proven again.
+export const quietly = (f) => { quiet++; try {
+    return f();
+}
+finally {
+    quiet--;
+} };
+export function crossCyclic(kind, name, usual, run, usualMs) {
+    const t0 = performance.now(), out = run(), ms = Math.round(performance.now() - t0);
+    const cyclic = out.proven && out.checked;
+    console.error(`cyclic: ${JSON.stringify({ kind, name, usual, cyclic, ms, ...(usualMs === undefined ? {} : { usualMs: Math.round(usualMs) }), ...(out.proven ? { nodes: out.proof.nodes.length, ...(out.why ? { why: out.why } : {}) } : { goal: out.goal, stuck: out.stuck }) })}`);
+    if (cyclic !== usual)
+        throw new Error(`cyclic route: ${kind} ${name} is ${cyclic ? 'proven' : 'not proven'} as a cyclic proof, ${usual ? 'proven' : 'not proven'} the usual way${out.proven ? (out.why ? ` (${out.why})` : '') : ` (${out.goal}: ${out.stuck})`}`);
+}

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.js

@@ -18,7 +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 } 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";
 // --- terms and conditions -------------------------------------------------------------------------------------------
@@ -1399,6 +1400,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 +1418,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 +1459,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 };
@@ -2607,7 +2618,7 @@ 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)
@@ -2771,7 +2782,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

@@ -21,6 +21,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 +35,15 @@ 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 const minimal: {
+    on: boolean;
+};
 export type Report = {
     proven: boolean;
     nodes: number;