gdp-wired 0.17.0 → 0.19.0

package/dist/core/data.js

@@ -0,0 +1,1858 @@
+import { substC, substE } from "../kernel/kernel.js";
+import { proveCyclic } from "./cyclic.js";
+import { pairedKeys, withDeadline } from "../kernel/prove.js";
+// --- sorts and the AST ------------------------------------------------------------------------------------------------
+export const self = { self: true };
+export const natural = 'nat';
+export const boolean = 'bool';
+// --- the surface ------------------------------------------------------------------------------------------------------
+let fresh = 0;
+const bindName = (field) => `${field}#${++fresh}`;
+export class Nat {
+    x;
+    constructor(x) {
+        this.x = x;
+    }
+    plus(b) { return new Nat({ op: 'add', a: this.x, b: natX(b) }); }
+    minus(b) { return new Nat({ op: 'sub', a: this.x, b: natX(b) }); }
+    times(k) { return new Nat({ op: 'mul', k, a: this.x }); }
+    lt(b) { return new Bool({ op: '<', a: this.x, b: natX(b) }); }
+    atMost(b) { return new Bool({ op: '<=', a: this.x, b: natX(b) }); }
+    gt(b) { return new Bool({ op: '<', a: natX(b), b: this.x }); }
+    atLeast(b) { return new Bool({ op: '<=', a: natX(b), b: this.x }); }
+    eq(b) { return new Bool({ op: '=', a: this.x, b: natX(b) }); }
+    ne(b) { return this.eq(b).not(); }
+}
+const natX = (t) => (typeof t === 'number' ? { op: 'nat', value: t } : t.x);
+export class Bool {
+    y;
+    constructor(y) {
+        this.y = y;
+    }
+    and(...bs) { return new Bool({ op: 'and', xs: [this.y, ...bs.map(b => b.y)] }); }
+    or(...bs) { return new Bool({ op: 'or', xs: [this.y, ...bs.map(b => b.y)] }); }
+    not() { return new Bool({ op: 'not', x: this.y }); }
+    implies(b) { return this.not().or(b); }
+    iff(b) { return this.implies(b).and(b.implies(this)); }
+}
+export const yes = new Bool({ op: '<=', a: { op: 'nat', value: 0 }, b: { op: 'nat', value: 0 } });
+export const no = new Bool({ op: '<', a: { op: 'nat', value: 0 }, b: { op: 'nat', value: 0 } });
+export class Val {
+    data;
+    x;
+    constructor(data, x) {
+        this.data = data;
+        this.x = x;
+    }
+    // Every case covered; each case's fields by name (a natural, or a value of the datatype).
+    // oxlint-disable-next-line typescript/no-explicit-any
+    match(cases) {
+        const d = this.data;
+        const built = d.ctors.map(c => {
+            const f = cases[c.name];
+            if (!f)
+                throw new Error(`${d.name}: match has no case ${c.name}`);
+            const binds = c.fields.map(fl => bindName(fl.name));
+            const fields = Object.fromEntries(c.fields.map((fl, i) => [fl.name, wrap(fl.sort === 'nat' ? 'nat' : d, { op: 'var', name: binds[i] })]));
+            return { binds, out: f(fields) };
+        });
+        const first = built[0].out;
+        const body = (o) => (typeof o === 'number' ? natX(o) : o instanceof Bool ? { op: 'bool', c: o.y } : o.x);
+        const x = { op: 'match', data: d.name, of: this.x, cases: built.map(b => ({ binds: b.binds, body: body(b.out) })) };
+        return (first instanceof Bool ? new Bool({ op: 'holds', x }) : first instanceof Val ? new Val(first.data, x) : new Nat(x));
+    }
+    is(ctor) { return new Bool({ op: 'is', data: this.data.name, of: this.x, ctor: this.data.index(ctor) }); }
+    eq(b) { return new Bool({ op: '=', a: this.x, b: b.x }); }
+    ne(b) { return this.eq(b).not(); }
+}
+// A value of a sort from its term.
+export const wrap = (s, x) => (s === 'nat' ? new Nat(x) : s === 'bool' ? new Bool({ op: 'holds', x }) : new Val(s, x));
+const xOf = (s, v) => (s === 'nat' ? natX(v) : s === 'bool' ? { op: 'bool', c: v.y } : v.x);
+export function when(c, a, b) {
+    if (a instanceof Bool)
+        return new Bool({ op: 'or', xs: [{ op: 'and', xs: [c.y, a.y] }, { op: 'and', xs: [{ op: 'not', x: c.y }, b.y] }] });
+    const ax = typeof a === 'number' ? natX(a) : a.x, bx = typeof b === 'number' ? natX(b) : b.x;
+    const x = { op: 'if', c: c.y, then: ax, else: bx };
+    return (a instanceof Val ? new Val(a.data, x) : new Nat(x));
+}
+// A datatype: its constructors, each with fields that are naturals or values of the datatype itself (`self`). Its
+// constructors are ordered as Lean's bijection numbers them: those of no field, then those with no field of the
+// datatype, then the rest; a datatype with no constructor of the first two kinds has no value and is refused.
+export class Data {
+    name;
+    ctors;
+    constructor(name, decl) {
+        this.name = name;
+        const all = Object.entries(decl).map(([c, fs]) => ({ name: c, fields: Object.entries(fs).map(([f, s]) => ({ name: f, sort: s === self ? 'self' : 'nat' })) }));
+        const rank = (c) => (!c.fields.length ? 0 : c.fields.every(f => f.sort === 'nat') ? 1 : 2);
+        this.ctors = [...all].sort((a, b) => rank(a) - rank(b));
+        if (!this.ctors.some(c => rank(c) < 2))
+            throw new Error(`${name}: every constructor has a field of ${name}, so it has no value`);
+        if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(name))
+            throw new Error(`${name}: a datatype's name is letters and digits`);
+    }
+    index(ctor) { const i = this.ctors.findIndex(c => c.name === ctor); if (i < 0)
+        throw new Error(`${this.name} has no constructor ${ctor}`); return i; }
+    get nullary() { return this.ctors.filter(c => !c.fields.length).length; }
+    make(ctor, ...args) {
+        const j = this.index(ctor), c = this.ctors[j];
+        if (args.length !== c.fields.length)
+            throw new Error(`${this.name}.${ctor} takes ${c.fields.length} fields`);
+        return new Val(this, { op: 'ctor', data: this.name, ctor: j, args: c.fields.map((f, i) => xOf(f.sort === 'nat' ? 'nat' : this, args[i])) });
+    }
+}
+// `data('List', {nil: {}, cons: {head: nat, tail: self}})`: `List.nil`, `List.cons(h, t)`, and `xs.match({...})`.
+export function data(name, decl) {
+    const norm = Object.fromEntries(Object.entries(decl).map(([c, fs]) => [c, Object.fromEntries(Object.entries(fs).map(([f, s]) => [f, s === self ? self : 'nat']))]));
+    const d = new Data(name, norm);
+    for (const c of d.ctors)
+        Object.defineProperty(d, c.name, c.fields.length ? { value: (...args) => d.make(c.name, ...args) } : { get: () => d.make(c.name) });
+    return d;
+}
+const fns = new Map();
+export function define(name, params, ret, body) {
+    if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(name))
+        throw new Error(`${name}: a function's name is letters and digits`);
+    const ps = Object.entries(params).map(([n, s]) => ({ name: n, sort: s }));
+    let built;
+    const fn = { name, params: ps, ret, paramFns: [], body: () => {
+            if (!built) {
+                const args = Object.fromEntries(ps.map(p => [p.name, wrap(p.sort, { op: 'var', name: `${name}.${p.name}` })]));
+                built = xOf(ret, body(args));
+                fn.decreases = decreasing(fn, built);
+                fn.paramFns = [...new Set(paramsIn(built))];
+            }
+            return built;
+        } };
+    fns.set(name, fn);
+    const call = (...args) => {
+        if (args.length !== ps.length)
+            throw new Error(`${name} takes ${ps.length} arguments`);
+        return wrap(ret, { op: 'call', fn: name, args: ps.map((p, i) => xOf(p.sort, args[i])) });
+    };
+    return Object.assign(call, { fn });
+}
+// An uninterpreted function of a natural (a law about every f): `const f = fnParam('f')`, `f(x)`.
+export const fnParam = (name) => Object.assign((x) => new Nat({ op: 'apply', param: name, arg: natX(x) }), { param: name });
+const paramsIn = (t) => { const out = []; walk(t, o => { if (o.op === 'apply')
+    out.push(o.param); }); return out; };
+function walk(t, f) {
+    if (Array.isArray(t)) {
+        t.forEach(x => walk(x, f));
+        return;
+    }
+    if (!t || typeof t !== 'object')
+        return;
+    const o = t;
+    f(o);
+    for (const v of Object.values(o))
+        walk(v, f);
+}
+// The parameter every recursive call passes a field of (bound by a match on that parameter), or a refusal.
+function decreasing(fn, body) {
+    const calls = [];
+    const go = (x, fieldsOf) => {
+        if (!x || typeof x !== 'object')
+            return;
+        if (Array.isArray(x)) {
+            x.forEach(y => go(y, fieldsOf));
+            return;
+        }
+        const o = x;
+        if (o.op === 'match') {
+            go(o.of, fieldsOf);
+            const of = o.of.op === 'var' ? (fieldsOf.get(o.of.name) ?? o.of.name) : undefined;
+            o.cases.forEach(c => { const m = new Map(fieldsOf); if (of)
+                c.binds.forEach(b => m.set(b, of)); go(c.body, m); });
+            return;
+        }
+        if (o.op === 'call' && o.fn === fn.name)
+            calls.push({ args: o.args, fieldsOf });
+        if (o.op === 'call' && o.fn !== fn.name && !fns.has(o.fn))
+            throw new Error(`${fn.name} calls ${o.fn}, which isn't defined`);
+        for (const v of Object.values(o))
+            go(v, fieldsOf);
+    };
+    go(body, new Map());
+    if (!calls.length)
+        return undefined;
+    for (const [i, p] of fn.params.entries()) {
+        if (p.sort === 'nat' || p.sort === 'bool')
+            continue;
+        const own = `${fn.name}.${p.name}`;
+        if (calls.every(c => { const a = c.args[i]; return a.op === 'var' && c.fieldsOf.get(a.name) === own; }))
+            return i;
+    }
+    throw new Error(`${fn.name}: not structural recursion (no parameter whose field every recursive call passes)`);
+}
+export function law(name, vars, holds) {
+    const vs = Object.entries(vars).map(([n, s]) => ({ name: n, sort: s }));
+    const y = holds(Object.fromEntries(vs.map(v => [v.name, wrap(v.sort, { op: 'var', name: v.name })]))).y;
+    return { name, vars: vs, holds: y, params: [...new Set(paramsIn(y))] };
+}
+const fnOf = (name) => { const f = fns.get(name); if (!f)
+    throw new Error(`no function ${name}`); return f; };
+const asNat = (v) => v;
+export function evalX(x, env, params) {
+    switch (x.op) {
+        case 'var': {
+            const v = env.get(x.name);
+            if (v === undefined)
+                throw new Error(`unbound ${x.name}`);
+            return v;
+        }
+        case 'nat': return x.value;
+        case 'add': return asNat(evalX(x.a, env, params)) + asNat(evalX(x.b, env, params));
+        case 'sub': return Math.max(0, asNat(evalX(x.a, env, params)) - asNat(evalX(x.b, env, params)));
+        case 'min': return Math.min(asNat(evalX(x.a, env, params)), asNat(evalX(x.b, env, params)));
+        case 'max': return Math.max(asNat(evalX(x.a, env, params)), asNat(evalX(x.b, env, params)));
+        case 'mul': return x.k * asNat(evalX(x.a, env, params));
+        case 'if': return evalY(x.c, env, params) ? evalX(x.then, env, params) : evalX(x.else, env, params);
+        case 'bool': return evalY(x.c, env, params) ? 1 : 0;
+        case 'apply': return params[x.param](asNat(evalX(x.arg, env, params)));
+        case 'ctor': return { c: x.ctor, f: x.args.map(a => evalX(a, env, params)) };
+        case 'match': {
+            const v = evalX(x.of, env, params), cs = x.cases[v.c];
+            const e2 = new Map(env);
+            cs.binds.forEach((b, i) => e2.set(b, v.f[i]));
+            return evalX(cs.body, e2, params);
+        }
+        case 'call': {
+            const f = fnOf(x.fn), body = f.body();
+            const e2 = new Map(f.params.map((p, i) => [`${f.name}.${p.name}`, evalX(x.args[i], env, params)]));
+            return evalX(body, e2, params);
+        }
+    }
+}
+export function evalY(y, env, params) {
+    switch (y.op) {
+        case '<': return asNat(evalX(y.a, env, params)) < asNat(evalX(y.b, env, params));
+        case '<=': return asNat(evalX(y.a, env, params)) <= asNat(evalX(y.b, env, params));
+        case '=': return same(evalX(y.a, env, params), evalX(y.b, env, params));
+        case 'and': return y.xs.every(z => evalY(z, env, params));
+        case 'or': return y.xs.some(z => evalY(z, env, params));
+        case 'not': return !evalY(y.x, env, params);
+        case 'is': return evalX(y.of, env, params).c === y.ctor;
+        case 'holds': return evalX(y.x, env, params) === 1;
+    }
+}
+const same = (a, b) => (typeof a === 'number' || typeof b === 'number' ? a === b : a.c === b.c && a.f.every((x, i) => same(x, b.f[i])));
+export const showValue = (d, v) => {
+    if (typeof v === 'number')
+        return String(v);
+    if (d === 'nat' || d === 'bool')
+        return JSON.stringify(v);
+    const c = d.ctors[v.c];
+    return c.fields.length ? `${c.name}(${c.fields.map((f, i) => showValue(f.sort === 'nat' ? 'nat' : d, v.f[i])).join(', ')})` : c.name;
+};
+export const rng = (seed) => () => { seed = (seed * 1103515245 + 12345) % 2147483648; return seed / 2147483648; };
+export function randomValue(s, rand, size, natMax = 5) {
+    if (s === 'nat')
+        return Math.floor(rand() * (natMax + 1));
+    if (s === 'bool')
+        return rand() < 0.5 ? 0 : 1;
+    const leaves = s.ctors.filter(c => c.fields.every(f => f.sort === 'nat'));
+    const pick = size <= 0 || rand() < 0.25 ? leaves : s.ctors;
+    const c = pick[Math.floor(rand() * pick.length)], j = s.ctors.indexOf(c);
+    const rec = c.fields.filter(f => f.sort === 'self').length;
+    return { c: j, f: c.fields.map(f => randomValue(f.sort === 'nat' ? 'nat' : s, rand, Math.floor((size - 1) / Math.max(1, rec)), natMax)) };
+}
+// A random function of a natural: a table of small values.
+export const randomFn = (rand, natMax = 5) => { const t = new Map(); return n => { if (!t.has(n))
+    t.set(n, Math.floor(rand() * (natMax + 1))); return t.get(n); }; };
+export function samples(vars, paramNames, n, seed = 1) {
+    const rand = rng(seed), out = [];
+    for (let i = 0; i < n; i++)
+        out.push({ env: new Map(vars.map(v => [v.name, randomValue(v.sort, rand, 1 + (i % 7))])), params: Object.fromEntries(paramNames.map(p => [p, randomFn(rand)])) });
+    return out;
+}
+// --- the encoding -----------------------------------------------------------------------------------------------------
+const ev = (name) => ({ op: 'var', name });
+const k = (value) => ({ op: 'const', value });
+const get = (map, key) => ({ op: 'get', map, key });
+const eqC = (a, b) => ({ op: '=', a, b });
+const leC = (a, b) => ({ op: '<=', a, b });
+const andC = (...xs) => (xs.length === 1 ? xs[0] : { op: 'and', xs });
+const implies = (a, b) => ({ op: 'or', xs: [{ op: 'not', x: a }, b] });
+const yesC = leC(k(0), k(0));
+const pairE = (a, b) => { const s = { op: 'add', a, b }; return { op: 'add', a: { op: 'prod', a: s, b: s }, b }; };
+export const keyOf = (args) => args.slice(1).reduce(pairE, args[0]);
+// The arguments of a key built by keyOf (n of them), read back from its shape.
+function argsOf(key, n) {
+    if (n === 1)
+        return [key];
+    if (key.op !== 'add' || key.a.op !== 'prod' || key.a.a.op !== 'add')
+        return undefined;
+    const left = argsOf(key.a.a.a, n - 1);
+    return left && [...left, key.b];
+}
+export const tagMap = (d) => `${d}.tag`, sizeMap = (d) => `${d}.size`;
+export const fieldMap = (d, j, i) => `${d.name}.${d.ctors[j].name}.${d.ctors[j].fields[i].name}`;
+export const ctorMap = (d, j) => `${d.name}.${d.ctors[j].name}`;
+// Everything a law reads: the datatypes, the functions (with those they call), the function parameters.
+export function programOf(laws, extra = []) {
+    const fs = new Map(), ds = new Map(), ps = new Set();
+    const addSort = (s) => { if (s instanceof Data)
+        ds.set(s.name, s); };
+    const visit = (t) => walk(t, o => {
+        if (o.op === 'call' && !fs.has(o.fn)) {
+            const f = fnOf(o.fn);
+            fs.set(f.name, f);
+            f.params.forEach(p => addSort(p.sort));
+            addSort(f.ret);
+            visit(f.body());
+        }
+        if (o.op === 'apply')
+            ps.add(o.param);
+    });
+    for (const l of laws) {
+        l.vars.forEach(v => addSort(v.sort));
+        visit(l.holds);
+    }
+    for (const f of extra)
+        visit({ op: 'call', fn: f.name, args: [] });
+    const datas = [...new Map([...ds.values()].map(d => [d.name, d])).values()];
+    // Functions in definition order (each after those it calls).
+    const order = [], seen = new Set();
+    const place = (f) => { if (seen.has(f.name))
+        return; seen.add(f.name); walk(f.body(), o => { if (o.op === 'call' && o.fn !== f.name)
+        place(fnOf(o.fn)); }); order.push(f); };
+    for (const f of fs.values())
+        place(f);
+    return { datas, fns: order, params: [...ps] };
+}
+const dataOf = (p, name) => p.datas.find(d => d.name === name);
+export function encX(p, x, env) {
+    switch (x.op) {
+        case 'var': return env.get(x.name) ?? ev(x.name);
+        case 'nat': return k(x.value);
+        case 'add':
+        case 'sub':
+        case 'min':
+        case 'max': return { op: x.op, a: encX(p, x.a, env), b: encX(p, x.b, env) };
+        case 'mul': return { op: 'mul', k: x.k, a: encX(p, x.a, env) };
+        case 'if': return { op: 'if', c: encY(p, x.c, env), then: encX(p, x.then, env), else: encX(p, x.else, env) };
+        case 'bool': return { op: 'if', c: encY(p, x.c, env), then: k(1), else: k(0) };
+        case 'apply': return get(x.param, encX(p, x.arg, env));
+        case 'call': return get(x.fn, keyOf(x.args.map(a => encX(p, a, env))));
+        case 'ctor': {
+            const d = dataOf(p, x.data);
+            return x.args.length ? get(ctorMap(d, x.ctor), keyOf(x.args.map(a => encX(p, a, env)))) : k(x.ctor);
+        }
+        case 'match': {
+            const d = dataOf(p, x.data), of = encX(p, x.of, env);
+            const bodies = x.cases.map((c, j) => { const e2 = new Map(env); c.binds.forEach((b, i) => e2.set(b, get(fieldMap(d, j, i), of))); return encX(p, c.body, e2); });
+            return bodies.slice(0, -1).reduceRight((acc, b, j) => ({ op: 'if', c: eqC(get(tagMap(d.name), of), k(j)), then: b, else: acc }), bodies.at(-1));
+        }
+    }
+}
+export function encY(p, y, env) {
+    switch (y.op) {
+        case '<':
+        case '<=':
+        case '=': return { op: y.op, a: encX(p, y.a, env), b: encX(p, y.b, env) };
+        case 'and':
+        case 'or': return { op: y.op, xs: y.xs.map(z => encY(p, z, env)) };
+        case 'not': return { op: 'not', x: encY(p, y.x, env) };
+        case 'is': return eqC(get(tagMap(y.data), encX(p, y.of, env)), k(y.ctor));
+        case 'holds': return eqC(encX(p, y.x, env), k(1));
+    }
+}
+export function factsOf(p) {
+    const facts = [], at = new Map(), arity = new Map();
+    const put = (name, f) => { at.set(name, facts.length); facts.push({ ...f, name }); };
+    const x = ev('x$');
+    for (const d of p.datas) {
+        const tag = get(tagMap(d.name), x), size = (t) => get(sizeMap(d.name), t);
+        // Under tag j: the size, and every field of another constructor 0 (what Lean's model reads there).
+        const under = (c, j) => {
+            const sz = c.fields.flatMap((f, i) => (f.sort === 'self' ? [size(get(fieldMap(d, j, i), x))] : [])).reduce((a, b) => ({ op: 'add', a, b }), k(1));
+            const others = d.ctors.flatMap((c2, j2) => (j2 === j ? [] : c2.fields.map((_, i2) => eqC(get(fieldMap(d, j2, i2), x), k(0)))));
+            return andC(eqC(size(x), sz), ...others);
+        };
+        put(`shape ${d.name}`, { name: '', keys: ['x$'], holds: andC(leC(tag, k(d.ctors.length - 1)), ...d.ctors.map((c, j) => implies(eqC(tag, k(j)), under(c, j)))) });
+        put(`eta ${d.name}`, { name: '', keys: ['x$'], holds: andC(...d.ctors.map((c, j) => implies(eqC(tag, k(j)), eqC(x, c.fields.length ? get(ctorMap(d, j), keyOf(c.fields.map((_, i) => get(fieldMap(d, j, i), x)))) : k(j))))) });
+        if (d.nullary)
+            put(`nullary ${d.name}`, { name: '', keys: [], holds: andC(...d.ctors.slice(0, d.nullary).map((_, j) => eqC(get(tagMap(d.name), k(j)), k(j)))) });
+        for (const [j, c] of d.ctors.entries()) {
+            if (!c.fields.length)
+                continue;
+            const as = c.fields.map((_, i) => `a$${i}`), key = keyOf(as.map(ev)), cell = get(ctorMap(d, j), key);
+            arity.set(ctorMap(d, j), as.length);
+            put(`ctor ${ctorMap(d, j)}`, { name: '', keys: as, holds: andC(eqC(get(tagMap(d.name), cell), k(j)), ...c.fields.map((_, i) => eqC(get(fieldMap(d, j, i), cell), ev(as[i])))) });
+        }
+    }
+    for (const f of p.fns) {
+        const keys = f.params.map(q => `${f.name}.${q.name}`);
+        arity.set(f.name, keys.length);
+        const body = encX(p, f.body(), new Map());
+        put(`fn ${f.name}`, { name: '', keys, holds: andC(eqC(get(f.name, keyOf(keys.map(ev))), body), ...(f.ret === 'bool' ? [leC(get(f.name, keyOf(keys.map(ev))), k(1))] : [])) });
+    }
+    // Every map the encoding reads: the datatypes' tag, size and fields too (each of one argument).
+    for (const d of p.datas) {
+        arity.set(tagMap(d.name), 1);
+        arity.set(sizeMap(d.name), 1);
+        d.ctors.forEach((c, j) => c.fields.forEach((_, i) => arity.set(fieldMap(d, j, i), 1)));
+    }
+    for (const q of p.params)
+        arity.set(q, 1);
+    for (const [m, n] of arity) {
+        const as = Array.from({ length: n }, (_, i) => `a$${i}`), bs = Array.from({ length: n }, (_, i) => `b$${i}`);
+        put(`cong ${m}`, { name: '', keys: [...as, ...bs], holds: implies(andC(...as.map((a, i) => eqC(ev(a), ev(bs[i])))), eqC(get(m, keyOf(as.map(ev))), get(m, keyOf(bs.map(ev))))) });
+    }
+    return { facts, at, arity };
+}
+// --- the codes Lean's twin defines (lean-kernel/Data.lean, lean-kernel/data.ts) ------------------------------------------
+// The naturals onto the pairs in order of their sum (Data.lean's cun) and back (cpair); a datatype's values as naturals:
+// those of no field their tag, the rest z + m·q + r (z of no field, m with fields, r the constructor's place among
+// those, q its fields packed by cpair). Every natural is a value; numbers past 2^53 are refused.
+const tri = (s) => (s * (s + 1)) / 2;
+const cun = (n) => { let s = Math.floor((Math.sqrt(8 * n + 1) - 1) / 2); while (tri(s) > n)
+    s--; while (tri(s + 1) <= n)
+    s++; const b = n - tri(s); return [s - b, b]; };
+const cpair = (a, b) => tri(a + b) + b;
+const tup = (q, k, i) => (k <= 1 ? q : i === 0 ? cun(q)[0] : tup(cun(q)[1], k - 1, i - 1));
+const tupk = (xs) => (xs.length === 1 ? xs[0] : cpair(xs[0], tupk(xs.slice(1))));
+const safe = (x) => { if (!Number.isSafeInteger(x))
+    throw new RangeError('past 2^53'); return x; };
+export function decode(d, n) {
+    const z = d.nullary, m = d.ctors.length - z;
+    if (n < z)
+        return { c: n, f: [] };
+    const q = Math.floor((n - z) / m), j = z + ((n - z) % m), c = d.ctors[j];
+    return { c: j, f: c.fields.map((f, i) => { const x = tup(q, c.fields.length, i); return f.sort === 'nat' ? x : decode(d, x); }) };
+}
+export function encode(d, v) {
+    const o = v, z = d.nullary, m = d.ctors.length - z;
+    if (o.c < z)
+        return o.c;
+    const c = d.ctors[o.c];
+    return safe(z + m * tupk(c.fields.map((f, i) => (f.sort === 'nat' ? o.f[i] : encode(d, o.f[i])))) + (o.c - z));
+}
+// Each map of the encoding as a function of its arguments, on the codes (for core/cycles.ts's runs).
+export function codeValues(p) {
+    const out = {};
+    for (const d of p.datas) {
+        out[tagMap(d.name)] = n => decode(d, n).c;
+        out[sizeMap(d.name)] = n => sizeOf(d, decode(d, n));
+        d.ctors.forEach((c, j) => {
+            c.fields.forEach((f, i) => { out[fieldMap(d, j, i)] = n => { const v = decode(d, n); return v.c === j ? (f.sort === 'nat' ? v.f[i] : encode(d, v.f[i])) : 0; }; });
+            if (c.fields.length)
+                out[ctorMap(d, j)] = (...xs) => encode(d, { c: j, f: c.fields.map((f, i) => (f.sort === 'nat' ? xs[i] : decode(d, xs[i]))) });
+        });
+    }
+    for (const f of p.fns)
+        out[f.name] = (...xs) => {
+            const v = evalX(f.body(), new Map(f.params.map((q, i) => [`${f.name}.${q.name}`, q.sort instanceof Data ? decode(q.sort, xs[i]) : xs[i]])), {});
+            return f.ret instanceof Data ? encode(f.ret, v) : v;
+        };
+    return out;
+}
+// That a value's fields of its datatype have smaller codes (true of the codes above: each field at most q).
+export const orderFacts = (p) => p.datas.map(d => ({ name: `order ${d.name}`, keys: ['x$'], holds: andC(yesC, ...d.ctors.flatMap((c, j) => c.fields.flatMap((f, i) => (f.sort === 'self' ? [implies(eqC(get(tagMap(d.name), ev('x$')), k(j)), { op: '<', a: get(fieldMap(d, j, i), ev('x$')), b: ev('x$') })] : [])))) }));
+// --- concrete models: a value of the encoding at random values (which terms are equal, for congruences and matches) ----
+// Values interned per datatype: a constructor of no field is its tag; the rest numbered from there. A key is a
+// pairing's natural, read back through its square root.
+export class Model {
+    p;
+    params;
+    ids = new Map();
+    vals = new Map();
+    constructor(p, params) {
+        this.p = p;
+        this.params = params;
+    }
+    id(d, v) {
+        if (typeof v === 'number')
+            return v;
+        if (!d.ctors[v.c].fields.length)
+            return v.c;
+        const text = JSON.stringify(v);
+        let m = this.ids.get(d.name), list = this.vals.get(d.name);
+        if (!m || !list) {
+            this.ids.set(d.name, (m = new Map()));
+            this.vals.set(d.name, (list = []));
+        }
+        let i = m.get(text);
+        if (i === undefined) {
+            i = d.nullary + list.length;
+            m.set(text, i);
+            list.push(v);
+        }
+        return i;
+    }
+    value(d, id) {
+        if (id < d.nullary)
+            return { c: id, f: [] };
+        const v = this.vals.get(d.name)?.[id - d.nullary];
+        if (!v)
+            throw new Error(`${d.name}: no value numbered ${id} here`);
+        return v;
+    }
+    // A value of a sort as the encoding's natural, and back.
+    code(s, v) { return s instanceof Data ? this.id(s, v) : v; }
+    decode(s, n) { return s instanceof Data ? this.value(s, n) : n; }
+    memo = new Map();
+    read(map, key) {
+        const at = `${map}|${key}`, had = this.memo.get(at);
+        if (had !== undefined)
+            return had;
+        const out = this.readNew(map, key);
+        this.memo.set(at, out);
+        return out;
+    }
+    terms = new WeakMap();
+    readNew(map, key) {
+        const p = this.p;
+        for (const d of p.datas) {
+            if (map === tagMap(d.name))
+                return this.value(d, key).c;
+            if (map === sizeMap(d.name))
+                return sizeOf(d, this.value(d, key));
+            for (const [j, c] of d.ctors.entries()) {
+                for (const [i, f] of c.fields.entries())
+                    if (map === fieldMap(d, j, i)) {
+                        const v = this.value(d, key);
+                        return v.c === j ? this.code(f.sort === 'nat' ? 'nat' : d, v.f[i]) : 0;
+                    }
+                if (c.fields.length && map === ctorMap(d, j)) {
+                    const as = unkey(key, c.fields.length);
+                    return this.id(d, { c: j, f: c.fields.map((f, i) => this.decode(f.sort === 'nat' ? 'nat' : d, as[i])) });
+                }
+            }
+        }
+        const f = p.fns.find(g => g.name === map);
+        if (f) {
+            const as = unkey(key, f.params.length);
+            const env = new Map(f.params.map((q, i) => [`${f.name}.${q.name}`, this.decode(q.sort, as[i])]));
+            const out = evalX(f.body(), env, this.params);
+            return f.ret === 'nat' || f.ret === 'bool' ? out : this.id(f.ret, out);
+        }
+        const prm = this.params[map];
+        if (prm)
+            return prm(key);
+        throw new Error(`no map ${map}`);
+    }
+    evalE(e, env) {
+        let m = this.terms.get(env);
+        if (!m)
+            this.terms.set(env, (m = new WeakMap()));
+        const had = m.get(e);
+        if (had !== undefined)
+            return had;
+        const out = this.evalNew(e, env);
+        m.set(e, out);
+        return out;
+    }
+    evalNew(e, env) {
+        switch (e.op) {
+            case 'var': {
+                const v = env[e.name];
+                if (v === undefined)
+                    throw new Error(`unbound ${e.name}`);
+                return v;
+            }
+            case 'const': return e.value;
+            case 'add': return this.evalE(e.a, env) + this.evalE(e.b, env);
+            case 'sub': return Math.max(0, this.evalE(e.a, env) - this.evalE(e.b, env));
+            case 'min': return Math.min(this.evalE(e.a, env), this.evalE(e.b, env));
+            case 'max': return Math.max(this.evalE(e.a, env), this.evalE(e.b, env));
+            case 'mul': return e.k * this.evalE(e.a, env);
+            case 'prod': return this.evalE(e.a, env) * this.evalE(e.b, env);
+            case 'if': return this.evalC(e.c, env) ? this.evalE(e.then, env) : this.evalE(e.else, env);
+            case 'get': return this.read(e.map, this.evalE(e.key, env));
+        }
+    }
+    evalC(c, env) {
+        switch (c.op) {
+            case '<': return this.evalE(c.a, env) < this.evalE(c.b, env);
+            case '<=': return this.evalE(c.a, env) <= this.evalE(c.b, env);
+            case '=': return this.evalE(c.a, env) === this.evalE(c.b, env);
+            case 'and': return c.xs.every(x => this.evalC(x, env));
+            case 'or': return c.xs.some(x => this.evalC(x, env));
+            case 'not': return !this.evalC(c.x, env);
+            case 'flag':
+            case 'all': throw new Error(`${c.op} isn't in the encoding`);
+        }
+    }
+}
+export const sizeOf = (d, v) => { const o = v; return 1 + d.ctors[o.c].fields.reduce((s, f, i) => s + (f.sort === 'self' ? sizeOf(d, o.f[i]) : 0), 0); };
+const isqrt = (n) => { let s = Math.floor(Math.sqrt(n)); while (s * s > n)
+    s--; while ((s + 1) * (s + 1) <= n)
+    s++; return s; };
+export function unkey(key, n) {
+    if (n === 1)
+        return [key];
+    const s = isqrt(key), b = key - s * s, a = s - b;
+    return [...unkey(a, n - 1), b];
+}
+// Random values of the law's variables: a law false at one is refuted with it.
+export function refute(l, n = 400, seed = 7) {
+    for (const s of samples(l.vars, programOf([l]).params, n, seed)) {
+        let ok;
+        try {
+            ok = evalY(l.holds, s.env, s.params);
+        }
+        catch (e) {
+            throw new Error(`${l.name}: ${e.message}`);
+        }
+        if (!ok)
+            return Object.fromEntries(l.vars.map(v => [v.name, showValue(v.sort, s.env.get(v.name))]));
+    }
+    return undefined;
+}
+function schemes(p, l) {
+    const out = [], seen = new Set();
+    const add = (s) => { const id = JSON.stringify(s.uses); if (!seen.has(id)) {
+        seen.add(id);
+        out.push(s);
+    } };
+    // Recursion induction: each call of the law to a recursive function at the law's variables, its recursive calls'
+    // arguments as the uses' substitution (where the case's tag holds).
+    walk(l.holds, o => {
+        if (o.op !== 'call')
+            return;
+        const f = fnOf(o.fn), args = o.args;
+        f.body();
+        if (f.decreases === undefined)
+            return;
+        const at = args[f.decreases];
+        if (at.op !== 'var' || !l.vars.some(v => v.name === at.name))
+            return;
+        const d = f.params[f.decreases].sort;
+        const formal = new Map(f.params.map((q, i) => [`${f.name}.${q.name}`, args[i].op === 'var' && l.vars.some(v => v.name === args[i].name) ? ev(args[i].name) : undefined]));
+        const uses = [];
+        const go = (x, env, guard) => {
+            if (!x || typeof x !== 'object')
+                return;
+            if (Array.isArray(x)) {
+                x.forEach(y => go(y, env, guard));
+                return;
+            }
+            const t = x;
+            if (t.op === 'match') {
+                go(t.of, env, guard);
+                const dd = dataOf(p, t.data), of = encX(p, t.of, env);
+                t.cases.forEach((c, j) => { const e2 = new Map(env); c.binds.forEach((b, i) => e2.set(b, get(fieldMap(dd, j, i), of))); go(c.body, e2, [...guard, eqC(get(tagMap(dd.name), of), k(j))]); });
+                return;
+            }
+            if (t.op === 'call' && t.fn === f.name) {
+                const subst = {};
+                let ok = true;
+                t.args.forEach((a, i) => {
+                    const lv = args[i];
+                    if (lv.op !== 'var' || !l.vars.some(v => v.name === lv.name)) {
+                        ok = ok && JSON.stringify(a) === JSON.stringify({ op: 'var', name: `${f.name}.${f.params[i].name}` });
+                        return;
+                    }
+                    const e = encX(p, a, env);
+                    if (JSON.stringify(e) !== JSON.stringify(ev(lv.name)))
+                        subst[lv.name] = e;
+                });
+                if (ok && Object.keys(subst).length)
+                    uses.push({ subst, guard: andC(yesC, ...guard) });
+            }
+            for (const v of Object.values(t))
+                go(v, env, guard);
+        };
+        const env = new Map([...formal].flatMap(([key, e]) => (e ? [[key, e]] : [])));
+        go(f.body(), env, []);
+        if (uses.length)
+            add({ name: `recursion of ${f.name} on ${at.name}`, on: { v: at.name, d }, uses });
+    });
+    // Structural induction on each variable of a datatype, the others fixed.
+    for (const v of l.vars) {
+        if (!(v.sort instanceof Data))
+            continue;
+        const d = v.sort, x = ev(v.name);
+        add({ name: `structure of ${v.name}`, on: { v: v.name, d }, uses: d.ctors.flatMap((c, j) => c.fields.flatMap((f, i) => (f.sort === 'self' ? [{ subst: { [v.name]: get(fieldMap(d, j, i), x) }, guard: eqC(get(tagMap(d.name), x), k(j)) }] : []))) });
+    }
+    return out;
+}
+function instancesOf(p, fs, w) {
+    // Past the attempt's time, what is found so far (the attempt then fails or proves with it).
+    const late = () => w.until !== undefined && performance.now() > w.until;
+    const tt = performance.now(), lap = (what) => { if (dataTrace)
+        console.error(`[data]   instances: ${what} at ${Math.round(performance.now() - tt)} ms`); };
+    const insts = [], seen = new Set();
+    const inst = (fact, at) => { const i = fs.at.get(fact); if (i === undefined)
+        return; const id = JSON.stringify([i, at]); if (!seen.has(id)) {
+        seen.add(id);
+        insts.push({ fact: i, at });
+    } };
+    const holdsAt = (fact, at) => { const f = fs.facts[fs.at.get(fact)]; return substC(f.holds, { vars: Object.fromEntries(f.keys.map((key, q) => [key, at[q]])), maps: {}, flags: {} }); };
+    const reads = (t) => { const out = []; walk(t, o => { if (o.op === 'get')
+        out.push({ map: o.map, key: o.key }); }); return out; };
+    const fnOfMap = (map) => p.fns.find(g => g.name === map);
+    const ctorOf = (map) => { for (const d of p.datas)
+        for (const [j, c] of d.ctors.entries())
+            if (c.fields.length && map === ctorMap(d, j))
+                return c.fields.length; return undefined; };
+    const all = [], had = new Set();
+    const note = (rs) => { const out = []; for (const r of rs) {
+        const id = JSON.stringify(r);
+        if (!had.has(id)) {
+            had.add(id);
+            all.push(r);
+            out.push(r);
+        }
+    } return out; };
+    // Constructor facts at every constructor read, closed under the reads they bring.
+    const ctors = (rs) => {
+        let todo = rs;
+        while (todo.length) {
+            const next = [];
+            for (const r of todo) {
+                const n = ctorOf(r.map), as = n && argsOf(r.key, n);
+                if (n && as) {
+                    inst(`ctor ${r.map}`, as);
+                    next.push(...note(reads(holdsAt(`ctor ${r.map}`, as))));
+                }
+            }
+            todo = next;
+        }
+    };
+    const unfolded = new Set();
+    let frontier = reads(w.depth >= 3 ? [w.roots, w.others] : w.roots);
+    note(frontier);
+    note(reads(w.others));
+    ctors(all);
+    for (let round = 0; round < w.depth && frontier.length; round++) {
+        const next = [];
+        for (const r of frontier) {
+            const f = fnOfMap(r.map), as = f && argsOf(r.key, f.params.length), rid = JSON.stringify(r);
+            if (!f || !as || unfolded.has(rid))
+                continue;
+            unfolded.add(rid);
+            inst(`fn ${f.name}`, as);
+            const body = reads(holdsAt(`fn ${f.name}`, as));
+            ctors(note(body));
+            next.push(...body);
+        }
+        frontier = next;
+    }
+    lap(`unfolded, ${insts.length} instances, ${all.length} reads`);
+    const closure = (model) => {
+        const parent = new Map(), terms = new Map(), adj = new Map();
+        const find = (x) => { let r = x; while (parent.has(r))
+            r = parent.get(r); return r; };
+        const linked = new Set();
+        const edge = (x, y, cong) => {
+            const a2 = tid(x), b2 = tid(y);
+            terms.set(a2, x);
+            terms.set(b2, y);
+            if (a2 === b2)
+                return false;
+            const merged = find(a2) !== find(b2);
+            // A congruence is recorded even between reads already of one class (they may be so only through a constant).
+            if (!merged && (!cong || linked.has(a2 < b2 ? `${a2}|${b2}` : `${b2}|${a2}`)))
+                return false;
+            linked.add(a2 < b2 ? `${a2}|${b2}` : `${b2}|${a2}`);
+            if (merged)
+                parent.set(find(a2), find(b2));
+            (adj.get(a2) ?? adj.set(a2, []).get(a2)).push({ to: b2, cong });
+            (adj.get(b2) ?? adj.set(b2, []).get(b2)).push({ to: a2, cong: cong && { map: cong.map, x: cong.y, y: cong.x } });
+            return merged;
+        };
+        const truthOf = (c) => { if (!model)
+            return undefined; try {
+            return model.m.evalC(c, model.env);
+        }
+        catch {
+            return undefined;
+        } };
+        const leaves = (e) => { if (e.op !== 'if')
+            return [e]; const t = truthOf(e.c); return t === undefined ? [...leaves(e.then), ...leaves(e.else)] : leaves(t ? e.then : e.else); };
+        const active = (c) => {
+            if (c.op === 'and') {
+                c.xs.forEach(active);
+                return;
+            }
+            if (c.op === 'or') {
+                if (!model) {
+                    c.xs.forEach(x => { if (x.op !== 'not')
+                        active(x); });
+                    return;
+                }
+                const open = c.xs.filter(x => truthOf(x) !== false);
+                if (open.length === 1)
+                    active(open[0]);
+                else {
+                    const neg = c.xs.find(x => x.op === 'not' && truthOf(x.x) === true);
+                    if (neg)
+                        c.xs.filter(x => x !== neg).forEach(x => { if (truthOf(x) === true)
+                            active(x); });
+                }
+                return;
+            }
+            if (c.op === '=' && (!model || truthOf(c) === true))
+                for (const leaf of leaves(c.b))
+                    edge(c.a, leaf);
+        };
+        for (const q of insts)
+            active(holdsAt(fs.facts[q.fact].name, q.at));
+        for (const c of w.others)
+            active(c);
+        const cells = new Map();
+        for (const r of all) {
+            const n = fs.arity.get(r.map), as = n ? argsOf(r.key, n) : undefined;
+            if (as)
+                (cells.get(r.map) ?? cells.set(r.map, []).get(r.map)).push({ key: r.key, as });
+        }
+        for (let changed = true; changed && !late();) {
+            changed = false;
+            for (const [map, list] of cells) {
+                const bySig = new Map();
+                for (const x of list) {
+                    const sig = x.as.map(t => find(tid(t))).join('\u0001'), y = bySig.get(sig);
+                    if (!y) {
+                        bySig.set(sig, x);
+                        continue;
+                    }
+                    if (tid(y.key) !== tid(x.key) && edge(get(map, y.key), get(map, x.key), { map, x: y.as, y: x.as }))
+                        changed = true;
+                }
+            }
+        }
+        return { find, terms, adj, truthOf };
+    };
+    // A function read whose decreasing argument a model's classes make a constructor's value (the argument itself, or a
+    // term of its class) unfolds there too: where the definition's match is decided. Each such instance stands for the
+    // reads it was unfolded for (`reached` keeps it in a case where it is one of them).
+    if (w.depth >= 1) {
+        let extra = 0;
+        for (const model of w.models.length ? w.models : [undefined]) {
+            if (late())
+                break;
+            const cl = closure(model);
+            // Once per function and class of its arguments (this model's): a term the facts already make equal to one
+            // unfolded brings nothing new.
+            const sigOf = (fn, as) => `${fn}(${as.map(a => cl.find(tid(a))).join(',')})`;
+            const done = new Set();
+            for (const q of insts) {
+                const name = fs.facts[q.fact].name;
+                if (name.startsWith('fn '))
+                    done.add(sigOf(name.slice(3), q.at));
+            }
+            for (const r of [...all]) {
+                const f = fnOfMap(r.map);
+                if (!f || f.decreases === undefined)
+                    continue;
+                const as = argsOf(r.key, f.params.length);
+                if (!as)
+                    continue;
+                const own = as[f.decreases], d = f.params[f.decreases].sort, root = cl.find(tid(own));
+                const built = (t) => (t.op === 'get' && d.ctors.some((c, j) => c.fields.length && t.map === ctorMap(d, j))) || (t.op === 'const' && t.value < d.nullary);
+                const cands = built(own) ? [own] : [...cl.terms.values()].filter(t => built(t) && cl.find(tid(t)) === root);
+                for (const t of cands) {
+                    const as2 = as.map((a, i) => (i === f.decreases ? t : a)), rid = JSON.stringify({ map: f.name, key: keyOf(as2) }), key2 = JSON.stringify([fs.at.get(`fn ${f.name}`), as2]);
+                    const anchor = { read: tid(get(f.name, r.key)), arg: own, value: t }, had = anchoredAt.get(key2) ?? [];
+                    if (!had.some(x => x.read === anchor.read))
+                        anchoredAt.set(key2, [...had, anchor]);
+                    if (unfolded.has(rid) || extra >= 12 || done.has(sigOf(f.name, as2)))
+                        continue;
+                    unfolded.add(rid);
+                    extra++;
+                    done.add(sigOf(f.name, as2));
+                    if (dataTrace)
+                        console.error(`[data]     unfold ${f.name} at ${JSON.stringify(as2).slice(0, 160)} for ${JSON.stringify(r.key).slice(0, 80)}`);
+                    inst(`fn ${f.name}`, as2);
+                    note([{ map: f.name, key: keyOf(as2) }]);
+                    ctors(note(reads(holdsAt(`fn ${f.name}`, as2))));
+                }
+            }
+        }
+    }
+    lap(`by constructors, ${insts.length} instances, ${all.length} reads`);
+    const dataOfTerm = (t) => {
+        if (t.op === 'get') {
+            for (const d of p.datas)
+                if (t.map === tagMap(d.name) || t.map === sizeMap(d.name))
+                    return d;
+            const f = fnOfMap(t.map);
+            if (f && f.ret instanceof Data)
+                return f.ret;
+            for (const d of p.datas)
+                for (const [j, c] of d.ctors.entries()) {
+                    if (c.fields.length && t.map === ctorMap(d, j))
+                        return d;
+                    for (const [i, fl] of c.fields.entries())
+                        if (fl.sort === 'self' && t.map === fieldMap(d, j, i))
+                            return d;
+                }
+        }
+        return undefined;
+    };
+    const shape = (t, d) => { const dd = d ?? dataOfTerm(t); if (dd) {
+        inst(`shape ${dd.name}`, [t]);
+        ctors(note(reads(holdsAt(`shape ${dd.name}`, [t]))));
+    } };
+    for (const t of w.shapesAt)
+        shape(t, typeOfVar(p, t));
+    if (w.depth >= 2)
+        for (const r of [...all])
+            for (const d of p.datas)
+                if (r.map === tagMap(d.name))
+                    shape(r.key, d);
+    for (const t of w.etaAt) {
+        const d = typeOfVar(p, t) ?? dataOfTerm(t);
+        if (d) {
+            inst(`eta ${d.name}`, [t]);
+            shape(t, d);
+            ctors(note(reads(holdsAt(`eta ${d.name}`, [t]))));
+        }
+    }
+    // A constant's tag is read where its tag is (the nullary facts).
+    for (const d of p.datas)
+        if (d.nullary && all.some(r => r.map === tagMap(d.name))) {
+            inst(`nullary ${d.name}`, []);
+            for (let j = 0; j < d.nullary; j++)
+                all.push({ map: tagMap(d.name), key: k(j) });
+        }
+    // Congruences (a map is a function), in each model: every value the model reads explained against one of its class
+    // (the path between them, each congruence on it explained in turn); the congruences the explanations use are the
+    // instances (with `every`, those that every model's explanations use).
+    const used = new Map();
+    for (const model of w.models) {
+        if (late())
+            break;
+        const { find, adj, truthOf } = closure(model);
+        const counted = new Set(), explained = new Set();
+        const explain = (a2, b2) => {
+            const key = a2 < b2 ? `${a2}|${b2}` : `${b2}|${a2}`;
+            if (a2 === b2 || explained.has(key))
+                return;
+            explained.add(key);
+            const back = new Map([[a2, { from: '' }]]), queue = [a2];
+            // A path through no constant first: two terms the model gives one value aren't equal for that alone (each needs
+            // its own facts), and a congruence between them is what the proof can use; else one through a constant.
+            const isConst = (x) => x !== a2 && x !== b2 && x.startsWith('{"op":"const"');
+            for (const avoid of [true, false]) {
+                if (back.has(b2))
+                    break;
+                back.clear();
+                back.set(a2, { from: '' });
+                queue.length = 0;
+                queue.push(a2);
+                while (queue.length && !back.has(b2)) {
+                    const x = queue.shift();
+                    if (avoid && isConst(x))
+                        continue;
+                    for (const e of adj.get(x) ?? [])
+                        if (!back.has(e.to)) {
+                            back.set(e.to, { from: x, cong: e.cong });
+                            queue.push(e.to);
+                        }
+                }
+            }
+            if (!back.has(b2))
+                return;
+            for (let at = b2; at !== a2;) {
+                const step = back.get(at);
+                if (step.cong) {
+                    const c = step.cong, k2 = JSON.stringify([c.map, c.x, c.y]);
+                    if (!counted.has(k2)) {
+                        counted.add(k2);
+                        const had = used.get(k2) ?? used.get(JSON.stringify([c.map, c.y, c.x]));
+                        if (had)
+                            had.n++;
+                        else
+                            used.set(k2, { map: c.map, at: [...c.x, ...c.y], n: 1 });
+                    }
+                    c.x.forEach((t, q) => explain(tid(t), tid(c.y[q])));
+                }
+                at = step.from;
+            }
+        };
+        // The values this model reads: the conclusions' reads, and each fact's where the model takes it (an if's condition
+        // and taken branch, an implication's conclusion where its premise holds).
+        const read = new Set();
+        const look = (t, whole) => {
+            if (!t || typeof t !== 'object')
+                return;
+            if (Array.isArray(t)) {
+                t.forEach(x => look(x, whole));
+                return;
+            }
+            const o = t;
+            if (!whole && o.op === 'if') {
+                look(o.c, whole);
+                const b2 = truthOf(o.c);
+                if (b2 !== false)
+                    look(o.then, whole);
+                if (b2 !== true)
+                    look(o.else, whole);
+                return;
+            }
+            if (!whole && o.op === 'or' && o.xs.length === 2 && o.xs[0].op === 'not') {
+                look(o.xs[0], whole);
+                if (truthOf(o.xs[0].x) !== false)
+                    look(o.xs[1], whole);
+                return;
+            }
+            if (o.op === 'get') {
+                read.add(tid(o));
+                return;
+            }
+            for (const v of Object.values(o))
+                look(v, whole);
+        };
+        look([w.roots, w.others], true);
+        look(insts.map(q => holdsAt(fs.facts[q.fact].name, q.at)), false);
+        const byClass = new Map();
+        for (const v of read) {
+            const r = find(v);
+            (byClass.get(r) ?? byClass.set(r, []).get(r)).push(v);
+        }
+        // Within a class, first the parts that join without a constant (each value against its part's first), then the parts.
+        const isConstId = (x) => x.startsWith('{"op":"const"');
+        for (const vs of byClass.values()) {
+            if (vs.length < 2)
+                continue;
+            const part = new Map();
+            for (const v of vs) {
+                if (part.has(v))
+                    continue;
+                const seen = new Set([v]), queue = [v];
+                while (queue.length) {
+                    const x = queue.shift();
+                    for (const e of adj.get(x) ?? [])
+                        if (!seen.has(e.to) && !isConstId(e.to)) {
+                            seen.add(e.to);
+                            queue.push(e.to);
+                        }
+                }
+                for (const u of vs)
+                    if (seen.has(u) && !part.has(u))
+                        part.set(u, v);
+            }
+            for (const v of vs)
+                if (part.get(v) !== v)
+                    explain(part.get(v), v);
+            const heads = [...new Set(part.values())];
+            for (const h of heads.slice(1))
+                explain(heads[0], h);
+        }
+        if (allCong)
+            for (const es of adj.values())
+                for (const e of es)
+                    if (e.cong) {
+                        const k2 = JSON.stringify([e.cong.map, e.cong.x, e.cong.y]), k3 = JSON.stringify([e.cong.map, e.cong.y, e.cong.x]);
+                        if (!used.has(k2) && !used.has(k3))
+                            used.set(k2, { map: e.cong.map, at: [...e.cong.x, ...e.cong.y], n: 1 });
+                    }
+    }
+    for (const d of used.values())
+        if (!w.every || d.n >= w.models.length)
+            inst(`cong ${d.map}`, d.at);
+    lap(`congruences, ${insts.length} instances, ${w.models.length} models`);
+    return insts;
+}
+let varSorts = new Map();
+// A term's text, once per object (terms are compared by it, and some are large).
+const idMemo = new WeakMap();
+const tid = (t) => { let out = idMemo.get(t); if (out === undefined)
+    idMemo.set(t, (out = JSON.stringify(t))); return out; };
+// An instance unfolded where a read's argument equals a constructor's value: the read it stands for (for `reached`).
+const anchoredAt = new Map();
+const typeOfVar = (_p, t) => (t.op === 'var' ? varSorts.get(t.name) : undefined);
+// The values a law's conclusion compares (eta is wanted at each: a variable equal to a value built is the constructor at
+// its own fields).
+function valuesCompared(p, l) {
+    const out = [];
+    const dataTerm = (x) => (x.op === 'var' ? l.vars.some(v => v.name === x.name && v.sort instanceof Data) : x.op === 'call' ? fnOf(x.fn).ret instanceof Data : x.op === 'ctor');
+    walk(l.holds, o => { if (o.op === '=' && dataTerm(o.a))
+        for (const side of [o.a, o.b])
+            if (side.op === 'var')
+                out.push(encX(p, side, new Map())); });
+    return out;
+}
+// Where a lemma's terms appear in a goal: a substitution of its variables by terms of the goal, for each term of the goal
+// that one of the lemma's sides matches (its variables read anywhere, the rest exactly).
+function matches(pattern, vars, t, s) {
+    if (pattern.op === 'var' && vars.has(pattern.name)) {
+        const had = s[pattern.name];
+        if (had)
+            return JSON.stringify(had) === JSON.stringify(t) ? s : undefined;
+        return { ...s, [pattern.name]: t };
+    }
+    if (pattern.op !== t.op)
+        return undefined;
+    const po = pattern, to = t;
+    let out = s;
+    for (const key of Object.keys(po)) {
+        if (!out)
+            return undefined;
+        const a = po[key], b = to[key];
+        if (a && typeof a === 'object' && 'op' in a) {
+            if (!b || typeof b !== 'object')
+                return undefined;
+            if (a.op && ['<', '<=', '=', 'and', 'or', 'not'].includes(a.op))
+                out = JSON.stringify(a) === JSON.stringify(b) ? out : undefined;
+            else
+                out = matches(a, vars, b, out);
+        }
+        else if (JSON.stringify(a) !== JSON.stringify(b))
+            return undefined;
+    }
+    return out;
+}
+function casesOf(p, unfolded, vars, models) {
+    const plain = (e) => (e.op === 'var' ? vars.has(e.name) : e.op === 'const' ? true : e.op === 'get' ? p.datas.some(d => e.map.startsWith(`${d.name}.`)) && !p.datas.some(d => d.ctors.some((c, j) => c.fields.length > 0 && e.map === ctorMap(d, j))) && plain(e.key)
+        : e.op === 'add' || e.op === 'sub' || e.op === 'min' || e.op === 'max' ? plain(e.a) && plain(e.b) : e.op === 'mul' ? plain(e.a) : false);
+    const plainC = (c) => JSON.stringify(c).includes('"op":"var"') && (c.op === '<' || c.op === '<=' || c.op === '=' ? plain(c.a) && plain(c.b) : c.op === 'not' ? plainC(c.x) : c.op === 'and' || c.op === 'or' ? c.xs.every(plainC) : false);
+    // The functions' facts the goal unfolds.
+    const roots = unfolded;
+    const sigs = models.map(({ m, env }) => {
+        const out = new Map();
+        const truthOf = (c) => { try {
+            return m.evalC(c, env);
+        }
+        catch {
+            return undefined;
+        } };
+        const go = (t) => {
+            if (!t || typeof t !== 'object')
+                return;
+            if (Array.isArray(t)) {
+                t.forEach(go);
+                return;
+            }
+            const o = t;
+            if (o.op === 'if') {
+                const v = truthOf(o.c);
+                if (v === undefined)
+                    return;
+                if (plainC(o.c)) {
+                    const key = JSON.stringify(o.c);
+                    if (!out.has(key))
+                        out.set(key, { c: o.c, t: v });
+                }
+                go(v ? o.then : o.else);
+                return;
+            }
+            for (const val of Object.values(o))
+                go(val);
+        };
+        go(roots);
+        return out;
+    });
+    const build = (ms, lits, decided, depth) => {
+        const count = new Map();
+        for (const i of ms)
+            for (const key of sigs[i].keys())
+                if (!decided.has(key))
+                    count.set(key, (count.get(key) ?? 0) + 1);
+        const pick = [...count.entries()].sort((a2, b2) => b2[1] - a2[1])[0];
+        if (!pick || depth >= 4)
+            return [{ lits, models: ms.length ? ms.map(i => models[i]) : undefined }];
+        const key = pick[0], c = ms.map(i => sigs[i].get(key)).find(x => x).c;
+        const side = (t) => ms.filter(i => sigs[i].get(key)?.t !== !t);
+        const d2 = new Set([...decided, key]);
+        // A guard every one of many models takes one way is not split (its other side is likely no case at all).
+        if (ms.length >= 20 && (!side(true).length || !side(false).length))
+            return build(ms, lits, d2, depth);
+        return [true, false].flatMap(t => { const s2 = side(t), lit = t ? c : { op: 'not', x: c }; return s2.length ? build(s2, [...lits, lit], d2, depth + 1) : [{ lits: [...lits, lit], models: undefined, near: ms.map(i => models[i]) }]; });
+    };
+    return build(models.map((_, i) => i), [], new Set(), 0);
+}
+// One attempt: the law's node (and the lemmas', proven before, with their own nodes) at a scheme and a depth. With
+// several cases, a main node uses a node per case (each its guards as hypotheses, its own instances), at rank
+// (level, size, 1) above theirs (level, size, 0); a case node uses the main node at the children.
+const dataTrace = !!globalThis.process?.env?.DATA_TRACE;
+// Debugging: every congruence a model's closure makes, not only those explanations use.
+const allCong = !!globalThis.process?.env?.DATA_ALLCONG;
+function attempt(p, fs, l, scheme, depth, lemmas, level, pool) {
+    const t0 = performance.now();
+    anchoredAt.clear();
+    // A few models for the instances; the whole pool for the cases (a rare case gets its own models from it).
+    const models = pool.slice(0, 24), few = (ms) => ms.slice(0, 16);
+    const concl = encY(p, l.holds, new Map());
+    const specs = [], where = new Map();
+    for (const lm of lemmas) {
+        const local = new Map();
+        lm.nodes.forEach((n, i) => {
+            if (where.has(n.name)) {
+                local.set(i, where.get(n.name));
+                return;
+            }
+            local.set(i, specs.length);
+            where.set(n.name, specs.length);
+            specs.push({ ...n, uses: n.uses.map(u => ({ ...u, node: local.get(u.node) ?? u.node })) });
+        });
+    }
+    const me = specs.length, name = `${l.name}${scheme ? ` (${scheme.name})` : ''}`;
+    varSorts = new Map(l.vars.flatMap(v => (v.sort instanceof Data ? [[v.name, v.sort]] : [])));
+    const size = scheme?.on ? get(sizeMap(scheme.on.d.name), ev(scheme.on.v)) : k(0);
+    const rank = (sub) => [k(level), size, k(sub)];
+    const ih = (scheme?.uses ?? []).map(u => ({ node: me, subst: u.subst, guard: u.guard }));
+    const shapesAt = scheme?.on ? [ev(scheme.on.v)] : [];
+    const ihConcls = ih.map(u => substC(concl, { vars: u.subst, maps: {}, flags: {} }));
+    // Uses of the lemmas, where a lemma's largest read matches a read of this goal (unfolded), its key up to the equalities
+    // the unfolded definitions give (any branch); twice over, the uses' own conclusions read the second time.
+    const pre = instancesOf(p, fs, { roots: [concl], others: ihConcls, depth, shapesAt, etaAt: [], models: [], until: t0 + attemptMs.ms });
+    const lemmaUses = lemmaUsesFor(p, fs, lemmas.map(lm => ({ law: lm.law, node: where.get(lm.spec.name), concl: specs[where.get(lm.spec.name)].concl })), [concl, ihConcls], pre, models);
+    const uses = [...ih, ...lemmaUses];
+    if (dataTrace)
+        for (const u of lemmaUses)
+            console.error(`[data]   lemma use ${specs[u.node].name.slice(0, 40)} at ${Object.entries(u.subst).map(([x, t]) => `${x} := ${JSON.stringify(t).slice(0, 80)}`).join('; ')}`);
+    const useConcl = (u) => substC(u.node === me ? concl : specs[u.node].concl, { vars: u.subst, maps: {}, flags: {} });
+    // The lemmas' conclusions are unfolded like the law's (they are what the goal reads, said another way); the cycle's
+    // own uses only from depth 3.
+    const instsFor = (ms, us, every = false) => instancesOf(p, fs, { roots: [concl], others: us.map(useConcl), depth, shapesAt, etaAt: [...shapesAt, ...valuesCompared(p, l)], models: ms, every, until: t0 + attemptMs.ms });
+    const cases = scheme ? casesOf(p, pre.filter(q => fs.facts[q.fact].name.startsWith('fn ')).map(q => holdsAt(fs, q)), new Set(l.vars.map(v => v.name)), pool) : [];
+    if (cases.length <= 1) {
+        specs.push({ name, hyps: [], concl, rank: rank(0), insts: instsFor(models, uses), uses });
+    }
+    else {
+        specs.push({ name, hyps: [], concl, rank: rank(1), insts: [], uses: cases.map((c, i) => ({ node: me + 1 + i, subst: {}, guard: andC(yesC, ...c.lits) })) });
+        for (const [i, c] of cases.entries()) {
+            // The uses whose guard some model of the case meets (all, for a case no model reaches).
+            const holdsIn = (g) => !c.models || c.models.some(({ m, env }) => { try {
+                return m.evalC(g, env);
+            }
+            catch {
+                return true;
+            } });
+            // A lemma's use where its read is the goal's read it matched, in every model of the case.
+            const applies = (u) => { const at = matchedAt.get(u); return !at || !c.models || c.models.every(({ m, env }) => { try {
+                return m.evalE(at.goal, env) === m.evalE(at.lemma, env);
+            }
+            catch {
+                return false;
+            } }); };
+            const us = uses.filter(u => holdsIn(u.guard) && applies(u));
+            const ms = few(c.models ?? c.near ?? models);
+            specs.push({ name: `${name}, case ${i + 1}`, hyps: c.lits, concl, rank: rank(0), insts: reached(p, fs, instsFor(ms, us), [c.lits, concl, us.map(u => [u.guard, useConcl(u)]), shapesAt], ms), uses: us });
+        }
+    }
+    // Each attempt within its own time (a goal past it is left unknown, and the attempt fails).
+    if (dataTrace)
+        console.error(`[data] @${Math.round(performance.now())} ${l.name} (${scheme?.name}) depth ${depth}, ${lemmas.length} lemmas: built in ${Math.round(performance.now() - t0)} ms, ${specs.length} nodes, ${specs.reduce((n, x) => n + x.insts.length, 0)} instances`);
+    if (performance.now() > t0 + attemptMs.ms)
+        return { verdict: { proven: false, checked: false, node: name, goal: name, stuck: 'unknown' }, specs };
+    const was = pairedKeys.skip;
+    pairedKeys.skip = true;
+    try {
+        return { verdict: withDeadline(t0 + attemptMs.ms, () => proveCyclic(fs.facts, specs)), specs };
+    }
+    finally {
+        pairedKeys.skip = was;
+    }
+}
+export const attemptMs = { ms: 8000 };
+// A case node's instances, those its models reach: from every read of its conclusion and its uses' (and their guards),
+// through each instance at a read reached (a function's at its call, a constructor's at its cell, a shape or eta at a
+// value whose tag is read), the reads of what it gives where the models take it (an if's taken branch, an implication's
+// conclusion where its premise holds); a congruence where both its reads are reached.
+function reached(p, fs, insts, from, ms) {
+    const reach = new Set(), id = (t) => JSON.stringify(t);
+    const active = (t, m, env) => {
+        if (!t || typeof t !== 'object')
+            return;
+        if (Array.isArray(t)) {
+            t.forEach(x => active(x, m, env));
+            return;
+        }
+        const o = t;
+        const truth = (c) => { try {
+            return m.evalC(c, env);
+        }
+        catch {
+            return undefined;
+        } };
+        if (o.op === 'if') {
+            active(o.c, m, env);
+            const v = truth(o.c);
+            if (v !== false)
+                active(o.then, m, env);
+            if (v !== true)
+                active(o.else, m, env);
+            return;
+        }
+        if (o.op === 'or' && o.xs.length === 2 && o.xs[0].op === 'not') {
+            active(o.xs[0], m, env);
+            if (truth(o.xs[0].x) !== false)
+                active(o.xs[1], m, env);
+            return;
+        }
+        if (o.op === 'get')
+            reach.add(id(o));
+        for (const v of Object.values(o))
+            active(v, m, env);
+    };
+    const each = (t) => { for (const { m, env } of ms)
+        active(t, m, env); };
+    // The conclusion and the uses' are read whole: the goal is where the law fails, which no model is.
+    walk(from, o => { if (o.op === 'get')
+        reach.add(JSON.stringify(o)); });
+    const anchor = (q) => {
+        const name = fs.facts[q.fact].name;
+        if (name.startsWith('fn '))
+            return [get(name.slice(3), keyOf(q.at))];
+        if (name.startsWith('ctor '))
+            return [get(name.slice(5), keyOf(q.at))];
+        if (name.startsWith('shape ') || name.startsWith('eta ')) {
+            const d = name.split(' ')[1];
+            return [get(tagMap(d), q.at[0]), get(sizeMap(d), q.at[0]), ...p.datas.filter(x => x.name === d).flatMap(x => x.ctors.flatMap((c, j) => c.fields.map((_, i) => get(fieldMap(x, j, i), q.at[0]))))];
+        }
+        return [];
+    };
+    const kept = new Set();
+    // A constant's tag (the nullary facts) is read wherever its constant is.
+    for (const [i, q] of insts.entries())
+        if (fs.facts[q.fact].name.startsWith('nullary ')) {
+            kept.add(i);
+            each(holdsAt(fs, q));
+        }
+    for (let changed = true; changed;) {
+        changed = false;
+        for (const [i, q] of insts.entries()) {
+            if (kept.has(i))
+                continue;
+            const name = fs.facts[q.fact].name;
+            if (name.startsWith('cong ') || name.startsWith('nullary '))
+                continue;
+            const virtual = anchoredAt.get(JSON.stringify([q.fact, q.at])) ?? [];
+            const same = (v) => ms.every(({ m, env }) => { try {
+                return m.evalE(v.arg, env) === m.evalE(v.value, env);
+            }
+            catch {
+                return false;
+            } });
+            if (!anchor(q).some(a => reach.has(id(a))) && !virtual.some(v => reach.has(v.read) && same(v)))
+                continue;
+            kept.add(i);
+            changed = true;
+            each(holdsAt(fs, q));
+        }
+    }
+    return insts.filter((q, i) => {
+        if (kept.has(i))
+            return true;
+        const name = fs.facts[q.fact].name;
+        if (name.startsWith('nullary '))
+            return true;
+        if (!name.startsWith('cong '))
+            return false;
+        const m = name.slice(5), n = q.at.length / 2;
+        return reach.has(id(get(m, keyOf(q.at.slice(0, n))))) && reach.has(id(get(m, keyOf(q.at.slice(n)))));
+    });
+}
+// The uses of lemmas a goal's reads match: each lemma's largest reads (those inside no other) matched against the goal's
+// reads of the same map at keys equal, by the instances' equations (every branch), to the read's key.
+function lemmaUsesFor(p, fs, lemmas, from, insts, models = []) {
+    const id = tid, parent = new Map(), terms = new Map();
+    const find = (x) => { let r = x; while (parent.has(r))
+        r = parent.get(r); return r; };
+    const union = (x, y) => { terms.set(id(x), x); terms.set(id(y), y); const a = find(id(x)), b = find(id(y)); if (a !== b)
+        parent.set(a, b); };
+    const leaves = (e) => (e.op === 'if' ? [...leaves(e.then), ...leaves(e.else)] : [e]);
+    for (const q of insts)
+        for (const [a, b] of equalities(holdsAt(fs, q)))
+            for (const leaf of leaves(b))
+                union(a, leaf);
+    // Closed under congruence (two reads of one map at arguments of one class), by signatures.
+    const cells = new Map();
+    walk([from, insts.map(q => holdsAt(fs, q))], o => { if (o.op !== 'get')
+        return; const n = fs.arity.get(o.map), as = n ? argsOf(o.key, n) : undefined; if (as)
+        (cells.get(o.map) ?? cells.set(o.map, []).get(o.map)).push({ key: o.key, as }); });
+    for (let changed = true, rounds = 0; changed && rounds < 8; rounds++) {
+        changed = false;
+        for (const [map, list] of cells) {
+            const bySig = new Map();
+            for (const x of list) {
+                const sig = x.as.map(t => find(id(t))).join('\u0001'), y = bySig.get(sig), cx = get(map, x.key);
+                if (!y) {
+                    bySig.set(sig, cx);
+                    continue;
+                }
+                if (find(id(y)) !== find(id(cx))) {
+                    union(y, cx);
+                    changed = true;
+                }
+            }
+        }
+    }
+    const classes = new Map();
+    for (const [key, e] of terms) {
+        const r = find(key);
+        (classes.get(r) ?? classes.set(r, []).get(r)).push(e);
+    }
+    const members = (t) => { const k0 = tid(t); return [t, ...(classes.get(find(k0)) ?? []).filter(e => tid(e) !== k0)]; };
+    const out = [], seen = new Set();
+    let reads = [];
+    walk([from, insts.map(q => holdsAt(fs, q))], o => { if (o.op === 'get')
+        reads.push(o); });
+    for (let round = 0; round < 2; round++) {
+        const fresh = [];
+        // The newest lemma first (the one the law is tried again for).
+        for (const lm of [...lemmas].reverse()) {
+            if (round > 0 && out.some(u => u.node === lm.node))
+                continue;
+            const vars = new Set(lm.law.vars.map(v => v.name)), sides = [];
+            walk(encY(p, lm.law.holds, new Map()), o => { if (o.op === 'get')
+                sides.push(o); });
+            const tops = sides.filter(a => !sides.some(b => b !== a && JSON.stringify(b).includes(JSON.stringify(a))));
+            for (const top of tops)
+                for (const t of reads) {
+                    if (t.op !== 'get' || t.map !== top.map)
+                        continue;
+                    // Each argument of the read matched up to its class (a key of several arguments is their pairing).
+                    const n = fs.arity.get(top.map) ?? 1, pats = argsOf(top.key, n), args = argsOf(t.key, n);
+                    if (!pats || !args)
+                        continue;
+                    let subs = [{}];
+                    for (const [q, pat] of pats.entries())
+                        subs = subs.flatMap(sb => members(args[q]).slice(0, 256).flatMap(m => { const r = matches(pat, vars, m, sb); return r ? [r] : []; })).slice(0, 512);
+                    for (const sub of subs) {
+                        if (Object.keys(sub).length !== vars.size)
+                            continue;
+                        // Where a model gives the lemma's arguments the goal read's (a match through every branch's classes may be none).
+                        const there = pats.map(a => substE(a, { vars: sub, maps: {}, flags: {} }));
+                        if (models.length && !models.some(({ m, env }) => { try {
+                            return there.every((a, q) => m.evalE(a, env) === m.evalE(args[q], env));
+                        }
+                        catch {
+                            return false;
+                        } }))
+                            continue;
+                        const k2 = JSON.stringify([lm.node, sub]);
+                        if (seen.has(k2) || out.length >= 12 || out.filter(u => u.node === lm.node).length >= 4)
+                            continue;
+                        seen.add(k2);
+                        out.push({ node: lm.node, subst: sub, guard: yesC });
+                        matchedAt.set(out.at(-1), { goal: t, lemma: substE(top, { vars: sub, maps: {}, flags: {} }) });
+                        walk(substC(lm.concl, { vars: sub, maps: {}, flags: {} }), o => { if (o.op === 'get')
+                            fresh.push(o); });
+                    }
+                }
+        }
+        reads = fresh;
+    }
+    return out;
+}
+// The equalities a condition may give: those in a positive place (a conjunction's parts, a disjunction's disjuncts that
+// aren't negations, so an implication's conclusion and never its premise).
+function equalities(c) {
+    if (c.op === '=')
+        return [[c.a, c.b]];
+    if (c.op === 'and' || c.op === 'or')
+        return c.xs.flatMap(x => (x.op === 'not' ? [] : equalities(x)));
+    return [];
+}
+// A lemma use: the goal's read it matched, and the lemma's read there (equal where the use applies).
+const matchedAt = new WeakMap();
+const holdsAt = (fs, q) => { const f = fs.facts[q.fact]; return substC(f.holds, { vars: Object.fromEntries(f.keys.map((key, i) => [key, q.at[i]])), maps: {}, flags: {} }); };
+// The models a search compares terms in: random values of the law's variables.
+function modelsFor(p, l, n, seed) {
+    return samples(l.vars, p.params, n, seed).map(s => {
+        const m = new Model(p, s.params);
+        const env = Object.fromEntries(l.vars.map(v => [v.name, m.code(v.sort, s.env.get(v.name))]));
+        return { m, env };
+    });
+}
+// Prove a law with the lemmas given (each proven, with its nodes), trying each scheme at each depth.
+function proveWith(p, fs, l, lemmas, level, opts, until, per, depths) {
+    const models = modelsFor(p, l, 240, opts.seed ?? 3);
+    let tried = 0, last;
+    const ss = opts.induction === false ? [undefined] : schemes(p, l);
+    for (const depth of depths.filter(d => d <= (opts.depth ?? 3)))
+        for (const s of ss) {
+            if (performance.now() > until)
+                return { tried, last };
+            tried++;
+            const { verdict, specs } = (attemptMs.ms = Math.min(per * (opts.patience ?? 1), until - performance.now()), attempt(p, fs, l, s, depth, lemmas, level, models));
+            last = verdict;
+            if (verdict.proven && verdict.checked)
+                return { out: { law: l, spec: specs.find(n => n.name === specs[specs.length - 1].name.replace(/, case \d+$/, '')), nodes: specs }, verdict, scheme: s?.name, tried };
+        }
+    return { tried, last };
+}
+// Conjectures from the values (theory exploration): equations between terms of the law's functions over a few
+// variables (two of each datatype, two naturals; constructors, the functions, sums of naturals, up to five symbols), met
+// by every random value, smallest first, each named canonically (its variables in order of appearance), none ground,
+// none the law, none that follows by rewriting with smaller ones; and for each predicate the law reads, that a function
+// returning a datatype keeps it (p(x) implies p(f(x, ...)), under a comparison of two naturals where that is needed).
+export function conjectures(p, l, max = 24, maxSize = 6) {
+    const sortsOf = (s) => (s instanceof Data ? s.name : s);
+    const vars = [...p.datas.flatMap(d => [{ name: `${d.name.toLowerCase()}1`, sort: d }, { name: `${d.name.toLowerCase()}2`, sort: d }]), { name: 'n1', sort: 'nat' }, { name: 'n2', sort: 'nat' }];
+    const sortOfVar = new Map(vars.map(v => [v.name, v.sort]));
+    const ss = samples(vars, p.params, 80, 11);
+    const used = new Set();
+    walk(l.holds, o => { if (o.op === 'call')
+        used.add(o.fn); });
+    const callees = (f) => { const out = []; walk(f.body(), o => { if (o.op === 'call')
+        out.push(o.fn); }); return out; };
+    for (let changed = true; changed;) {
+        changed = false;
+        for (const f of p.fns)
+            if (used.has(f.name))
+                for (const g of callees(f))
+                    if (!used.has(g)) {
+                        used.add(g);
+                        changed = true;
+                    }
+    }
+    const fnsUsed = p.fns.filter(f => used.has(f.name));
+    const fp = (x) => { try {
+        return JSON.stringify(ss.map(s => evalX(x, s.env, s.params)));
+    }
+    catch {
+        return undefined;
+    } };
+    const classes = new Map();
+    const addT = (t) => { const f = fp(t.x); if (f === undefined)
+        return; const key = `${sortsOf(t.sort)}:${f}`; const c = classes.get(key) ?? []; c.push(t); classes.set(key, c); };
+    for (const v of vars)
+        addT({ x: { op: 'var', name: v.name }, sort: v.sort, size: 1 });
+    addT({ x: { op: 'nat', value: 0 }, sort: 'nat', size: 1 });
+    for (const d of p.datas)
+        d.ctors.forEach((c, j) => { if (!c.fields.length)
+            addT({ x: { op: 'ctor', data: d.name, ctor: j, args: [] }, sort: d, size: 1 }); });
+    for (let size = 2; size <= maxSize; size++) {
+        const reps = [...classes.values()].map(c => [...c].sort((a, b) => a.size - b.size)[0]);
+        const build = (sorts, budget) => {
+            if (!sorts.length)
+                return budget === 0 ? [[]] : [];
+            const out = [];
+            for (const t of reps)
+                if (sortsOf(t.sort) === sortsOf(sorts[0]) && t.size <= budget - (sorts.length - 1))
+                    for (const rest of build(sorts.slice(1), budget - t.size))
+                        out.push([t, ...rest]);
+            return out;
+        };
+        for (const f of fnsUsed)
+            for (const args of build(f.params.map(q => q.sort), size - 1))
+                addT({ x: { op: 'call', fn: f.name, args: args.map(a => a.x) }, sort: f.ret, size });
+        for (const d of p.datas)
+            d.ctors.forEach((c, j) => { if (c.fields.length)
+                for (const args of build(c.fields.map(f => (f.sort === 'nat' ? 'nat' : d)), size - 1))
+                    addT({ x: { op: 'ctor', data: d.name, ctor: j, args: args.map(a => a.x) }, sort: d, size }); });
+        for (const [a2, b2] of build(['nat', 'nat'], size - 1))
+            if (JSON.stringify(a2.x) <= JSON.stringify(b2.x))
+                addT({ x: { op: 'add', a: a2.x, b: b2.x }, sort: 'nat', size });
+        if (classes.size > 6000)
+            break;
+    }
+    // Canonical names: each sort's variables renamed in order of appearance.
+    const canon = (t) => {
+        const order = [];
+        walk(t, o => { if (o.op === 'var' && sortOfVar.has(o.name) && !order.includes(o.name))
+            order.push(o.name); });
+        const count = new Map(), ren = new Map();
+        for (const v of order) {
+            const s2 = sortOfVar.get(v), key = s2 instanceof Data ? s2.name.toLowerCase() : 'n', i = (count.get(key) ?? 0) + 1;
+            count.set(key, i);
+            ren.set(v, `${key}${i}`);
+        }
+        const go = (x) => (Array.isArray(x) ? x.map(go) : x && typeof x === 'object' ? (x.op === 'var' && ren.has(x.name) ? { op: 'var', name: ren.get(x.name) } : Object.fromEntries(Object.entries(x).map(([key, v]) => [key, go(v)]))) : x);
+        return { t: go(t), vs: new Set(ren.values()) };
+    };
+    const callIn = (x) => JSON.stringify(x).includes('"op":"call"');
+    const size = (x) => { let n = 0; walk(x, o => { if (['var', 'nat', 'call', 'ctor', 'add'].includes(o.op))
+        n++; }); return n; };
+    const eqs = [];
+    for (const c of classes.values()) {
+        const ts = [...c].sort((a, b) => a.size - b.size), rep = ts[0];
+        const repVars = new Set();
+        walk(rep.x, o => { if (o.op === 'var')
+            repVars.add(o.name); });
+        for (const t of ts.slice(1)) {
+            if (!callIn(t.x))
+                continue;
+            const tv = new Set();
+            walk(t.x, o => { if (o.op === 'var')
+                tv.add(o.name); });
+            if (![...repVars].every(v => tv.has(v)))
+                continue;
+            const { t: ct } = canon([t.x, rep.x]), [ca, cb] = ct;
+            eqs.push({ a: ca, b: cb, size: t.size + rep.size });
+        }
+    }
+    // Smallest first, and of one size the most general first (an instance of a kept one is then dropped).
+    const nvars = (e) => { const vs = new Set(); walk(e, o => { if (o.op === 'var')
+        vs.add(o.name); }); return vs.size; };
+    eqs.sort((a, b) => a.size - b.size || nvars(b) - nvars(a));
+    const rules = [];
+    const matchX = (pat, t, vs, sub) => {
+        if (pat.op === 'var' && vs.has(pat.name)) {
+            const had = sub.get(pat.name);
+            if (had)
+                return JSON.stringify(had) === JSON.stringify(t);
+            sub.set(pat.name, t);
+            return true;
+        }
+        if (pat.op !== t.op)
+            return false;
+        const po = pat, to = t;
+        for (const key of Object.keys(po)) {
+            const a2 = po[key], b2 = to[key];
+            if (Array.isArray(a2)) {
+                if (!Array.isArray(b2) || a2.length !== b2.length || !a2.every((x, i) => matchX(x, b2[i], vs, sub)))
+                    return false;
+            }
+            else if (a2 && typeof a2 === 'object') {
+                if (!b2 || typeof b2 !== 'object' || !matchX(a2, b2, vs, sub))
+                    return false;
+            }
+            else if (a2 !== b2)
+                return false;
+        }
+        return true;
+    };
+    const substX = (x, sub) => JSON.parse(JSON.stringify(x), (_, v) => (v && typeof v === 'object' && v.op === 'var' && sub.has(v.name) ? sub.get(v.name) : v));
+    const norm = (x, depth = 0) => {
+        if (depth > 30)
+            return x;
+        let t = JSON.parse(JSON.stringify(x));
+        if (t.op === 'call' || t.op === 'ctor')
+            t = { ...t, args: t.args.map(a2 => norm(a2, depth + 1)) };
+        if (t.op === 'add') {
+            const [a2, b2] = [norm(t.a, depth + 1), norm(t.b, depth + 1)];
+            if (a2.op === 'nat' && a2.value === 0)
+                return b2;
+            if (b2.op === 'nat' && b2.value === 0)
+                return a2;
+            t = JSON.stringify(a2) <= JSON.stringify(b2) ? { op: 'add', a: a2, b: b2 } : { op: 'add', a: b2, b: a2 };
+        }
+        for (const r of rules) {
+            const sub = new Map();
+            if (matchX(r.l, t, r.vs, sub))
+                return norm(substX(r.r, sub), depth + 1);
+        }
+        return t;
+    };
+    // The law in the same names (its variables by sort, in order of appearance).
+    const lawText = (() => {
+        const count = new Map(), ren = new Map();
+        walk(l.holds, o => { if (o.op === 'var' && !ren.has(o.name)) {
+            const v = l.vars.find(w => w.name === o.name);
+            if (!v)
+                return;
+            const key = v.sort instanceof Data ? v.sort.name.toLowerCase() : 'n', i = (count.get(key) ?? 0) + 1;
+            count.set(key, i);
+            ren.set(v.name, `${key}${i}`);
+        } });
+        return JSON.stringify(l.holds, (_, v) => (v && typeof v === 'object' && v.op === 'var' && ren.has(v.name) ? { op: 'var', name: ren.get(v.name) } : v));
+    })();
+    const out = [], seen = new Set();
+    const lawOf = (y, vs, name) => ({ name, vars: [...vs].map(v => ({ name: v, sort: sortOfVar.get(v) })), holds: y, params: [...new Set(paramsIn(y))] });
+    const kept = [];
+    // The definitions, unfolded at a constructor: f(.., C(x, y), ..) → its case's body, where that is a plain term.
+    for (const f of fnsUsed) {
+        const body = f.body(), di = f.decreases;
+        if (body.op !== 'match' || di === undefined || body.of.op !== 'var' || body.of.name !== `${f.name}.${f.params[di].name}`)
+            continue;
+        const d = f.params[di].sort;
+        body.cases.forEach((c, j) => {
+            if (JSON.stringify(c.body).match(/"op":"(match|if|bool|apply)"/))
+                return;
+            const names = new Map(f.params.map((q, i) => [`${f.name}.${q.name}`, { op: 'var', name: `$p${i}` }]));
+            c.binds.forEach((b, i) => names.set(b, { op: 'var', name: `$f${i}` }));
+            const ren = (x) => JSON.parse(JSON.stringify(x), (_, v) => (v && typeof v === 'object' && v.op === 'var' && names.has(v.name) ? names.get(v.name) : v));
+            const lhs = { op: 'call', fn: f.name, args: f.params.map((_, i) => (i === di ? { op: 'ctor', data: d.name, ctor: j, args: c.binds.map((_, q) => ({ op: 'var', name: `$f${q}` })) } : { op: 'var', name: `$p${i}` })) };
+            const vs = new Set();
+            walk(lhs, o => { if (o.op === 'var')
+                vs.add(o.name); });
+            rules.push({ l: lhs, r: ren(c.body), vs });
+        });
+    }
+    const lawY = JSON.parse(lawText);
+    if (lawY.op === '=') {
+        const vs = new Set();
+        walk(lawY, o => { if (o.op === 'var')
+            vs.add(o.name); });
+        const [big, small] = size(lawY.a) >= size(lawY.b) ? [lawY.a, lawY.b] : [lawY.b, lawY.a];
+        if (size(big) > size(small))
+            rules.push({ l: big, r: small, vs });
+    }
+    for (const e of eqs) {
+        const na = norm(e.a), nb = norm(e.b);
+        if (JSON.stringify(na) === JSON.stringify(nb))
+            continue;
+        // An instance of one kept (both sides at one substitution) adds nothing.
+        if (kept.some(q => [[q.a, q.b], [q.b, q.a]].some(([x1, x2]) => { const sub = new Map(); return matchX(x1, e.a, q.vs, sub) && matchX(x2, e.b, q.vs, sub); })))
+            continue;
+        const y = { op: '=', a: e.a, b: e.b }, text = JSON.stringify(y);
+        if (seen.has(text) || text === lawText || JSON.stringify({ op: '=', a: e.b, b: e.a }) === lawText)
+            continue;
+        seen.add(text);
+        const vs = new Set();
+        walk(y, o => { if (o.op === 'var')
+            vs.add(o.name); });
+        // A ground equation only rewrites (a definition unfolded proves it where it is needed).
+        if (vs.size && out.length < max)
+            out.push(lawOf(y, vs, `${showX(e.a)} = ${showX(e.b)}`));
+        kept.push({ a: e.a, b: e.b, vs });
+        const [big, small] = size(e.a) >= size(e.b) ? [e.a, e.b] : [e.b, e.a];
+        if (size(big) > size(small))
+            rules.push({ l: big, r: small, vs });
+    }
+    // Predicates kept by a function returning a datatype.
+    const preds = p.fns.filter(f => f.ret === 'bool' && used.has(f.name)), makers = p.fns.filter(f => f.ret instanceof Data && used.has(f.name));
+    const nats = vars.filter(v => v.sort === 'nat').map(v => v.name);
+    for (const pr of preds)
+        for (const mk of makers) {
+            const di = pr.params.findIndex(q => q.sort === mk.ret);
+            if (di < 0)
+                continue;
+            const dvar = vars.find(v => v.sort === mk.ret).name;
+            const argSets = (qs) => qs.reduce((acc, q) => acc.flatMap(a2 => (q.sort === 'nat' ? nats.map(n => [...a2, { op: 'var', name: n }]) : q.sort === 'bool' ? [] : [[...a2, { op: 'var', name: vars.find(v => v.sort === q.sort).name }]])), [[]]);
+            for (const margs of argSets(mk.params))
+                for (const pargs of argSets(pr.params.filter((_, i) => i !== di))) {
+                    const pAt = (x) => { const as = [...pargs]; as.splice(di, 0, x); return { op: 'holds', x: { op: 'call', fn: pr.name, args: as } }; };
+                    const premise = pAt({ op: 'var', name: dvar }), conclusion = pAt({ op: 'call', fn: mk.name, args: margs });
+                    const conds = [undefined, ...nats.flatMap(a2 => nats.filter(b2 => b2 !== a2).flatMap(b2 => [{ op: '<', a: { op: 'var', name: a2 }, b: { op: 'var', name: b2 } }, { op: '<=', a: { op: 'var', name: a2 }, b: { op: 'var', name: b2 } }]))];
+                    for (const c of conds) {
+                        const hyp = c ? { op: 'and', xs: [premise, c] } : premise;
+                        const { t: cy, vs } = canon({ op: 'or', xs: [{ op: 'not', x: hyp }, conclusion] });
+                        const y = cy, text = JSON.stringify(y);
+                        if (seen.has(text) || text === lawText)
+                            break;
+                        let held = 0, ok = true;
+                        for (const sm of ss) {
+                            try {
+                                if (evalY(hyp, sm.env, sm.params)) {
+                                    held++;
+                                    if (!evalY(conclusion, sm.env, sm.params)) {
+                                        ok = false;
+                                        break;
+                                    }
+                                }
+                            }
+                            catch {
+                                ok = false;
+                                break;
+                            }
+                        }
+                        if (ok && held >= 5) {
+                            seen.add(text);
+                            out.push(lawOf(y, vs, `${showY(y.xs[0].op === 'not' ? y.xs[0].x : y)} implies ${showY(y.xs[1])}`));
+                            break;
+                        }
+                    }
+                }
+        }
+    return out;
+}
+export const showX = (x) => {
+    switch (x.op) {
+        case 'var': return x.name.replace(/#\d+$/, '');
+        case 'nat': return String(x.value);
+        case 'add': return `${showX(x.a)} + ${showX(x.b)}`;
+        case 'sub': return `${showX(x.a)} − ${showX(x.b)}`;
+        case 'min':
+        case 'max': return `${x.op}(${showX(x.a)}, ${showX(x.b)})`;
+        case 'mul': return `${x.k}·${showX(x.a)}`;
+        case 'if': return `if ${showY(x.c)} then ${showX(x.then)} else ${showX(x.else)}`;
+        case 'bool': return showY(x.c);
+        case 'apply': return `${x.param}(${showX(x.arg)})`;
+        case 'call': return `${x.fn}(${x.args.map(showX).join(', ')})`;
+        case 'ctor': {
+            const d = [...fns.values()].length >= 0 ? x.data : x.data;
+            return `${d}.${x.ctor}${x.args.length ? `(${x.args.map(showX).join(', ')})` : ''}`;
+        }
+        case 'match': return `match ${showX(x.of)}`;
+    }
+};
+export const showY = (y) => {
+    switch (y.op) {
+        case '<':
+        case '<=':
+        case '=': return `${showX(y.a)} ${y.op} ${showX(y.b)}`;
+        case 'and': return y.xs.map(showY).join(' and ');
+        case 'or': return y.xs.map(showY).join(' or ');
+        case 'not': return `not (${showY(y.x)})`;
+        case 'is': return `${showX(y.of)} is ${y.ctor}`;
+        case 'holds': return showX(y.x);
+    }
+};
+// Prove a law over datatypes: refuted by a random value where one breaks it; else proven by a cycle the search finds,
+// with lemmas found from the values when the law alone isn't (`lemmas: false` turns that off; an array gives lemmas to
+// prove and use instead, which the corpus never does).
+export function proveData(l, opts = {}) {
+    const t0 = performance.now(), until = t0 + (opts.ms ?? 120_000);
+    const p = programOf([l, ...(Array.isArray(opts.lemmas) ? opts.lemmas : [])]), fs = factsOf(p);
+    const done = (v) => ({ law: l.name, ...v, ms: Math.round(performance.now() - t0) });
+    const cex = refute(l, opts.samples ?? 400);
+    if (cex)
+        return done({ proven: false, checked: false, counterexample: cex, lemmas: [], tried: 0 });
+    // The law alone at one unfolding; then lemmas at one unfolding each (the law tried again after each its goal
+    // matches); then the law at two; then lemmas at two; last the law at three. A lemma is named in the verdict when the
+    // proof uses it.
+    let tried = 0;
+    const used = (r, lemmas) => {
+        const nodes = r.nodes, seen = new Set(), todo = [nodes.indexOf(r.spec)];
+        while (todo.length) {
+            const i = todo.pop();
+            if (seen.has(i))
+                continue;
+            seen.add(i);
+            for (const u of nodes[i].uses)
+                todo.push(u.node);
+        }
+        return lemmas.filter(q => seen.has(nodes.indexOf(nodes.find(n => n.name === q.spec.name)))).map(q => q.law.name);
+    };
+    const ok = (r, lemmas, prog = p) => (tried += r.tried, r.out ? done({ proven: true, checked: true, proof: r.verdict, lemmas: used(r.out, lemmas), scheme: r.scheme, tried, program: prog, node: r.out.nodes.indexOf(r.out.spec) }) : undefined);
+    const first = proveWith(p, fs, l, [], 1, opts, until, 6000, [1]);
+    const one = ok(first, []);
+    if (one)
+        return one;
+    const without = opts.lemmas === false || opts.induction === false;
+    if (without)
+        return ok(proveWith(p, fs, l, [], 1, opts, until, 20000, [2, 3]), []) ?? done({ proven: false, checked: false, lemmas: [], tried, ...stuckOf(first.last) });
+    const cands = Array.isArray(opts.lemmas) ? opts.lemmas : conjectures(p, l);
+    const p2 = programOf([l, ...cands]), fs2 = factsOf(p2);
+    const goalOf = (s) => {
+        const concl = encY(p2, l.holds, new Map()), ihc = (s?.uses ?? []).map(u => substC(concl, { vars: u.subst, maps: {}, flags: {} }));
+        return { from: [concl, ihc], insts: instancesOf(p2, fs2, { roots: [concl], others: ihc, depth: 2, shapesAt: s?.on ? [ev(s.on.v)] : [], etaAt: [], models: [] }) };
+    };
+    const goals = schemes(p2, l).map(goalOf);
+    const matchesGoal = (c) => goals.some(g => lemmaUsesFor(p2, fs2, [{ law: c, node: 0, concl: encY(p2, c.holds, new Map()) }], g.from, g.insts).length > 0);
+    // Those the goal matches first, of those the ones of the law's shape (an implication for an implication) first.
+    const implication = (y) => y.op === 'or' && y.xs.length === 2 && y.xs[0].op === 'not';
+    const score = (c, hit) => (hit ? 2 : 0) + (implication(c.holds) === implication(l.holds) ? 1 : 0);
+    const ranked = cands.map(c => ({ c, hit: matchesGoal(c) })).sort((a, b) => score(b.c, b.hit) - score(a.c, a.hit));
+    const proven = [], failed = new Set();
+    const lemmasAt = (depth) => {
+        for (const { c, hit } of ranked) {
+            if (performance.now() > until)
+                return undefined;
+            if (proven.some(q => q.law === c) || (depth === 2 && !failed.has(c)) || refute(c, 200))
+                continue;
+            const r = proveWith(p2, fs2, c, proven, 1 + proven.length, opts, Math.min(until, performance.now() + (depth === 1 ? 8000 : 12000) * (opts.patience ?? 1)), 5000, [depth]);
+            tried += r.tried;
+            if (!r.out) {
+                failed.add(c);
+                continue;
+            }
+            failed.delete(c);
+            proven.push(r.out);
+            if (!hit && implication(c.holds) !== implication(l.holds))
+                continue;
+            const again = ok(proveWith(p2, fs2, l, proven, 1 + proven.length, opts, until, 6000, depth === 1 ? [1] : [1, 2]), proven, p2);
+            if (again)
+                return again;
+        }
+        return undefined;
+    };
+    const steps = [
+        () => lemmasAt(1),
+        () => ok(proveWith(p, fs, l, [], 1, opts, until, 30000, [2]), []),
+        () => (proven.length ? ok(proveWith(p2, fs2, l, proven, 1 + proven.length, opts, until, 30000, [2]), proven, p2) : undefined),
+        () => lemmasAt(2),
+        () => ok(proveWith(p2, fs2, l, proven, 1 + proven.length, opts, until, 12000, [3]), proven, p2),
+    ];
+    for (const step of steps) {
+        if (performance.now() > until)
+            break;
+        const out = step();
+        if (out)
+            return out;
+    }
+    return done({ proven: false, checked: false, lemmas: [], tried, ...stuckOf(first.last) });
+}
+const stuckOf = (v) => (v && !v.proven ? { goal: v.goal, stuck: v.stuck } : v && !v.checked ? { goal: 'check', stuck: v.why } : {});
+// The law with no cycle: its definitions unfolded, the kernel's prover alone (what the library proves without the search).
+export const proveDataToday = (l) => proveData(l, { induction: false });