gdp-wired 0.18.0 → 0.20.0

package/dist/core/discover.js

@@ -83,8 +83,8 @@ function linearCands(target, forms, samples, show) {
     return dedupe(out.filter(c => samples.every(s => holds(c, s))));
 }
 const dedupe = (cs) => [...new Map(cs.map(c => [c.name, c])).values()];
-// A polynomial in x of degree 2 at most, exact over the rationals, as d·f = a·x·x + b·x + c with whole numbers: fitted to
-// three points, kept when every sample meets it.
+// A polynomial in x of degree 3 at most, exact over the rationals, as d·f = a·x·x·x + b·x·x + c·x + e with whole
+// numbers: fitted to four points (Newton's differences), kept when every sample meets it.
 function closedForm(samples, show) {
     const at = new Map();
     for (const s of samples) {
@@ -95,22 +95,30 @@ function closedForm(samples, show) {
     if (![0, 1, 2].every(x => at.has(x)))
         return [];
     const [f0, f1, f2] = [at.get(0), at.get(1), at.get(2)];
+    const keep = (lin) => {
+        const g = Object.values(lin).reduce((p, q) => gcd(p, Math.abs(q)), 0);
+        const c = { name: '', rel: '=', lin: Object.fromEntries(Object.entries(lin).map(([a, k]) => [a, k / g]).filter(([, k]) => k !== 0)) };
+        c.name = nameOf(c, show, 'f');
+        return samples.every(s => holds(c, s)) ? [c] : [];
+    };
     // f = a x² + b x + c: c = f0, a = (f2 - 2 f1 + f0) / 2, b = f1 - f0 - a; times 2 to keep whole numbers.
     const A = f2 - 2 * f1 + f0, B = 2 * (f1 - f0) - A, C = 2 * f0;
-    if (A === 0)
-        return []; // linear: the bounds find it
-    const g = [A, B, C, 2].reduce((p, q) => gcd(p, Math.abs(q)), 0);
-    const c = { name: '', rel: '=', lin: Object.fromEntries(Object.entries({ f: 2 / g, xx: -A / g, x: -B / g, 1: -C / g }).filter(([, k]) => k !== 0)) };
-    c.name = nameOf(c, show, 'f');
-    return samples.every(s => holds(c, s)) ? [c] : [];
+    const square = A === 0 ? [] : keep({ f: 2, xx: -A, x: -B, 1: -C });
+    if (square.length || !at.has(3))
+        return square;
+    // f = Δ0 + Δ1·x + Δ2·x(x − 1)/2 + Δ3·x(x − 1)(x − 2)/6, times 6: x³ by Δ3, x² by 3Δ2 − 3Δ3, x by 6Δ1 − 3Δ2 + 2Δ3.
+    const d1 = f1 - f0, d2 = f2 - 2 * f1 + f0, d3 = at.get(3) - 3 * f2 + 3 * f1 - f0;
+    if (d3 === 0)
+        return []; // degree 2 at most: above, or linear (the bounds find it)
+    return keep({ f: 6, xxx: -d3, xx: -(3 * d2 - 3 * d3), x: -(6 * d1 - 3 * d2 + 2 * d3), 1: -6 * f0 });
 }
 // The law a goal is of (the kernel names each goal after its law: '<law> @step').
 const lawOfGoal = (goal) => goal.replace(/ @(start|step|step law|\d+ steps|leaf|node)$/, '');
 const isGoalOf = (goal) => (c) => { const law = lawOfGoal(goal); return law === c.name || law === `${c.name} at y`; };
 const gcd = (a, b) => (b === 0 ? Math.abs(a) : gcd(b, a % b));
 // --- recurrences ---------------------------------------------------------------------------------------------------
-const showRecur = (a) => (a === 'f' ? 'f(x)' : a === 'g' ? 'f(y)' : a === 'xx' ? 'x·x' : a);
-const srcRecur = (a) => (a === 'xx' ? 'x.mul(x)' : a);
+const showRecur = (a) => (a === 'f' ? 'f(x)' : a === 'g' ? 'f(y)' : a === 'xx' ? 'x·x' : a === 'xxx' ? 'x·x·x' : a);
+const srcRecur = (a) => (a === 'xx' ? 'x.mul(x)' : a === 'xxx' ? 'x.mul(x).mul(x)' : a);
 // The function's values: x from 0 to 40 at a few values of each further argument (all of them for two at most).
 function recurSamples(d, args) {
     const f = (typeof d.js === 'function' ? d.js : compileFunction([], `return (${d.js})`)());
@@ -128,7 +136,7 @@ function recurSamples(d, args) {
                     break;
                 throw e;
             }
-            out.push({ x, f: y, xx: x * x, ...Object.fromEntries(args.map((a, i) => [a, t[i]])) });
+            out.push({ x, f: y, xx: x * x, xxx: x * x * x, ...Object.fromEntries(args.map((a, i) => [a, t[i]])) });
         }
     return out;
 }
@@ -167,9 +175,9 @@ function recurCands(samples, args) {
         c.name = nameOf(c, showRecur, 'g');
     return { lemmas, between };
 }
-const recurAtoms = (args, x, f, env, y, g) => ({ x, f, xx: x.mul(x), ...(y && g ? { y, g } : {}), ...Object.fromEntries(args.map(a => [a, env[a]])) });
+const recurAtoms = (args, x, f, env, y, g) => ({ x, f, xx: x.mul(x), xxx: x.mul(x).mul(x), ...(y && g ? { y, g } : {}), ...Object.fromEntries(args.map(a => [a, env[a]])) });
 const recurSrc = (c, args, between) => {
-    const reads = (a) => Object.keys(c.lin).includes(a) || (a === 'x' && 'xx' in c.lin);
+    const reads = (a) => Object.keys(c.lin).includes(a) || (a === 'x' && ('xx' in c.lin || 'xxx' in c.lin));
     const names = between ? ['x', 'f', 'y', 'g'] : ['x', 'f'];
     let unused = 0;
     const params = [...names.map(n => (reads(n) ? n : '_'.repeat(++unused))), ...(args.some(reads) ? [`{${args.filter(reads).join(', ')}}`] : [])];
@@ -268,27 +276,40 @@ 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);
-    // Per function and per list: what is proven, made into the rule.
-    const fnMade = {};
-    for (const [n, d] of fns) {
-        const src = recurOf(d);
-        if (!src)
-            continue;
-        const args = [...(src.def.args ?? [])], { lemmas, between } = recurCands(recurSamples(d, args), args);
-        const made = houdiniRecur(d, lemmas, between);
-        if (made && (made.lemmas.length || made.between.length))
-            fnMade[n] = made;
-    }
-    let rule = r.withParts(Object.fromEntries(Object.entries(fnMade).map(([n, m]) => [n, m.d])));
-    const listKept = {};
-    for (const part of lists) {
-        const out = houdiniList(rule, part, listCands(part, params, listSamples(part, params)), ps);
-        if (out && out.kept.length) {
-            rule = out.rule;
-            listKept[part[0]] = out.kept;
+    // Per function and per list: what is proven, made into the rule. A function with a closed form (of degree 2 or 3,
+    // fitted exactly) first with it alone: it decides the function, and the bounds beside it, which the closed form
+    // implies only through products, are slow to prove by induction; the rest where the laws aren't proven with it.
+    const cands = new Map(fns.flatMap(([n, d]) => { const src = recurOf(d); if (!src)
+        return []; const args = [...(src.def.args ?? [])]; return [[n, recurCands(recurSamples(d, args), args)]]; }));
+    const exact = (c) => c.rel === '=' && ('xx' in c.lin || 'xxx' in c.lin);
+    const makeFns = (closedOnly) => {
+        const out = {};
+        for (const [n, d] of fns) {
+            const cs = cands.get(n);
+            if (!cs)
+                continue;
+            const closed = cs.lemmas.filter(exact), made = closedOnly && closed.length ? houdiniRecur(d, closed, []) : houdiniRecur(d, cs.lemmas, cs.between);
+            if (made && (made.lemmas.length || made.between.length))
+                out[n] = made;
         }
-    }
-    const verdict = proveSteps(rule, laws, stepLaws, { search: false });
+        return out;
+    };
+    const withLists = (fnMade) => {
+        let rule = r.withParts(Object.fromEntries(Object.entries(fnMade).map(([n, m]) => [n, m.d])));
+        const listKept = {};
+        for (const part of lists) {
+            const out = houdiniList(rule, part, listCands(part, params, listSamples(part, params)), ps);
+            if (out && out.kept.length) {
+                rule = out.rule;
+                listKept[part[0]] = out.kept;
+            }
+        }
+        return { fnMade, rule, listKept, verdict: proveSteps(rule, laws, stepLaws, { search: false }) };
+    };
+    let made = [...cands.values()].some(cs => cs.lemmas.some(exact)) ? withLists(makeFns(true)) : undefined;
+    if (!made || !(made.verdict.proven && made.verdict.checked))
+        made = withLists(makeFns(false));
+    const { fnMade, rule, listKept, verdict } = made;
     const found = () => ({
         ...Object.fromEntries(Object.entries(fnMade).map(([n, m]) => { const args = [...(recurOf(m.d).def.args ?? [])]; return [n, { ...(m.lemmas.length ? { lemmas: m.lemmas.map(c => recurSrc(c, args, false)) } : {}), ...(m.between.length ? { between: m.between.map(c => recurSrc(c, args, true)) } : {}) }]; })),
         ...Object.fromEntries(Object.entries(listKept).map(([n, cs]) => [n, { lemmas: cs.map(c => listSrc(c, Object.keys(lists.find(l => l[0] === n)[2]), ps, c.target)) }])),

package/dist/core/dsl.d.ts

@@ -594,7 +594,7 @@ export declare class Rule<P extends Obj = {}, I extends Obj = {}, S extends Obj
     leadsTo(name: string, spec: {
         from: (env: P & S & M & Su) => Cond;
         to: (env: P & S & M & Su) => Cond;
-        rank: (env: P & S & M & Su) => TermLike | TermLike[];
+        rank?: (env: P & S & M & Su) => TermLike | TermLike[];
         helpful: ((env: P & S & M & Su) => Record<string, TermLike>) | {
             when?: (env: P & S & M & Su) => Cond;
             request: (env: P & S & M & Su) => Record<string, TermLike>;
@@ -828,7 +828,9 @@ export declare function proveRule(r: Rule<Obj, Obj, Obj, Obj, Obj, Obj, Obj, Obj
 export declare function proveSteps(r: Rule<Obj, Obj, Obj, Obj, Obj, Obj, Obj, Obj>, laws: Law[], stepLaws: StepLaw[], opts?: ProveOptions): Verdict;
 export type { StepLaw };
 export type { Liveness };
-export declare function proveLeadsTo(r: Rule<Obj, Obj, Obj, Obj, Obj, Obj, Obj, Obj>, laws: Law[], l: Liveness): Verdict;
+export declare function proveLeadsTo(r: Rule<Obj, Obj, Obj, Obj, Obj, Obj, Obj, Obj>, laws: Law[], l: Liveness, opts?: {
+    ms?: number;
+}): Verdict;
 export declare const proveDecision: (d: Decision) => Verdict;
 export declare function crossCheckDecision(d: Decision, opts?: {
     trials?: number;

package/dist/core/dsl.js

@@ -18,11 +18,11 @@
 import { carriedView, compileFunction, evalC, evalE, interpret, loadJs, numbersOf, pairedArgs } from "./machine.js";
 import { allowed, keysOf, requestEnv, watch } from "./watch.js";
 import { check, foldObligations, loopObligations } from "../kernel/kernel.js";
-import { factsFor, grow, proveLaws, proveLiveness, proveStepLaws, withDeadline } from "../kernel/prove.js";
-import { crossCyclic, cyclicOn, foldNodes, proveCyclic, quietly, recurNodes } from "./cyclic.js";
+import { factsFor, grow, proveLaws, proveLiveness, proveStepLaws, usualProof, withDeadline } from "../kernel/prove.js";
+import { certCyclic, certOn, crossCyclic, cyclicOn, foldNodes, proveCyclic, quietly, recurNodes, translatedProof, uncovered } from "./cyclic.js";
 import { discover } from "./discover.js";
 import { inferLaws } from "./infer.js";
-import { cycleLemmas, findRank } from "./cycles.js";
+import { cycleLemmas, findLeadsTo, findRank } from "./cycles.js";
 // --- terms and conditions -------------------------------------------------------------------------------------------
 const naturalConst = (v) => {
     if (!Number.isSafeInteger(v) || v < 0)
@@ -1410,6 +1410,10 @@ export const recur = (name, def, lemmas = {}, between = {}) => {
     // The lemmas: x counting up from 0 and fx its value, each lemma a law of that machine.
     let verdict = { proven: true, checked: true };
     const proofs = {};
+    // The usual proofs, to translate (core/cyclic.ts's recurNodes): the lemmas' machine's, the laws between's.
+    let lemmaProof;
+    const translatedRecur = (u) => (u.lemmas || !stated.length)
+        ? st => translatedProof(() => JSON.stringify(['recurrence', recurCase(u.between ? pairs : [])]), () => recurNodes(recurCase(u.between ? pairs : []), u, st), st) : undefined;
     if (stated.length) {
         // A start that reads a function is a param given as that start by a fact (a start reads the params alone).
         const zeroReads = JSON.stringify(zero).includes('"op":"get"');
@@ -1421,9 +1425,17 @@ export const recur = (name, def, lemmas = {}, between = {}) => {
         const laws = Object.entries(lemmas).map(([n, f]) => r.law(n, (env) => f(env.x, env.fx, envAt(args.map(a => env[a])))));
         // (Its machine's proof timed alone: the recurrence is compared below as its own instance.)
         const t0 = performance.now();
+        usualProof.last = undefined;
         verdict = quietly(() => proveRule(r, laws, { search: false }));
+        lemmaProof = usualProof.last;
         if (cyclicOn())
-            crossCyclic('recurrence', name, verdict.proven && verdict.checked, () => { const { facts, specs } = recurNodes(recurCase([])); return proveCyclic(facts, specs); }, performance.now() - t0);
+            crossCyclic('recurrence', name, verdict.proven && verdict.checked, () => { const { facts, specs } = recurNodes(recurCase([])); return proveCyclic(facts, specs); }, performance.now() - t0, translatedRecur({ lemmas: lemmaProof }));
+        // (the usual trees checked already, inside quietly: where no cyclic proof is made they are the certificate)
+        if (certOn() && verdict.proven && verdict.checked) {
+            const c = certCyclic('recurrence', name, translatedRecur({ lemmas: lemmaProof }), () => { const { facts, specs } = recurNodes(recurCase([])); return proveCyclic(facts, specs); }, performance.now() - t0);
+            if (!c.checked)
+                uncovered('recurrence', name, c.why);
+        }
         failed('lemmas', verdict);
         proofs.lemmas = { machine: r.machine, laws };
     }
@@ -1460,9 +1472,15 @@ export const recur = (name, def, lemmas = {}, between = {}) => {
             .step((env) => ({ y: env.y.plus(1), fy: def.next(env.y, env.fy, envAt(at(env))) }));
         const laws = [...Object.entries(lemmas).map(([n, l]) => r.law(`${n} at y`, (env) => l(env.y, env.fy, envAt(at(env))))),
             ...Object.entries(between).map(([n, l]) => r.law(n, (env) => l(env.x, env.fx, env.y, env.fy, envAt(at(env)))))];
-        const t0 = performance.now(), v = quietly(() => proveRule(r, laws, { search: false })), usualMs = performance.now() - t0;
+        usualProof.last = undefined;
+        const t0 = performance.now(), v = quietly(() => proveRule(r, laws, { search: false })), usualMs = performance.now() - t0, betweenProof = usualProof.last;
         if (cyclicOn())
-            crossCyclic('recurrence, between', name, v.proven && v.checked, () => { const { facts, specs } = recurNodes(recurCase(pairs)); return proveCyclic(facts, specs); }, usualMs);
+            crossCyclic('recurrence, between', name, v.proven && v.checked, () => { const { facts, specs } = recurNodes(recurCase(pairs)); return proveCyclic(facts, specs); }, usualMs, betweenProof && translatedRecur({ lemmas: lemmaProof, between: betweenProof }));
+        if (certOn() && v.proven && v.checked) {
+            const c = certCyclic('recurrence, between', name, betweenProof && translatedRecur({ lemmas: lemmaProof, between: betweenProof }), () => { const { facts, specs } = recurNodes(recurCase(pairs)); return proveCyclic(facts, specs); }, usualMs);
+            if (!c.checked)
+                uncovered('recurrence, between', name, c.why);
+        }
         failed('laws between two points', v);
         proofs.between = { machine: r.machine, laws };
         verdict = { proven: true, checked: verdict.checked && v.checked };
@@ -1828,10 +1846,11 @@ export class Rule {
     //     rank: ({t, served}) => t.plus(1).minus(served), helpful: () => ({op: 1})})
     //   batches.leadsTo('every batch is done', {from: () => yes, to: ({waiting, items}) => waiting.eq(0).and(items.eq(0)),
     //     rank: ({waiting, items}) => [waiting, items], helpful: [{when: ({items}) => items.gt(0), request: () => ({op: 1})}, {when: ({items}) => items.eq(0), request: () => ({op: 0})}]})
+    // With no rank, proveLeadsTo finds one from the rule's runs (core/cycles.ts's findLeadsTo).
     leadsTo(name, spec) {
         const env = this.env({ flags: false, inputs: false, queries: false });
         const req = (f) => Object.fromEntries(Object.entries(f(env)).map(([n, t]) => [n, termOf(t)]));
-        const r = spec.rank(env), rank = Array.isArray(r) ? r.map(termOf) : termOf(r);
+        const r = spec.rank ? spec.rank(env) : [], rank = Array.isArray(r) ? r.map(termOf) : termOf(r);
         const base = { name, from: spec.from(env).c, to: spec.to(env).c, rank };
         return typeof spec.helpful === 'function' ? { ...base, request: req(spec.helpful) } : { ...base, helpful: spec.helpful.map(h => ({ ...(h.when ? { when: h.when(env).c } : {}), request: req(h.request) })) };
     }
@@ -2504,7 +2523,7 @@ export class Unproven extends Error {
         this.verdict = verdict;
     }
 }
-const goalsVerdict = (goals) => {
+const goalsVerdict = (goals, checkIt = true) => {
     const trees = {};
     for (const g of goals) {
         const out = grow(g);
@@ -2512,7 +2531,7 @@ const goalsVerdict = (goals) => {
             return { proven: false, checked: false, goal: g.name, stuck: out.stuck, ...(out.witness ? { witness: out.witness } : {}), ...(out.why ? { why: out.why } : {}) };
         trees[g.name] = out.tree;
     }
-    return { proven: true, checked: goals.every(g => check(g, trees[g.name])), trees };
+    return { proven: true, checked: !checkIt || goals.every(g => check(g, trees[g.name])), trees };
 };
 // The kinds' laws first, those the caller didn't pass already (by name).
 const withKinds = (r, laws) => [...r.kindLaws().filter(k => !laws.some(l => l.name === k.name)), ...laws];
@@ -2643,7 +2662,12 @@ function searched(r, laws, stepLaws, v, opts) {
     void _stats;
     return { ...verdict, found: { laws: found, ...(lemmas ? { lemmas } : {}) } };
 }
-export function proveLeadsTo(r, laws, l) {
+export function proveLeadsTo(r, laws, l, opts = {}) {
+    if (Array.isArray(l.rank) && !l.rank.length) {
+        const f = findLeadsTo(r.machine, withKinds(r, laws), l, { params: (rand, bound) => r.randomParams(rand, bound), input: (rand, bound, ps) => r.randomInput(rand, bound, ps) }, opts);
+        return { proven: f.proven, checked: f.checked, ...(f.goal ? { goal: f.goal, stuck: f.stuck } : {}), ...(f.witness ? { witness: f.witness } : {}), ...(f.why ? { why: f.why } : {}),
+            ...(f.found ? { found: { rank: f.found.rank, ...(f.laws?.length ? { laws: f.laws.map((law, i) => ({ law, text: f.found.laws[i] ?? law.name })) } : {}) } } : {}) };
+    }
     const out = proveLiveness(r.machine, withKinds(r, laws), l);
     return { proven: out.proven, checked: out.checked, ...(out.failed ? { goal: out.failed.goal, stuck: out.failed.stuck, ...(out.failed.witness ? { witness: out.failed.witness } : {}), ...(out.failed.why ? { why: out.failed.why } : {}) } : {}) };
 }
@@ -2679,6 +2703,8 @@ export function crossCheckDecision(d, opts = {}) {
 // With no rank stated, the rank is searched for from the loop's runs (core/cycles.ts's findRank), with the invariants it
 // needs (inferLaws), within `ms` (10 s); the verdict is the kernel's on the rank and the laws found, in `found`.
 export const proveLoop = (l, laws, opts = {}) => {
+    if (cyclicOn() || certOn())
+        uncovered('loop', l.loop.name, 'a claim about runs that never end');
     if (l.hasRank)
         return goalsVerdict(loopObligations(l.loop, laws, l.rankTerms));
     const out = findRank(l.loop, laws, opts);
@@ -2800,9 +2826,18 @@ export class FoldRule {
 export const fold = (name) => new FoldRule({ name, params: [], inputs: [], pre: [], assume: [] });
 // A fold's laws proven over every tree (a rose fold's own laws, its children's lemmas, with them).
 export const proveFold = (f, laws) => {
-    const all = [...(f.lemmas ?? []), ...laws], t0 = performance.now(), v = goalsVerdict(foldObligations(f.fold, all)), usualMs = performance.now() - t0;
+    // (by default the certificate a cyclic proof, core/cyclic.ts's certCyclic, the usual trees its input; where none is
+    // made, the usual trees checked)
+    const all = [...(f.lemmas ?? []), ...laws], t0 = performance.now(), v = goalsVerdict(foldObligations(f.fold, all), !certOn()), usualMs = performance.now() - t0;
     if (cyclicOn())
-        crossCyclic('fold', f.fold.name, v.proven && v.checked, () => { const { facts, specs } = foldNodes(f.fold, all); return proveCyclic(facts, specs); }, usualMs);
+        crossCyclic('fold', f.fold.name, v.proven && v.checked, () => { const { facts, specs } = foldNodes(f.fold, all); return proveCyclic(facts, specs); }, usualMs, v.trees && (st => translatedProof(() => JSON.stringify(['fold', f.fold, all]), () => foldNodes(f.fold, all, v.trees, st), st)));
+    if (certOn() && v.proven) {
+        const c = certCyclic('fold', f.fold.name, v.trees && (st => translatedProof(() => JSON.stringify(['fold', f.fold, all]), () => foldNodes(f.fold, all, v.trees, st), st)), () => { const { facts, specs } = foldNodes(f.fold, all); return proveCyclic(facts, specs); }, usualMs);
+        if (!c.checked) {
+            uncovered('fold', f.fold.name, c.why);
+            v.checked = foldObligations(f.fold, all).every(g => v.trees?.[g.name] !== undefined && check(g, v.trees[g.name]));
+        }
+    }
     return v;
 };
 const asTerm = (t) => (t instanceof Term ? t : lit(t));

package/dist/core/solver.d.ts

@@ -50,5 +50,8 @@ export type Verdict = {
     kind: 'unknown';
     point?: Record<string, number>;
 };
+export declare const work: {
+    n: number;
+};
 export declare function solve(constraints: Constraint[], maxRows?: number): Verdict;
 export declare function refuteFast(constraints: Constraint[], maxRows?: number): Verdict | undefined;

package/dist/core/solver.js

@@ -56,7 +56,10 @@ const gcd = (a, b) => (b === 0 ? Math.abs(a) : gcd(b, a % b));
 const vars = (lin) => Object.keys(lin).filter(key => key !== '1');
 // maxRows: elimination can square the rows each round; past this many live rows, or a round that would make more than
 // five times as many before merging them, it gives up with `unknown`.
+// The rows the solver has read and made, which a counted search reads as its clock (kernel/prove.ts's `counted`).
+export const work = { n: 0 };
 export function solve(constraints, maxRows = 20_000) {
+    work.n += constraints.length;
     const steps = [];
     const lins = [];
     const push = (step, lin) => (steps.push(step), lins.push(lin), lins.length - 1);
@@ -173,6 +176,7 @@ export function solve(constraints, maxRows = 20_000) {
             break;
         if (choice.pos.length * choice.neg.length > 5 * maxRows)
             return { kind: 'unknown' };
+        work.n += choice.pos.length * choice.neg.length;
         exact &&= choice.isExact;
         eliminated.push({ x: choice.x, rows: [...choice.pos, ...choice.neg] });
         const next = rows.filter(r => (lins[r][choice.x] ?? 0) === 0);
@@ -295,6 +299,7 @@ export function refuteFast(constraints, maxRows = 2_000) {
                 z[j] -= T[r][j];
     const eps = 1e-9;
     for (let iter = 0; iter < 50 * (R + m); iter++) {
+        work.n += 1 + ((R * cols) >> 8);
         // Bland's rule: the first column with a negative reduced cost enters (no cycling on degenerate systems).
         let enter = -1;
         for (let j = 0; j < cols; j++)

package/dist/core/translate.d.ts

@@ -0,0 +1,30 @@
+import type { C, E } from './machine.js';
+import { type Lin } from './solver.js';
+import { type Goal, type Path, type Subst, type Tree } from '../kernel/kernel.js';
+export type Rename = {
+    s: Subst;
+    cells?: Record<string, {
+        to: string;
+        at: E;
+    }>;
+};
+export type Renamer = (lin: Lin, wp: Path) => Lin | undefined;
+export declare function renamer(r: Rename): Renamer;
+export type TStats = {
+    leaves: number;
+    regrown: number;
+    splits: number;
+    carried: number;
+    uncarried: number;
+    cached: number;
+};
+export declare const tstats: () => TStats;
+export declare function translate(part: Goal, whole: Goal, tree: Tree, ren0: Renamer, st: TStats, until: number, pp?: Path, wp?: Path, swaps?: [string, string][]): Tree | undefined;
+export type Reads = {
+    k: E;
+    w: E;
+}[];
+export declare function readsFirst(whole: Goal, reads: Reads, ren: Renamer, inner: (wp: Path, swaps: [string, string][]) => Tree | undefined, st: TStats, until: number, wp?: Path, swaps?: [string, string][]): Tree | undefined;
+export declare function decide(whole: Goal, conds: C[], inner: (wp: Path) => Tree | undefined, st: TStats, until: number, wp?: Path): Tree | undefined;
+export declare function close(g: Goal, wp: Path, st: TStats, until: number): Tree | undefined;
+export declare function carry(g: Goal, nFacts: number, nUses: number, st: TStats, until: number): Tree | undefined;