gdp-wired 0.10.0 → 0.11.0

package/dist/core/machine.js

@@ -130,7 +130,12 @@ export function evalE(e, env, st, m) {
         case 'max': return Math.max(evalE(e.a, env, st, m), evalE(e.b, env, st, m));
         case 'if': return evalC(e.c, env, st, m) ? evalE(e.then, env, st, m) : evalE(e.else, env, st, m);
         case 'get': {
-            const key = evalE(e.key, env, st, m), fn = m.fns?.[e.map];
+            const fn = m.fns?.[e.map], args = fn?.call ? pairedArgs(e.key, fn.arity) : undefined;
+            if (args) {
+                const xs = args.map(a => evalE(a, env, st, m));
+                return naturalIn(callOf(fn)(...xs), `${e.map}(${xs.join(', ')})`);
+            }
+            const key = evalE(e.key, env, st, m);
             return fn ? naturalIn(fnOf(fn)(key), `${e.map}(${key})`) : st.maps[e.map].get(key) ?? st.defaults?.[e.map] ?? m.maps[e.map];
         }
     }
@@ -147,6 +152,34 @@ const fnOf = (fn) => {
     }
     return f;
 };
+const compiledCalls = new WeakMap();
+const callOf = (fn) => {
+    let f = compiledCalls.get(fn);
+    if (!f) {
+        f = compileFunction([], `return (${fn.call})`)();
+        compiledCalls.set(fn, f);
+    }
+    return f;
+};
+// The n arguments a key pairs (left-nested, ((a, b), c)..., each pair (s)² + b with s = a + b), if it is their pairing.
+const paired = new WeakMap();
+export function pairedArgs(key, n) {
+    let byN = paired.get(key);
+    if (!byN)
+        paired.set(key, (byN = new Map()));
+    if (byN.has(n))
+        return byN.get(n);
+    let out;
+    if (n === 1)
+        out = [key];
+    else if (key.op === 'add' && key.a.op === 'prod' && key.a.a.op === 'add' && alike(key.a.a, key.a.b) && alike(key.a.a.b, key.b)) {
+        const first = pairedArgs(key.a.a.a, n - 1);
+        out = first && [...first, key.b];
+    }
+    byN.set(n, out);
+    return out;
+}
+const alike = (a, b) => a === b || JSON.stringify(a) === JSON.stringify(b);
 export function evalC(c, env, st, m) {
     switch (c.op) {
         case '<': return evalE(c.a, env, st, m) < evalE(c.b, env, st, m);
@@ -323,7 +356,12 @@ export function compileJs(m) {
             case 'min': return `Math.min(${ex(e.a)}, ${ex(e.b)})`;
             case 'max': return `Math.max(${ex(e.a)}, ${ex(e.b)})`;
             case 'if': return `(${cx(e.c)} ? ${ex(e.then)} : ${ex(e.else)})`;
-            case 'get': return fns.includes(e.map) ? `$n(fn${fns.indexOf(e.map)}(${ex(e.key)}), ${id(`${e.map}()`)})` : `(maps[${id(e.map)}].get(${ex(e.key)}) ?? ${carriedMaps.includes(e.map) ? '0' : `dft[${id(e.map)}] ?? ${plain.maps[e.map]}`})`;
+            case 'get': {
+                const fn = m.fns?.[e.map], args = fn?.call ? pairedArgs(e.key, fn.arity) : undefined;
+                if (args)
+                    return `$n(fnc${fns.indexOf(e.map)}(${args.map(ex).join(', ')}), ${id(`${e.map}()`)})`;
+                return fns.includes(e.map) ? `$n(fn${fns.indexOf(e.map)}(${ex(e.key)}), ${id(`${e.map}()`)})` : `(maps[${id(e.map)}].get(${ex(e.key)}) ?? ${carriedMaps.includes(e.map) ? '0' : `dft[${id(e.map)}] ?? ${plain.maps[e.map]}`})`;
+            }
         }
     };
     const cx = (c) => {
@@ -379,7 +417,7 @@ function $n(v, what) { if (typeof v !== 'number' || !Number.isSafeInteger(v) ||
 function $x(v) { if (v > 9007199254740991) throw new RangeError('a value passed 2^53 - 1, past which the proofs over the naturals no longer describe the run'); return v; }
 function $m(v, what) { if (!(v instanceof Map)) throw new RangeError(what + ' must be a Map of naturals'); for (const [key, x] of v) { $n(key, 'a key of ' + what); $n(x, 'a cell of ' + what); } return v; }
 function $keys(maps, names) { const keys = new Set(); let past = 0; for (const c of Object.values(maps)) for (const key of c.keys()) past = Math.max(past, key + 1); for (const n of names) for (const key of maps[n].keys()) keys.add(key); return [...keys, past]; }
-${fns.map((name, i) => `const fn${i} = (${m.fns[name].js});\n`).join('')}function $breaks(maps, reads, cmps) { const p = new Set([0]); for (const [n, d, minus] of reads) { for (const s of maps[n].keys()) { if (minus) p.add(s + d); else if (s >= d) p.add(s - d); } if (minus) p.add(d); } for (const [v, d, minus] of cmps) { if (minus) { p.add(v + d); p.add(d); } else if (v >= d) p.add(v - d); } const keys = new Set(); for (const q of p) for (let i = -1; i <= 2; i++) if (q + i >= 0) keys.add(q + i); const sorted = [...keys].sort((a, b) => a - b); sorted.push(sorted[sorted.length - 1] + 1); return sorted; }
+${fns.map((name, i) => `const fn${i} = (${m.fns[name].js});\n${m.fns[name].call ? `const fnc${i} = (${m.fns[name].call});\n` : ''}`).join('')}function $breaks(maps, reads, cmps) { const p = new Set([0]); for (const [n, d, minus] of reads) { for (const s of maps[n].keys()) { if (minus) p.add(s + d); else if (s >= d) p.add(s - d); } if (minus) p.add(d); } for (const [v, d, minus] of cmps) { if (minus) { p.add(v + d); p.add(d); } else if (v >= d) p.add(v - d); } const keys = new Set(); for (const q of p) for (let i = -1; i <= 2; i++) if (q + i >= 0) keys.add(q + i); const sorted = [...keys].sort((a, b) => a - b); sorted.push(sorted[sorted.length - 1] + 1); return sorted; }
 function $dense(keys, f) { const top = keys[keys.length - 1]; if (top > 1000000) throw new RangeError('a write at every key reads its key in arithmetic past a million keys (' + top + ')'); const d = f(top), cells = new Map(); for (let k = 0; k < top; k++) { const v = f(k); if (v !== d) cells.set(k, v); } return {cells, d}; }
 function $every(keys, f) { const past = keys[keys.length - 1], d = f(past), cells = new Map(); for (let i = 0; i < keys.length - 1; i++) { const v = f(keys[i]); if (v !== d) cells.set(keys[i], v); } return {cells, d}; }
 export function init(params) {

package/dist/core/solver.d.ts

@@ -39,3 +39,4 @@ export type Verdict = {
     point?: Record<string, 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

@@ -8,18 +8,38 @@
 // exact shadow). Then a rational solution of the rest extends to an integer x, so back-substitution finds a witness.
 export const v = (name) => ({ [name]: 1 });
 export const k = (value) => (value === 0 ? {} : { 1: value });
+// (Plain loops, no intermediate arrays: these run millions of times in a proof. Each keeps the keys in the order they
+// first appear, as a sum over the entries would.)
 export function add(...xs) {
     const out = {};
     for (const x of xs)
-        for (const [key, value] of Object.entries(x))
-            out[key] = (out[key] ?? 0) + value;
-    for (const key of Object.keys(out))
+        for (const key in x)
+            out[key] = (out[key] ?? 0) + x[key];
+    for (const key in out)
         if (out[key] === 0)
             delete out[key];
     return out;
 }
-export const scale = (x, f) => add(Object.fromEntries(Object.entries(x).map(([key, value]) => [key, value * f])));
-export const sub = (a, b) => add(a, scale(b, -1));
+export const scale = (x, f) => {
+    const out = {};
+    for (const key in x) {
+        const value = x[key] * f;
+        if (value !== 0)
+            out[key] = value;
+    }
+    return out;
+};
+export const sub = (a, b) => {
+    const out = {};
+    for (const key in a)
+        out[key] = a[key];
+    for (const key in b)
+        out[key] = (out[key] ?? 0) - b[key];
+    for (const key in out)
+        if (out[key] === 0)
+            delete out[key];
+    return out;
+};
 export function show(x) {
     const parts = Object.entries(x).filter(([key]) => key !== '1').map(([key, c]) => (c === 1 ? key : c === -1 ? `-${key}` : `${c}${key}`));
     if ((x['1'] ?? 0) !== 0 || parts.length === 0)
@@ -180,3 +200,94 @@ function prune(steps, last) {
         return s.kind === 'combine' ? { ...s, a: at.get(s.a), b: at.get(s.b) } : s.kind === 'cut' ? { ...s, of: at.get(s.of) } : s;
     });
 }
+// A refutation found fast, where there is one over the rationals: Farkas' lemma says rows a·x + c <= 0 (x free) have no
+// rational solution exactly when some λ >= 0 has Σ λ·a = 0 and Σ λ·c > 0. A floating-point simplex looks for such λ
+// (phase one on Σ λ·a = 0, Σ λ·c = 1), and elimination on the rows it uses alone (usually a handful) gives the
+// derivation, renumbered to the whole system's rows. Floating point only picks the rows: the derivation is exact, and
+// the checker sees nothing else. Undefined when no λ turns up (a system with a rational solution, or one the floats
+// misjudge): the caller goes on as without it.
+export function refuteFast(constraints, maxRows = 2_000) {
+    const m = constraints.length;
+    if (m === 0)
+        return undefined;
+    const names = [...new Set(constraints.flatMap(c => vars(c.lin)))], n = names.length;
+    if (m > maxRows || n > maxRows)
+        return undefined;
+    // Tableau rows: one per variable (Σ λ_i a_ij = 0) and the normalization (Σ λ_i c_i = 1); columns: the m λs, then one
+    // artificial per row, then the right-hand side.
+    const R = n + 1, cols = m + R;
+    const T = Array.from({ length: R }, () => new Float64Array(cols + 1));
+    const col = new Map(names.map((x, j) => [x, j]));
+    constraints.forEach((c, i) => {
+        for (const [key, a] of Object.entries(c.lin)) {
+            if (key === '1')
+                T[n][i] = a;
+            else
+                T[col.get(key)][i] = a;
+        }
+    });
+    T[n][cols] = 1;
+    for (let r = 0; r < R; r++)
+        T[r][m + r] = 1;
+    const basis = Array.from({ length: R }, (_, r) => m + r);
+    // Phase one: minimize the artificials' sum, as the reduced costs of the objective row.
+    const z = new Float64Array(cols + 1);
+    for (let r = 0; r < R; r++)
+        for (let j = 0; j <= cols; j++)
+            if (j < m || j === cols)
+                z[j] -= T[r][j];
+    const eps = 1e-9;
+    for (let iter = 0; iter < 50 * (R + m); iter++) {
+        // 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++)
+            if (z[j] < -eps) {
+                enter = j;
+                break;
+            }
+        if (enter < 0)
+            break;
+        let leave = -1, best = Infinity;
+        for (let r = 0; r < R; r++) {
+            const a = T[r][enter];
+            if (a > eps) {
+                const ratio = T[r][cols] / a;
+                if (ratio < best - eps || (Math.abs(ratio - best) <= eps && basis[r] < basis[leave])) {
+                    best = ratio;
+                    leave = r;
+                }
+            }
+        }
+        if (leave < 0)
+            return undefined; // unbounded: cannot happen in phase one; give up rather than guess
+        const p = T[leave], pv = p[enter];
+        for (let j = 0; j <= cols; j++)
+            p[j] /= pv;
+        for (let r = 0; r < R; r++)
+            if (r !== leave) {
+                const f = T[r][enter];
+                if (f !== 0) {
+                    const row = T[r];
+                    for (let j = 0; j <= cols; j++)
+                        row[j] -= f * p[j];
+                }
+            }
+        const f = z[enter];
+        if (f !== 0)
+            for (let j = 0; j <= cols; j++)
+                z[j] -= f * p[j];
+        basis[leave] = enter;
+    }
+    if (-z[cols] > 1e-7)
+        return undefined; // the artificials can't all leave: no λ, so a rational solution exists
+    const support = [];
+    for (let r = 0; r < R; r++)
+        if (basis[r] < m && T[r][cols] > eps)
+            support.push(basis[r]);
+    if (!support.length)
+        return undefined;
+    const sub = solve(support.sort((a, b) => a - b).map(i => constraints[i]));
+    if (sub.kind !== 'refuted')
+        return undefined;
+    return { kind: 'refuted', steps: sub.steps.map(st => (st.kind === 'input' ? { ...st, index: support[st.index] } : st)) };
+}

package/dist/kernel/kernel.d.ts

@@ -18,6 +18,7 @@ export type Path = Map<string, {
     holds: boolean;
 }>;
 export declare const canon: (lin: Lin) => string;
+export declare const canonFlip: (lin: Lin) => string;
 export declare const atomOf: (lin: Lin, holds: boolean) => Constraint;
 export declare function linear(e: E, path: Path): Lin | undefined;
 export declare const termColumn: (e: E) => string;
@@ -27,6 +28,12 @@ export declare function termRows(name: string, path: Path): Lin[];
 export declare function truth(c: C, path: Path): boolean | undefined;
 export declare function facts(c: C, path: Path, positive?: boolean): Lin[];
 export declare function leafConstraints(goal: Goal, path: Path): Constraint[];
+export declare function leafConstraintsReusing(goal: Goal, path: Path): Constraint[];
+type Seen<T> = {
+    reads: [string, boolean | undefined][];
+    out: T;
+}[];
+export declare function reusing<T>(seen: Seen<T>, path: Path, f: (path: Path) => T): T;
 export declare function withProducts(rows: Constraint[], pairs: [number, number][]): Constraint[];
 export declare function check(goal: Goal, tree: Tree, path?: Path): boolean;
 export type Subst = {
@@ -46,7 +53,7 @@ export declare function historyMachine(m: Machine): {
     machine: Machine;
     goals: Goal[];
 };
-export declare function obligations(m: Machine, laws: Law[], instances?: Record<string, Instances>): Goal[];
+export declare function obligations(m: Machine, laws: Law[], instances?: Record<string, Instances>, only?: number): Goal[];
 export declare function checkLaws(m: Machine, laws: Law[], proof: {
     instances: Record<string, Instances>;
     trees: Record<string, Tree>;
@@ -122,3 +129,4 @@ export type Fold = {
     assume?: C;
 };
 export declare function foldObligations(f: Fold, laws: Law[]): Goal[];
+export {};

package/dist/kernel/kernel.js

@@ -22,25 +22,99 @@ import { add, k, scale, sub, v } from "../core/solver.js";
 // An exhaustive switch's default: TypeScript proves it unreachable, and if it is reached anyway (a value from outside
 // the types), it fails loudly instead of returning undefined.
 export function unreachable(value) { throw new Error(`unhandled case: ${JSON.stringify(value)}`); }
-export const canon = (lin) => Object.keys(lin).sort().map(key => `${key}:${lin[key]}`).join(',');
+// (Remembered per linear form: a form is never changed once built, and the same forms are looked up at every node.)
+const canonMemo = new WeakMap(), flipMemo = new WeakMap();
+export const canon = (lin) => {
+    let out = canonMemo.get(lin);
+    if (out === undefined)
+        canonMemo.set(lin, (out = Object.keys(lin).sort().map(key => `${key}:${lin[key]}`).join(',')));
+    return out;
+};
+// canon(1 − lin), the atom that decides lin <= 0 the other way, without building it.
+export const canonFlip = (lin) => {
+    let out = flipMemo.get(lin);
+    if (out !== undefined)
+        return out;
+    const keys = Object.keys(lin);
+    if (!('1' in lin))
+        keys.push('1');
+    const parts = [];
+    for (const key of keys.sort()) {
+        const c = key === '1' ? 1 - (lin['1'] ?? 0) : -lin[key];
+        if (c !== 0)
+            parts.push(`${key}:${c}`);
+    }
+    flipMemo.set(lin, (out = parts.join(',')));
+    return out;
+};
 export const atomOf = (lin, holds) => ({ lin: holds ? lin : add(k(1), scale(lin, -1)), label: '' });
 // Is lin <= 0 decided by the path? A constant atom decides itself.
 // Over the integers lin <= 0 fails exactly when 1 - lin <= 0 holds, so either atom decides the other.
 function decide(lin, path) {
-    if (Object.keys(lin).every(key => key === '1'))
+    let constant = true;
+    for (const key in lin)
+        if (key !== '1') {
+            constant = false;
+            break;
+        }
+    if (constant)
         return (lin['1'] ?? 0) <= 0;
-    const direct = path.get(canon(lin))?.holds;
+    const direct = look(path, canon(lin));
     if (direct !== undefined)
         return direct;
-    const flipped = path.get(canon(add(k(1), scale(lin, -1))))?.holds;
+    const flipped = look(path, canonFlip(lin));
     return flipped === undefined ? undefined : !flipped;
 }
+// Every decision a hypothesis' facts read, found or not, while they are recorded (leafConstraintsReusing).
+let recording;
+const look = (path, key) => { const out = path.get(key)?.holds; if (recording)
+    recording.set(key, out); return out; };
 // A term's linear form under the path. Reads become cells, named by map and key: `M[key]`; a choice the path leaves
 // open (∸, min, max, if) becomes a column of its own, `⟦n⟧`, standing for the term's value (see termRows).
 // Remembered per path and term (a path is never changed once built; a new decision is a new path), so a term shared
 // across hypotheses, or nested in a k-step run's later states, is read once per path.
+// A term without a choice (no ∸, min, max or if inside, its keys' too) reads alike on every path: remembered once.
 const linearMemo = new WeakMap();
+const freeMemo = new WeakMap(), freeLinear = new WeakMap();
+const choiceFree = (e) => {
+    let out = freeMemo.get(e);
+    if (out !== undefined)
+        return out;
+    switch (e.op) {
+        case 'var':
+        case 'const':
+            out = true;
+            break;
+        case 'mul':
+            out = choiceFree(e.a);
+            break;
+        case 'get':
+            out = choiceFree(e.key);
+            break;
+        case 'add':
+        case 'prod':
+            out = choiceFree(e.a) && choiceFree(e.b);
+            break;
+        case 'sub':
+        case 'min':
+        case 'max':
+        case 'if':
+            out = false;
+            break;
+    }
+    freeMemo.set(e, out);
+    return out;
+};
 export function linear(e, path) {
+    if (choiceFree(e)) {
+        if (freeLinear.has(e))
+            return freeLinear.get(e);
+        const out = linearOf(e, path);
+        freeLinear.set(e, out);
+        return out;
+    }
+    if (reuse)
+        return reusing(seenOf(linearSeen, e), path, p => linearOf(e, p));
     let memo = linearMemo.get(path);
     if (!memo)
         linearMemo.set(path, (memo = new WeakMap()));
@@ -158,8 +232,28 @@ function times(a, b) {
         }
     return add(...out);
 }
-// The atoms (lin <= 0 each) that make a comparison true, and those that make it false (one of which holds).
+const comparisonMemo = new WeakMap(), freeComparison = new WeakMap();
 function comparison(c, path) {
+    const free = choiceFree(c.a) && choiceFree(c.b);
+    if (free && freeComparison.has(c))
+        return freeComparison.get(c);
+    if (!free && reuse)
+        return reusing(seenOf(comparisonSeen, c), path, p => comparisonOf(c, p));
+    let memo = comparisonMemo.get(path);
+    if (!free) {
+        if (!memo)
+            comparisonMemo.set(path, (memo = new WeakMap()));
+        if (memo.has(c))
+            return memo.get(c);
+    }
+    const out = comparisonOf(c, path);
+    if (free)
+        freeComparison.set(c, out);
+    else
+        memo.set(c, out);
+    return out;
+}
+function comparisonOf(c, path) {
     const a = linear(c.a, path), b = linear(c.b, path);
     if (!a || !b)
         return undefined;
@@ -170,8 +264,21 @@ function comparison(c, path) {
         return { when: [add(ab, k(1))], unless: [[ba]] };
     return { when: [ab, ba], unless: [[add(ab, k(1))], [add(ba, k(1))]] };
 }
-// Kleene truth under the path: true, false, or undefined when open.
+// Kleene truth under the path: true, false, or undefined when open (remembered per path and condition).
+const truthMemo = new WeakMap();
 export function truth(c, path) {
+    if (reuse)
+        return reusing(seenOf(truthSeen, c), path, p => truthOf(c, p));
+    let memo = truthMemo.get(path);
+    if (!memo)
+        truthMemo.set(path, (memo = new WeakMap()));
+    if (memo.has(c))
+        return memo.get(c);
+    const out = truthOf(c, path);
+    memo.set(c, out);
+    return out;
+}
+function truthOf(c, path) {
     switch (c.op) {
         case 'flag': throw new Error('flags are inlined before the kernel sees them');
         case 'all': return undefined; // closed before a goal is checked; opaque here, so it gives a leaf nothing
@@ -224,10 +331,57 @@ export function facts(c, path, positive = true) {
     }
 }
 // What a leaf's derivation must refute.
-export function leafConstraints(goal, path) {
+export function leafConstraints(goal, path) { return leafRows(goal, path, h => facts(h, path)); }
+const factsSeen = new WeakMap();
+export function leafConstraintsReusing(goal, path) {
+    let byHyp = factsSeen.get(goal);
+    if (!byHyp)
+        factsSeen.set(goal, (byHyp = new Map()));
+    return leafRows(goal, path, h => {
+        let seen = byHyp.get(h);
+        if (!seen)
+            byHyp.set(h, (seen = []));
+        return reusing(seen, path, p => facts(h, p));
+    });
+}
+export function reusing(seen, path, f) {
+    const hit = seen.find(e => e.reads.every(([key, holds]) => path.get(key)?.holds === holds));
+    if (hit) {
+        if (recording)
+            for (const [key, holds] of hit.reads)
+                recording.set(key, holds);
+        return hit.out;
+    }
+    const outer = recording, mode = reuse;
+    recording = new Map();
+    reuse = true;
+    try {
+        const out = f(new Map(path));
+        seen.unshift({ reads: [...recording], out });
+        if (seen.length > 16)
+            seen.pop();
+        return out;
+    }
+    finally {
+        // What was read inside is read by the outer value too.
+        if (outer)
+            for (const [key, holds] of recording)
+                outer.set(key, holds);
+        recording = outer;
+        reuse = mode;
+    }
+}
+// While the prover reuses (inside `reusing`), a term's linear form, a comparison and a condition's truth are reused the
+// same way, each by the decisions it reads: only what a new decision touches is read again. The kernel's check never
+// runs in this mode: it reads every term afresh on every path.
+let reuse = false;
+const linearSeen = new WeakMap(), comparisonSeen = new WeakMap(), truthSeen = new WeakMap();
+const seenOf = (m, k) => { let s = m.get(k); if (!s)
+    m.set(k, (s = [])); return s; };
+function leafRows(goal, path, factsOf) {
     const rows = [...path.values()].map(a => atomOf(a.lin, a.holds));
     for (const h of goal.hyps)
-        for (const lin of facts(h, path))
+        for (const lin of factsOf(h))
             rows.push({ lin, label: '' });
     const names = new Set(rows.flatMap(r => Object.keys(r.lin).filter(key => key !== '1')));
     // Two reads of one map whose keys the path proves equal are equal.
@@ -755,10 +909,11 @@ export function historyMachine(m) {
     }
     return { machine, goals };
 }
-export function obligations(m, laws, instances = {}) {
+// `only`: the goals of that law alone (the prover's instance search asks for one law's at a time).
+export function obligations(m, laws, instances = {}, only) {
     if (m.history) {
         const { machine, goals } = historyMachine(m);
-        return [...obligations(machine, laws, instances), ...goals];
+        return [...obligations(machine, laws, instances, only), ...(only === undefined ? goals : [])];
     }
     scope(m, laws);
     const ok = [...Object.values(m.state), ...Object.values(m.step.state ?? {}), ...Object.values(m.step.maps ?? {}).flatMap(w => ('each' in w ? [w.value] : [w.key, w.value]))].every(natural)
@@ -770,7 +925,9 @@ export function obligations(m, laws, instances = {}) {
     // value of it too (the Lean twin reads it so).
     const proven = (law) => (law.forall ? substC(law.holds, { vars: { [law.forall]: { op: 'var', name: `${law.forall}#` } }, maps: {}, flags: {} }) : law.holds);
     const pre = preOf(m), u = updateOf(m), assume = m.assume ? [inlineFlags(m, m.assume)] : [];
-    return laws.flatMap(law => {
+    return laws.flatMap((law, i) => {
+        if (only !== undefined && i !== only)
+            return [];
         // At the start: the precondition, and no request. One step: from a state where the laws hold, a request allowed.
         // The facts hold throughout, read where the run begins (they read no state).
         const start = given(m, holds(from(startOf(m)), pre), instances[law.name] ?? {});
@@ -885,8 +1042,9 @@ export function stepLawObligations(machine, laws, instances, sl) {
     const m = machine.history ? historyMachine(machine).machine : machine;
     scope(m, laws);
     const k = sl.steps ?? 1;
-    if (!Number.isInteger(k) || k < 1 || k > 16)
-        throw new Error(`step law ${sl.name}: steps is a whole number from 1 to 16`);
+    // Past 64 the cost is the bound (proving grows about as k³: 64 steps in about 90 s; Lean checks 32 in about 13 minutes).
+    if (!Number.isInteger(k) || k < 1 || k > 64)
+        throw new Error(`step law ${sl.name}: steps is a whole number from 1 to 64`);
     const whens = sl.when === undefined ? [] : Array.isArray(sl.when) ? sl.when : [sl.when];
     if (whens.length > k)
         throw new Error(`step law ${sl.name}: one when per step at most`);

package/dist/kernel/prove.d.ts

@@ -1,5 +1,26 @@
 import type { C, E, Law, Machine } from '../core/machine.js';
 import { type Goal, type Instances, type Liveness, type Path, type StepLaw, type Tree } from './kernel.js';
+export declare const profile: {
+    on: boolean;
+    goals: {
+        name: string;
+        ms: number;
+        nodes: number;
+        solves: number;
+        solveMs: number;
+        rowsMs: number;
+        proven: boolean;
+    }[];
+    solves: number;
+    solveMs: number;
+    rowsMs: number;
+    nodes: number;
+};
+export declare const solveKinds: Record<string, {
+    n: number;
+    ms: number;
+    rows: number;
+}>;
 export type Outcome = {
     tree: Tree;
     nodes: number;