gdp-wired 0.19.0 → 0.21.0

package/dist/core/cycles.js

@@ -1,9 +1,9 @@
-import { fnValue, pairedArgs } from "./machine.js";
-import { check, livenessParts, loopLiveness, loopMachine, loopObligations, substC, substE } from "../kernel/kernel.js";
-import { factsAvoid, lexLt } from "../kernel/cyclic.js";
+import { compileFunction, evalC as evalMC, evalE as evalME, fnValue, interpret, pairedArgs } from "./machine.js";
+import { check, livenessHelpful, livenessParts, loopLiveness, loopMachine, loopObligations, substC, substE } from "../kernel/kernel.js";
+import { checkCyclic, factsAvoid, lexLt } from "../kernel/cyclic.js";
 import { proveCyclic } from "./cyclic.js";
 import { solve } from "./solver.js";
-import { grow, proveLaws, proveStepLaws, withDeadline } from "../kernel/prove.js";
+import { grow, proveLaws, proveLiveness, proveStepLaws, withDeadline } from "../kernel/prove.js";
 import { inferLaws } from "./infer.js";
 // --- terms ----------------------------------------------------------------------------------------------------------
 const v = (name) => ({ op: 'var', name }), k = (value) => ({ op: 'const', value });
@@ -36,7 +36,10 @@ export const showE = (e) => {
         case 'add': return `${showE(e.a)} + ${showE(e.b)}`;
         case 'sub': return `${showE(e.a)} − ${e.b.op === 'add' || e.b.op === 'sub' ? `(${showE(e.b)})` : showE(e.b)}`;
         case 'mul': return `${e.k}·${e.a.op === 'var' || e.a.op === 'const' ? showE(e.a) : `(${showE(e.a)})`}`;
-        case 'prod': return `(${showE(e.a)})·(${showE(e.b)})`;
+        case 'prod': {
+            const f = (t) => (t.op === 'var' || t.op === 'const' || t.op === 'get' ? showE(t) : `(${showE(t)})`);
+            return `${f(e.a)}·${f(e.b)}`;
+        }
         case 'min':
         case 'max': return `${e.op}(${showE(e.a)}, ${showE(e.b)})`;
         case 'if': return `if ${showC(e.c)} then ${showE(e.then)} else ${showE(e.else)}`;
@@ -409,9 +412,10 @@ function lp(must, pool, until, scale = 1, signs = [true, false]) {
         }
         return undefined;
     };
-    // The widest box first: where it has no solution, none of the smaller has.
+    // The widest box first: where it has no solution, none of the smaller has. Past it, a rank's rows (homogeneous in the
+    // unknowns, the drop's constant aside) are solved exactly over the rationals, the solution scaled to whole numbers.
     if (!stage(signs.at(-1), bounds.at(-1), true))
-        return undefined;
+        return fit ? undefined : exactLp(must, pool, until);
     for (const natural of signs)
         for (const bound of bounds)
             for (const wide of [false, true]) {
@@ -421,14 +425,176 @@ function lp(must, pool, until, scale = 1, signs = [true, false]) {
             }
     return undefined;
 }
+const bgcd = (a, b) => { if (a < 0n)
+    a = -a; if (b < 0n)
+    b = -b; while (b)
+    [a, b] = [b, a % b]; return a; };
+const q = (n, d = 1n) => { if (d < 0n)
+    (n = -n, d = -d); const g = bgcd(n, d) || 1n; return g === 1n ? { n, d } : { n: n / g, d: d / g }; };
+const Q0 = q(0n), Q1 = q(1n);
+const qadd = (a, b) => (a.d === b.d ? q(a.n + b.n, a.d) : q(a.n * b.d + b.n * a.d, a.d * b.d));
+const qsub = (a, b) => qadd(a, { n: -b.n, d: b.d });
+const qmul = (a, b) => (!a.n || !b.n ? Q0 : q(a.n * b.n, a.d * b.d));
+const qdiv = (a, b) => q(a.n * b.d, a.d * b.n);
+const qlt = (a, b) => a.n * b.d < b.n * a.d;
+// The primal simplex on a tableau whose basis is feasible: minimize cost·y over T·y = rhs (the last column), y >= 0,
+// Bland's rule (the smallest column that improves, the smallest basis index among ties), only `open` columns entering.
+function simplex(T, basis, cost, open, until) {
+    const cols = cost.length;
+    for (let it = 0; it < 5000; it++) {
+        if (performance.now() > until)
+            return false;
+        let enter = -1;
+        for (let j = 0; j < cols && enter < 0; j++) {
+            if (!open(j) || basis.includes(j))
+                continue;
+            let r = cost[j];
+            for (const [i, b] of basis.entries())
+                if (T[i][j].n && cost[b].n)
+                    r = qsub(r, qmul(cost[b], T[i][j]));
+            if (r.n < 0n)
+                enter = j;
+        }
+        if (enter < 0)
+            return true;
+        let leave = -1, best;
+        for (const [i, row] of T.entries()) {
+            if (row[enter].n <= 0n)
+                continue;
+            const ratio = qdiv(row[cols], row[enter]);
+            if (!best || qlt(ratio, best) || (!qlt(best, ratio) && basis[i] < basis[leave]))
+                (best = ratio, leave = i);
+        }
+        if (leave < 0)
+            return false; // unbounded: not for an objective bounded below
+        const p = T[leave][enter];
+        T[leave] = T[leave].map(x => qdiv(x, p));
+        for (const [i, row] of T.entries()) {
+            if (i === leave || !row[enter].n)
+                continue;
+            const f = row[enter];
+            T[i] = row.map((x, j) => qsub(x, qmul(f, T[leave][j])));
+        }
+        basis[leave] = enter;
+    }
+    return false;
+}
+// The rows (lin <= 0) over free unknowns, solved exactly: Σ|u| least (each u as p − q, p, q >= 0), two phases. The
+// rational solution scaled by its denominators' least common multiple and divided by its numerators' common divisor;
+// kept only if every row holds of it exactly (a row with a positive constant, a drop of at least 1, holds of any
+// multiple at least 1 of a solution; one with a negative constant may not).
+function exactSolve(rows, until) {
+    const xs = [...new Set(rows.flatMap(l => Object.keys(l)).filter(x => x !== '1'))].sort(), n = xs.length, m = rows.length;
+    // Columns: p (n), q (n), a slack per row (m), an artificial per row (m); the right-hand side last.
+    const cols = 2 * n + 2 * m, T = [], basis = [];
+    for (const [i, l] of rows.entries()) {
+        let rhs = -(l['1'] ?? 0);
+        const sign = rhs < 0 ? -1 : 1;
+        rhs *= sign;
+        const row = Array.from({ length: cols + 1 }, () => Q0);
+        for (const [j, x] of xs.entries()) {
+            const c = sign * (l[x] ?? 0);
+            if (c)
+                (row[j] = q(BigInt(c)), row[n + j] = q(BigInt(-c)));
+        }
+        row[2 * n + i] = q(BigInt(sign));
+        if (sign < 0) {
+            row[2 * n + m + i] = Q1;
+            basis.push(2 * n + m + i);
+        }
+        else
+            basis.push(2 * n + i);
+        row[cols] = q(BigInt(rhs));
+        T.push(row);
+    }
+    const art = (j) => j >= 2 * n + m;
+    const phase1 = Array.from({ length: cols }, (_, j) => (art(j) ? Q1 : Q0));
+    if (!simplex(T, basis, phase1, () => true, until))
+        return undefined;
+    if (T.some((row, i) => art(basis[i]) && row[cols].n))
+        return undefined; // infeasible
+    // An artificial left in the basis at zero: pivoted out on any other column, or its row dropped (redundant).
+    for (let i = T.length - 1; i >= 0; i--) {
+        if (!art(basis[i]))
+            continue;
+        const j = T[i].findIndex((x, c) => c < 2 * n + m && x.n !== 0n);
+        if (j < 0) {
+            T.splice(i, 1);
+            basis.splice(i, 1);
+            continue;
+        }
+        const p = T[i][j];
+        T[i] = T[i].map(x => qdiv(x, p));
+        for (const [r, row] of T.entries())
+            if (r !== i && row[j].n) {
+                const f = row[j];
+                T[r] = row.map((x, c) => qsub(x, qmul(f, T[i][c])));
+            }
+        basis[i] = j;
+    }
+    const phase2 = Array.from({ length: cols }, (_, j) => (j < 2 * n ? Q1 : Q0));
+    if (!simplex(T, basis, phase2, j => !art(j), until))
+        return undefined;
+    const val = (j) => { const i = basis.indexOf(j); return i < 0 ? Q0 : T[i][cols]; };
+    const u = xs.map((_, j) => qsub(val(j), val(n + j)));
+    let lcm = 1n;
+    for (const r of u)
+        lcm = lcm / bgcd(lcm, r.d) * r.d;
+    const ints = u.map(r => r.n * (lcm / r.d)), g = ints.reduce((a, b) => bgcd(a, b), 0n) || 1n;
+    const w = {};
+    for (const [j, x] of xs.entries()) {
+        const c = Number(ints[j] / g);
+        if (!Number.isSafeInteger(c))
+            return undefined;
+        if (c)
+            w[x] = c;
+    }
+    return rows.every(l => valueAt(l, w) <= 0) ? w : undefined;
+}
+// exactSolve over `must` and the pool's rows, the pool's added as they are violated (the most violated first). The
+// solution is found on the smaller half of the runs (each row's size its largest coefficient, a sample's value or a
+// turn's change) and kept only where it holds of all of them: a coefficient the runs' size forces (32·x + y where x
+// reaches 33, a reset y := x − 1 in the runs) grows with the runs, and is refused, where one a turn's change forces
+// (11·x + 2·y, six tokens for a coin and a coin for five) is the same on both.
+function exactLp(must, pool, until) {
+    const size = (l) => { let m = 0; for (const x in l)
+        if (x !== '1')
+            m = Math.max(m, Math.abs(l[x])); return m; };
+    const sizes = pool.map(size), half = sizes.reduce((a, b) => Math.max(a, b), 0) / 2, small = pool.filter((_, i) => sizes[i] <= half), rows = [...must];
+    for (let round = 0; round < 40 && performance.now() < until; round++) {
+        const w = exactSolve(rows, until);
+        if (!w)
+            return undefined;
+        // The twelve most violated, in one pass.
+        const bad = [];
+        for (const l of small) {
+            const x = valueAt(l, w);
+            if (x <= 0 || (bad.length === 12 && x <= bad[11][0]))
+                continue;
+            bad.push([x, l]);
+            bad.sort((p, q) => q[0] - p[0]);
+            if (bad.length > 12)
+                bad.pop();
+        }
+        if (!bad.length)
+            return pool.every(l => valueAt(l, w) <= 0) ? w : undefined;
+        rows.push(...bad.map(b => b[1]));
+    }
+    return undefined;
+}
 // Lexicographic ranks over the edges (each from a node at a sample to a node at its arguments), every component >= 0
 // at every sample: Bradley–Manna–Sipma's successive elimination, each component the sum of one solution per edge it can
 // make drop. An edge no component makes drop is left (its use's guard keeps it where the rank drops, if anywhere).
-function lexRanks(idx, nodes, samples, edges, name, until) {
-    const points = [...new Map(idx.flatMap(n => samples[n].map(s => { const l = rankRow(n, nodes, s.env, name, -1); return [id(l), l]; }))).values()];
+// `onEdges`: each component a natural only where an edge compares it (at its ends), not at every sample: a rank the
+// kernel reads truncated (n·n − i, 0 past the square, where no call is made). `weak`: edges the rank must not raise but
+// need not lower (a liveness's steps other than its helpful requests'), each dropped once a component lowers it.
+function lexRanks(idx, nodes, samples, edges, name, until, onEdges = false, weak = []) {
+    const ends = onEdges ? edges.flatMap(e => [[e.from, e.s], [e.to, e.t]]) : idx.flatMap(n => samples[n].map(s => [n, s.env]));
+    const points = [...new Map(ends.map(([n, env]) => { const l = rankRow(n, nodes, env, name, -1); return [id(l), l]; })).values()];
     const delta = (e) => plus(rankRow(e.to, nodes, e.t, name), rankRow(e.from, nodes, e.s, name, -1));
     const scale = 1 + Math.max(0, ...idx.flatMap(n => samples[n].flatMap(s => Object.values(s.env))));
     let left = [...new Map(edges.map(e => { const l = delta(e); return [id(l), l]; })).values()];
+    let keep = [...new Map(weak.map(e => { const l = delta(e); return [id(l), l]; })).values()].filter(l => !left.some(x => id(x) === id(l)));
     const comps = [];
     while (left.length && comps.length < 4 && performance.now() < until) {
         let sum = {};
@@ -439,7 +605,7 @@ function lexRanks(idx, nodes, samples, edges, name, until) {
             if (strict(l) || performance.now() > until || tried.has(sign(l)) || tried.size > 40)
                 continue;
             tried.add(sign(l));
-            const w = lp([plus(l, { 1: 1 })], [...left, ...points], until, scale);
+            const w = lp([plus(l, { 1: 1 })], [...left, ...keep, ...points], until, scale);
             if (w)
                 sum = plus(sum, w);
         }
@@ -451,6 +617,7 @@ function lexRanks(idx, nodes, samples, edges, name, until) {
             sum = Object.fromEntries(Object.entries(sum).map(([x, c]) => [x, c / g]));
         comps.push(sum);
         const kept = left.filter(l => !strict(l));
+        keep = keep.filter(l => !strict(l));
         if (kept.length === left.length)
             break;
         left = kept;
@@ -458,7 +625,51 @@ function lexRanks(idx, nodes, samples, edges, name, until) {
     return { comps, left: left.length };
 }
 const gcd = (a, b) => (b === 0 ? a : gcd(b, a % b));
-const compE = (c, n, node, name) => linE(Object.fromEntries(node.vars.map((x, j) => [x, c[name(n, j)] ?? 0])), c[name(n, 'b')] ?? 0);
+// The same over named naturals and the edges of runs alone (core/data.ts: a recursive function's calls, each from its
+// parameters' sizes to its arguments'): each component's coefficient per variable and its constant.
+export function ranksOfRuns(vars, points, edges, ms = 1000) {
+    const node = { name: 'runs', hyps: [], concl: yes, vars, level: 0, given: true };
+    const { comps, left } = lexRanks([0], [node], [points.map(env => ({ env, calls: new Set() }))], edges.map(e => ({ from: 0, to: 0, s: e.s, t: e.t })), shared, performance.now() + ms);
+    return { comps: comps.map(c => ({ coef: Object.fromEntries(vars.map((x, j) => [x, c[shared(0, j)] ?? 0])), c: c[shared(0, 'b')] ?? 0 })), left };
+}
+const compE = (c, n, node, name) => unfeat(linE(Object.fromEntries(node.vars.map((x, j) => [x, c[name(n, j)] ?? 0])), c[name(n, 'b')] ?? 0));
+// Ranks of degree 2: a product of two of a node's variables (a square too) a further variable of the LP, its value at
+// each sample the product's, one product at a time (a sparse template: with every product at once, the runs fit a rank
+// of many small parts that no turn past them keeps). The rank found is linear in it, the product read back as the term
+// it is (x·y as prod(x, y)), which the kernel takes as a monomial, its goals the same linear goals over it (with its
+// products of rows and squares, Positivstellensatz of degree 2, where they need more).
+const featSep = '·';
+const products = (names) => names.flatMap((a, i) => names.slice(i).map(b => [a, b]));
+const featName = ([a, b]) => `${a}${featSep}${b}`;
+const withFeat = (env, p) => (p && env[p[0]] !== undefined && env[p[1]] !== undefined ? { ...env, [featName(p)]: env[p[0]] * env[p[1]] } : env);
+// (linE builds sums, differences and multiples of variables and constants only)
+const unfeat = (e) => {
+    if (e.op === 'var') {
+        const [a, b] = e.name.split(featSep);
+        return b === undefined ? e : { op: 'prod', a: v(a), b: v(b) };
+    }
+    if (e.op === 'add' || e.op === 'sub')
+        return { ...e, a: unfeat(e.a), b: unfeat(e.b) };
+    return e.op === 'mul' ? { ...e, a: unfeat(e.a) } : e;
+};
+// The products of two variables a term reads, each as its sorted pair.
+const productsIn = (t) => {
+    const out = new Map();
+    walk(t, o => { if (o.op === 'prod') {
+        const a = o.a, b = o.b;
+        if (a.op === 'var' && b.op === 'var') {
+            const p = [a.name, b.name].sort();
+            out.set(id(p), p);
+        }
+    } });
+    return [...out.values()];
+};
+// The nodes, samples and edges with one product of two variables per node a variable (none where `ps[i]` is undefined).
+const withProducts = (nodes, samples, edges, ps) => ({
+    nodes: nodes.map((n, i) => (ps[i] ? { ...n, vars: [...n.vars, featName(ps[i])] } : n)),
+    samples: samples.map((ss, i) => ss.map(s => ({ ...s, env: withFeat(s.env, ps[i]) }))),
+    edges: edges.map(e => ({ ...e, s: withFeat(e.s, ps[e.from]), t: withFeat(e.t, ps[e.to]) })),
+});
 // Strongly connected components (Tarjan), each node's component's index.
 function sccs(graph) {
     const index = [], low = [], on = [], stack = [], comp = [];
@@ -490,7 +701,8 @@ function sccs(graph) {
             visit(u);
     return comp;
 }
-function build(facts, cx, nodes, depth, big, until) {
+// `quad`: ranks of degree 2, the product of those two variables a further one of each node that has both.
+function build(facts, cx, nodes, depth, big, until, quad) {
     const inst = nodes.map(n => instancesFor(facts, cx, n, depth));
     const samples = [];
     for (const n of nodes) {
@@ -539,21 +751,23 @@ function build(facts, cx, nodes, depth, big, until) {
                 parts.set(i, []);
             continue;
         }
-        let best = { ...lexRanks(idx, nodes, samples, within, shared, until), name: shared };
+        const q = quad ? withProducts(nodes, samples, within, nodes.map(n => (n.vars.includes(quad[0]) && n.vars.includes(quad[1]) ? quad : undefined))) : { nodes, samples, edges: within };
+        let best = { ...lexRanks(idx, q.nodes, q.samples, q.edges, shared, until, !!quad), name: shared };
         if (best.left && idx.length > 1 && idx.length <= 4) {
-            const o = lexRanks(idx, nodes, samples, within, own(nodes), until);
+            const o = lexRanks(idx, q.nodes, q.samples, q.edges, own(q.nodes), until, !!quad);
             if (o.left < best.left)
-                best = { ...o, name: own(nodes) };
+                best = { ...o, name: own(q.nodes) };
         }
         for (const i of idx)
-            parts.set(i, best.comps.map(cp => compE(cp, i, nodes[i], best.name)));
+            parts.set(i, best.comps.map(cp => compE(cp, i, q.nodes[i], best.name)));
     }
     const width = Math.max(0, ...[...parts.values()].map(p => p.length)), tiers = graph.some(g => g.length);
     const ranks = nodes.map((_, i) => [...(tiers ? [k(heightOf(comp[i]))] : []), ...parts.get(i), ...Array.from({ length: width - parts.get(i).length }, () => k(0))]);
     let uses = 0;
     const specs = nodes.map((n, i) => ({
         name: n.name, hyps: n.hyps, concl: n.concl, rank: ranks[i], insts: inst[i].insts,
-        uses: cands[i].filter((_, u) => active[i][u]).map(c => {
+        // (a use at a rank that is this node's own, term for term, never applies: its guard is false, so it is left out)
+        uses: cands[i].filter((c, u) => active[i][u] && id(ranks[c.node].map(r => substE(r, vs(c.subst)))) !== id(ranks[i])).map(c => {
             uses++;
             const m = nodes[c.node], s = vs(c.subst);
             return { node: c.node, subst: c.subst, guard: and(...m.hyps.map(h => substC(h, s)), lexLt(ranks[c.node].map(r => substE(r, s)), ranks[i])) };
@@ -672,8 +886,8 @@ export function findCycles(facts, claims, opts = {}) {
     const big = Math.max(0, ...constsOf([facts.map(f => f.holds), claims]).filter(c => c <= 1000));
     const given = claims.map(c => nodeOf(c, 1, !opts.houdini));
     let last = { proven: false, checked: false, why: 'nothing tried' };
-    const once = (nodes, depth) => {
-        const b = withDeadline(until, () => build(facts, cx, nodes, depth, big, until));
+    const once = (nodes, depth, quad) => {
+        const b = withDeadline(until, () => build(facts, cx, nodes, depth, big, until, quad));
         if ('broken' in b) {
             const at = nodes.find(n => n.name === b.broken.node);
             return { failed: at, verdict: { proven: false, checked: false, goal: at.name, stuck: 'sat', witness: b.broken.env, why: 'the facts, run, break it' } };
@@ -695,10 +909,10 @@ export function findCycles(facts, claims, opts = {}) {
     };
     // Houdini over the nodes that may be dropped (each that fails, dropped, the rest proven again); then each companion
     // dropped in turn where the rest are proven without it (only what the claims need is kept).
-    const attempt = (start, depth) => {
+    const attempt = (start, depth, quad) => {
         let nodes = start, done;
         for (let round = 0; round <= start.length && nodes.length && performance.now() < until && !done; round++) {
-            const t = once(nodes, depth);
+            const t = once(nodes, depth, quad);
             if ('proven' in t) {
                 done = t.proven;
                 break;
@@ -714,14 +928,16 @@ export function findCycles(facts, claims, opts = {}) {
         for (const c of nodes.filter(n => !n.given)) {
             if (performance.now() >= until)
                 break;
-            const rest = nodes.filter(n => n !== c), t = once(rest, depth);
+            const rest = nodes.filter(n => n !== c), t = once(rest, depth, quad);
             if ('proven' in t && t.proven.checked)
                 (nodes = rest, done = t.proven);
         }
         return done;
     };
     // The claims alone, with the facts at the terms they read and then at those the facts read; their constants as
-    // variables; companions beside them by analogy, then every bound.
+    // variables; companions beside them by analogy, then every bound; then ranks of degree 2, over each product of two
+    // variables the claims read (up(i, n) = up(i + 1, n) while i < n·n: n·n − i).
+    const quads = productsIn(given.map(n => [n.hyps, n.concl])).filter(([a, b]) => given.some(n => n.vars.includes(a) && n.vars.includes(b)));
     const tries = [
         [depth, () => given], [depth + 1, () => given],
         ...(opts.generalize === false ? [] : [
@@ -729,16 +945,17 @@ export function findCycles(facts, claims, opts = {}) {
             [depth + 1, () => [...given, ...beside(cx, facts, given, big, until, true)]],
             [depth + 1, () => [...given, ...beside(cx, facts, given, big, until, false)]],
         ]),
+        ...quads.flatMap(p => [[depth, () => given, p], [depth + 1, () => given, p]]),
     ];
     const tried = new Set();
-    for (const [d, t] of tries) {
+    for (const [d, t, quad] of tries) {
         if (performance.now() >= until)
             break;
         const nodes = t();
-        if (tried.has(id([d, nodes.map(n => n.name)])))
+        if (tried.has(id([d, nodes.map(n => n.name), quad])))
             continue;
-        tried.add(id([d, nodes.map(n => n.name)]));
-        const out = attempt(nodes, d);
+        tried.add(id([d, nodes.map(n => n.name), quad]));
+        const out = attempt(nodes, d, quad);
         if (out.proven || out.stuck === 'sat' && out.why)
             return out;
         last = out;
@@ -803,38 +1020,168 @@ export function findRank(l, laws = [], opts = {}) {
             }
         }
     const samples = [[...points.values()].map(env => ({ env, calls: new Set() }))];
-    const { comps } = lexRanks([0], [node], samples, [...edges.values()], shared, until);
-    if (!comps.length)
-        return { proven: false, checked: false, why: `no linear rank, in order, drops on every turn of ${edges.size} sampled` };
-    const rank = comps.map(c => compE(c, 0, node, shared)), text = `(${rank.map(showE).join(', ')})`;
-    const first = withDeadline(until, () => goalsProven(loopObligations(l, laws, rank)));
-    if ('trees' in first)
-        return { proven: true, checked: true, rank, laws: [], found: { rank: text, laws: [] }, trees: first.trees };
-    // Invariants the rank needs: the descent as the loop's step laws, inferLaws's candidates chosen by its counterexamples.
-    const m = loopMachine(l), { stay, cover, helps } = livenessParts(m, loopLiveness(l, rank));
+    const { comps, left } = lexRanks([0], [node], samples, [...edges.values()], shared, until);
+    // Ranks of degree 2 where the linear one leaves turns or the kernel refuses it (while i < N·M: N·M − i, where the runs
+    // alone give 299 − i): one product of two variables at a time. The products the loop's own terms read first (a rank
+    // of degree 2 measures what its terms of degree 2 bound), before the invariants; the others after them, within a
+    // quarter of the time.
+    const read = productsIn([l.while, l.body, l.state, l.pre ?? yes, l.assume ?? yes]).filter(([x, y]) => names.includes(x) && names.includes(y));
+    const rest = products(names).filter(p => !read.some(r => id(r) === id(p)));
+    const seen = new Set();
+    const quadratic = (ps, until) => {
+        const out = [];
+        for (const p of ps) {
+            if (performance.now() > until)
+                break;
+            const d = withProducts([node], samples, [...edges.values()], [p]), r = lexRanks([0], d.nodes, d.samples, d.edges, shared, until);
+            if (!r.comps.length || r.left)
+                continue;
+            const r2 = r.comps.map(c => compE(c, 0, d.nodes[0], shared));
+            if (seen.has(id(r2)))
+                continue;
+            seen.add(id(r2));
+            const verdict = withDeadline(until, () => goalsProven(loopObligations(l, laws, r2)));
+            if (trace)
+                console.error(`[cycles] ${l.name}: degree 2 with ${featName(p)}: (${r2.map(showE).join(', ')}) ${'trees' in verdict ? 'proven' : verdict.goal}`);
+            out.push({ rank: r2, verdict });
+            if ('trees' in verdict)
+                break;
+        }
+        return out;
+    };
+    const done = (rank, trees, more = [], texts = []) => ({ proven: true, checked: true, rank, laws: more, found: { rank: `(${rank.map(showE).join(', ')})`, laws: texts }, trees });
+    // The linear rank first, then those of degree 2 over the products the loop reads, each checked in turn.
+    const linear = comps.map(c => compE(c, 0, node, shared));
+    let tried = [];
+    if (comps.length && !left) {
+        seen.add(id(linear));
+        tried.push({ rank: linear, verdict: withDeadline(until, () => goalsProven(loopObligations(l, laws, linear))) });
+    }
+    tried.push(...quadratic(read, until));
+    const won = tried.find(t => 'trees' in t.verdict);
+    if (won && 'trees' in won.verdict)
+        return done(won.rank, won.verdict.trees);
+    if (!tried.length && comps.length)
+        tried.push({ rank: linear, verdict: withDeadline(until, () => goalsProven(loopObligations(l, laws, linear))) });
+    // Invariants the rank needs: the descent as the loop's step laws, inferLaws's candidates chosen by its counterexamples
+    // (within half the time left where products remain to be tried after them).
+    const base = tried[0];
+    if (base && !('trees' in base.verdict)) {
+        const rank = base.rank, m = loopMachine(l), { stay, cover, helps } = livenessParts(m, loopLiveness(l, rank));
+        const ms = (until - performance.now()) * (rest.length ? 0.5 : 1);
+        if (ms > 300) {
+            const inf = inferLaws(m, laws, [stay, cover, ...helps], { ms });
+            const kept = inf.found.filter(f => !f.law.forall && !f.law.keys?.length), more = kept.map(f => f.law);
+            if (inf.proven && more.length) {
+                const all = [...laws, ...more], again = withDeadline(until + 5000, () => goalsProven(loopObligations(l, all, rank)));
+                if ('trees' in again)
+                    return done(rank, again.trees, more, kept.map(f => f.text));
+            }
+        }
+    }
+    // (the products the loop doesn't read within a quarter of its time: a search that fails tries each of them)
+    tried = quadratic(rest, Math.min(until, performance.now() + (opts.ms ?? 10_000) / 4));
+    const late = tried.find(t => 'trees' in t.verdict);
+    if (late && 'trees' in late.verdict)
+        return done(late.rank, late.verdict.trees);
+    if (!base || 'trees' in base.verdict)
+        return { proven: false, checked: false, why: `no rank, linear or of degree 2, in order, drops on every turn of ${edges.size} sampled` };
+    const text = `(${base.rank.map(showE).join(', ')})`, first = base.verdict;
+    return { proven: false, checked: false, rank: base.rank, found: { rank: text, laws: [] }, goal: first.goal, stuck: first.stuck, ...(first.witness ? { witness: first.witness } : {}), why: `rank ${text} from the runs; no invariant found that it needs` };
+}
+export function findLeadsTo(m, laws, l, sample, opts = {}) {
+    const t0 = performance.now(), until = t0 + (opts.ms ?? 10_000), rand = seeded(29), run = interpret(m);
+    const names = [...Object.keys(m.state), ...m.params].sort(), helpful = livenessHelpful(l);
+    const node = { name: l.name, hyps: [], concl: yes, vars: names, level: 0, given: true };
+    const env = (ps, st) => ({ ...ps, ...st.scalars });
+    const holds = (c, ps, st) => { try {
+        return evalMC(c, env(ps, st), st, m);
+    }
+    catch {
+        return undefined;
+    } };
+    const pending = (ps, st) => holds(l.from, ps, st) === true && holds(l.to, ps, st) === false;
+    const points = new Map(), strong = new Map(), weak = new Map();
+    for (const bound of [2, 4, 8, 16])
+        for (let trial = 0; trial < 20 && performance.now() < t0 + 1000; trial++) {
+            let ps;
+            try {
+                ps = sample.params(rand, bound);
+            }
+            catch {
+                continue;
+            }
+            if (m.pre && holds(m.pre, ps, { scalars: {}, maps: {} }) !== true)
+                continue;
+            let st;
+            try {
+                st = run.init(ps);
+            }
+            catch {
+                continue;
+            }
+            for (let turn = 0; turn < 120; turn++) {
+                const here = env(ps, st), was = pending(ps, st);
+                if (was)
+                    points.set(id(here), here);
+                // A helpful request in its region half the time (its named inputs at the state, the rest drawn), else any.
+                const regions = helpful.filter(h => holds(h.when, ps, st) === true), h = regions.length && rand(2) ? regions[rand(regions.length)] : undefined;
+                let next;
+                for (let tries = 0; tries < 20 && !next; tries++) {
+                    try {
+                        const input = sample.input(rand, bound, ps);
+                        if (h)
+                            for (const [x, t] of Object.entries(h.request))
+                                input[x] = evalME(t, here, st, m);
+                        next = run.step(ps, st, input);
+                    }
+                    catch { /* refused: another */ }
+                }
+                if (!next)
+                    break;
+                if (was && pending(ps, next)) {
+                    const e = { from: 0, to: 0, s: here, t: env(ps, next) };
+                    (h ? strong : weak).set(id([e.s, e.t]), e);
+                }
+                st = next;
+            }
+        }
+    const samples = [[...points.values()].map(env => ({ env, calls: new Set() }))];
+    const { comps, left } = lexRanks([0], [node], samples, [...strong.values()], shared, until, false, [...weak.values()]);
+    if (!comps.length || left)
+        return { proven: false, checked: false, why: `no linear rank, in order, that ${strong.size} helpful steps sampled lower and ${weak.size} others keep` };
+    const rank = comps.map(c => compE(c, 0, node, shared)), text = `(${rank.map(showE).join(', ')})`, lv = { ...l, rank };
+    const first = withDeadline(until, () => proveLiveness(m, laws, lv));
+    if (first.proven && first.checked)
+        return { proven: true, checked: true, rank, laws: [], found: { rank: text, laws: [] } };
     const ms = until - performance.now();
     if (ms > 300) {
-        const inf = inferLaws(m, laws, [stay, cover, ...helps], { ms });
+        const { stay, cover, helps } = livenessParts(m, lv), inf = inferLaws(m, laws, [stay, cover, ...helps], { ms });
         const kept = inf.found.filter(f => !f.law.forall && !f.law.keys?.length), more = kept.map(f => f.law);
         if (inf.proven && more.length) {
-            const all = [...laws, ...more], again = withDeadline(until + 5000, () => goalsProven(loopObligations(l, all, rank)));
-            if ('trees' in again)
-                return { proven: true, checked: true, rank, laws: more, found: { rank: text, laws: kept.map(f => f.text) }, trees: again.trees };
+            const again = withDeadline(until + 5000, () => proveLiveness(m, [...laws, ...more], lv));
+            if (again.proven && again.checked)
+                return { proven: true, checked: true, rank, laws: more, found: { rank: text, laws: kept.map(f => f.text) } };
         }
     }
-    return { proven: false, checked: false, rank, found: { rank: text, laws: [] }, goal: first.goal, stuck: first.stuck, ...(first.witness ? { witness: first.witness } : {}), why: `rank ${text} from the runs; no invariant found that it needs` };
+    return { proven: false, checked: false, rank, found: { rank: text, laws: [] }, ...(first.failed ? { goal: first.failed.goal, stuck: first.failed.stuck, ...(first.failed.witness ? { witness: first.failed.witness } : {}) } : {}), why: `rank ${text} from the runs; the kernel's goals not proven with it` };
 }
 export function cycleLemmas(m, laws, stepLaws = [], opts = {}) {
     const until = performance.now() + (opts.ms ?? 10_000);
     const fns = Object.entries(m.fns ?? {}).filter(([, f]) => !f.recur && (f.arity ?? 1) === 1);
-    if (!fns.length || !m.facts?.length)
+    const fns2 = Object.entries(m.fns ?? {}).filter(([, f]) => !f.recur && f.arity === 2 && f.call);
+    if ((!fns.length && !fns2.length) || !m.facts?.length)
         return { proven: false, checked: false, found: [], why: 'no function known by its facts' };
     const facts = m.facts.map(f => ({ name: f.name, keys: [...(f.forall ? [f.forall] : []), ...(f.keys ?? [])], holds: f.holds }));
     const values = {};
     for (const [name, f] of fns)
         values[name] = (q) => fnValue(f, q);
+    for (const [name, f] of fns2) {
+        const g = compileFunction([], `return (${f.call})`)();
+        values[name] = (a, b) => g(a, b);
+    }
     const ts = [...new Set(constsOf([m, laws, stepLaws]).filter(c => c >= 0 && c <= 1000).flatMap(c => [c - 1, c, c + 1]).filter(c => c >= 0))].sort((a, b) => a - b);
-    const big = Math.max(24, ...ts), x = 'k$', claims = [];
+    const big = Math.max(24, ...ts), x = 'k$', y = 'j$', claims = [];
     for (const [name] of fns) {
         const f = values[name];
         if (!f)
@@ -872,14 +1219,72 @@ export function cycleLemmas(m, laws, stepLaws = [], opts = {}) {
         if (vals.slice(vals.length >> 1).includes(top))
             claims.push({ name: `${name}(k) ≤ ${top}`, concl: le(read, k(top)) });
     }
-    const unique = [...new Map(claims.map(c => [c.name, c])).values()];
-    if (!unique.length)
-        return { proven: false, checked: false, found: [], why: 'no lemma fits the values' };
-    const out = findCycles(facts, unique, { ms: Math.max(0, until - performance.now()) * 0.6, values, houdini: true, generalize: false });
-    if (!out.proven || !out.checked || !out.kept?.length)
+    // A function of two arguments: over a grid of both, the line that fits exactly, and each bound by 0, either argument or
+    // their sum plus the tightest constant (above, and below where it is one): a constant above only where the values
+    // reach it below half the grid in both arguments (not the grid's own size).
+    for (const [name] of fns2) {
+        const f = values[name], B = Math.min(big, 24), pts = [];
+        for (let a = 0; a <= B; a++)
+            for (let b = 0; b <= B; b++) {
+                let z;
+                try {
+                    z = f(a, b);
+                }
+                catch {
+                    continue;
+                }
+                if (Number.isSafeInteger(z) && z >= 0)
+                    pts.push({ env: { [x]: a, [y]: b }, value: z });
+            }
+        if (pts.length < 16)
+            continue;
+        const read = get(name, argsKey([v(x), v(y)])), show = (l, c) => showE(linE(Object.fromEntries(Object.entries(l).map(([n, q]) => [n === x ? 'k' : 'j', q])), c));
+        const line = fitExact([x, y], pts, until);
+        if (line) {
+            claims.push({ name: `${name}(k, j) = ${show(line.coef, line.c)}`, concl: eqC(read, linE(line.coef, line.c)) });
+            continue;
+        }
+        for (const form of [{}, { [x]: 1 }, { [y]: 1 }, { [x]: 1, [y]: 1 }]) {
+            const at = (p) => Object.entries(form).reduce((acc, [n, q]) => acc + q * p.env[n], 0);
+            const d = Math.max(...pts.map(p => p.value - at(p))), lo = Math.min(...pts.map(p => p.value - at(p)));
+            const reached = pts.some(p => p.value - at(p) === d && p.env[x] <= B / 2 && p.env[y] <= B / 2);
+            if (Object.keys(form).length ? d <= 0 || reached : reached)
+                claims.push({ name: `${name}(k, j) ≤ ${show(form, d)}`, concl: d >= 0 ? le(read, linE(form, d)) : le(add(read, k(-d)), linE(form, 0)) });
+            if (Object.keys(form).length && lo >= 0)
+                claims.push({ name: `${name}(k, j) ≥ ${show(form, lo)}`, concl: le(linE(form, lo), read) });
+        }
+    }
+    // Those of two arguments each proven alone (their keys are pairings, products: a goal that reads several such claims
+    // at once is slow to refute), the rest together; the proof the nodes of each, side by side (no node of one uses
+    // another's).
+    const unique = [...new Map(claims.map(c => [c.name, c])).values()], two = (c) => m.fns?.[readsOf(c.concl)[0]?.map ?? '']?.arity === 2;
+    const proofs = new Map();
+    for (const c of unique.filter(two)) {
+        if (performance.now() >= until)
+            break;
+        const o = findCycles(facts, [c], { ms: Math.min(1000, (until - performance.now()) * 0.1), values, houdini: true, generalize: false });
+        if (o.proven && o.checked && o.proof)
+            proofs.set(c.name, o.proof);
+    }
+    const ones = unique.filter(c => !two(c));
+    if (!ones.length && !proofs.size)
+        return { proven: false, checked: false, found: [], why: unique.length ? 'no lemma proven' : 'no lemma fits the values' };
+    const out = ones.length ? findCycles(facts, ones, { ms: Math.max(0, until - performance.now()) * 0.6, values, houdini: true, generalize: false }) : { proven: true, checked: true, kept: [] };
+    if ((!out.proven || !out.checked || !out.kept?.length) && !proofs.size)
         return { proven: false, checked: false, found: [], why: out.why ?? 'no lemma proven' };
-    const asLaw = (c) => ({ law: { name: c.name, forall: x, holds: c.hyps?.length ? { op: 'or', xs: [{ op: 'not', x: and(...c.hyps) }, c.concl] } : c.concl }, text: c.name });
-    let found = unique.filter(c => out.kept.includes(c.name)).map(asLaw);
+    const kept = [...(out.proven && out.checked ? out.kept ?? [] : []), ...proofs.keys()];
+    const sideBySide = (ps) => {
+        if (!ps.length)
+            return undefined;
+        let at = 0;
+        const nodes = ps.flatMap(p => { const off = at; at += p.nodes.length; return p.nodes.map(n => ({ ...n, uses: n.uses.map(u => ({ ...u, node: u.node + off })) })); });
+        return { facts: ps[0].facts, nodes };
+    };
+    const asLaw = (c) => {
+        const holds = c.hyps?.length ? { op: 'or', xs: [{ op: 'not', x: and(...c.hyps) }, c.concl] } : c.concl;
+        return { law: { name: c.name, forall: x, ...(varsOf(holds).includes(y) ? { keys: [y] } : {}), holds }, text: c.name };
+    };
+    let found = unique.filter(c => kept.includes(c.name)).map(asLaw);
     const proveWith = (fs) => {
         const mm = { ...m, facts: [...m.facts, ...fs.map(f => f.law)] };
         const r = withDeadline(until, () => (stepLaws.length ? proveStepLaws(mm, laws, stepLaws) : proveLaws(mm, laws)));
@@ -895,5 +1300,7 @@ export function cycleLemmas(m, laws, stepLaws = [], opts = {}) {
         if (again.ok)
             (found = rest, best = again);
     }
-    return { proven: true, checked: true, machine: best.machine, found, ...(out.proof ? { proof: out.proof } : {}) };
+    const merged = sideBySide([...(out.proof && found.some(f => ones.some(c => c.name === f.text)) ? [out.proof] : []), ...found.flatMap(f => (proofs.has(f.text) ? [proofs.get(f.text)] : []))]);
+    const proof = merged && checkCyclic(merged) ? merged : undefined;
+    return { proven: true, checked: true, machine: best.machine, found, ...(proof ? { proof } : {}) };
 }