gdp-wired 0.14.1 → 0.15.0

package/dist/core/infer.js

@@ -0,0 +1,573 @@
+// Invariants nobody wrote: a law that holds but isn't inductive, proven with laws the search finds. Nothing here is
+// trusted; what it finds is proven by the kernel with the rule's own laws, as laws of the same rule.
+//   - runs: random runs from the start (params and requests by their kinds, the assumption met) give reachable states
+//   - candidates: linear forms Σ c·v ≤ d over the state and the params (an integer as its value, its two naturals
+//     together), up to three terms with small coefficients and the rule's own constants, each d the largest value the
+//     runs reached (and the rule's constants just above it); the same forms where a yes/no, a choice or a small natural
+//     holds one value (locked is 0 → …), and a choice's value no run reached as unreachable; and laws about every key
+//     of the maps: forms over the cells at one key (and a scalar), at every key or every key but a scalar's (k = owner
+//     or …), and where a cell holds one value
+//   - Houdini on the runs' neighbors: a reached state moved a little that every candidate alive and every law allows,
+//     stepped; a candidate its step breaks is in no inductive set of them, so it is dropped
+//   - the kernel: the laws with the candidates chosen so far, proven one law at a time; when a goal is stuck at a step,
+//     its witness is a counterexample to induction, so the candidate that rules it out (and the most of those seen) is
+//     added; a chosen candidate that nothing supports, or that makes a proof slow, is dropped; the set proven as a whole
+//     is the answer, after each chosen candidate the proof doesn't need is taken out again
+import { any, atMost, evalC, get, interpret, n, not, plus, same, times, x } from "./machine.js";
+import { proveRule, proveSteps } from "./dsl.js";
+import { allowed, watch } from "./watch.js";
+import { proveLaw, proveLaws, proveStepLaws } from "../kernel/prove.js";
+const KEY = 'key$found', AT = '@', K = '#';
+const seeded = (seed) => { let s = seed; return k => { s = (s * 1103515245 + 12345) % 2 ** 31; return Math.floor(s / 2 ** 31 * k); }; };
+const isRule = (t) => typeof t.kindsOfState === 'function';
+const gcd = (a, b) => (b === 0 ? Math.abs(a) : gcd(b, a % b));
+// The constants a machine's expressions hold, and the factors it multiplies by.
+function constantsOf(m, laws) {
+    const out = new Set();
+    const e = (t) => {
+        switch (t.op) {
+            case 'const':
+                out.add(t.value);
+                break;
+            case 'var': break;
+            case 'mul':
+                out.add(t.k);
+                e(t.a);
+                break;
+            case 'add':
+            case 'sub':
+            case 'min':
+            case 'max':
+            case 'prod':
+                e(t.a);
+                e(t.b);
+                break;
+            case 'if':
+                c(t.c);
+                e(t.then);
+                e(t.else);
+                break;
+            case 'get':
+                e(t.key);
+                break;
+        }
+    };
+    const c = (t) => {
+        switch (t.op) {
+            case '<':
+            case '<=':
+            case '=':
+                e(t.a);
+                e(t.b);
+                break;
+            case 'and':
+            case 'or':
+                t.xs.forEach(c);
+                break;
+            case 'not':
+                c(t.x);
+                break;
+            case 'flag': break;
+            case 'all':
+                c(t.c);
+                break;
+        }
+    };
+    Object.values(m.state).forEach(e);
+    Object.values(m.step.state ?? {}).forEach(e);
+    Object.values(m.step.flags ?? {}).forEach(c);
+    for (const w of Object.values(m.step.maps ?? {})) {
+        if ('key' in w)
+            e(w.key);
+        e(w.value);
+    }
+    if (m.assume)
+        c(m.assume);
+    if (m.pre)
+        c(m.pre);
+    laws.forEach(l => c(l.holds));
+    return [...out].filter(k => Number.isSafeInteger(k) && Math.abs(k) <= 1e6);
+}
+// A cell's key as the kernel names it (kernel.ts keyOf): `name:coef` parts joined by ',', '1' the constant.
+const keyValue = (cell, w) => {
+    const inner = cell.slice(cell.indexOf('[') + 1, -1);
+    if (inner.includes('['))
+        return undefined;
+    let value = 0;
+    for (const part of inner.split(',').filter(Boolean)) {
+        const at = part.lastIndexOf(':'), name = part.slice(0, at), coef = Number(part.slice(at + 1));
+        if (name === '1')
+            value += coef;
+        else if (name in w)
+            value += coef * w[name];
+        else
+            return undefined;
+    }
+    return value;
+};
+export function inferLaws(target, laws, stepLaws = [], opts = {}) {
+    const t0 = performance.now(), until = t0 + (opts.ms ?? 20000), rule = isRule(target) ? target : undefined;
+    const m = rule ? rule.machine : target;
+    let proofs = 0;
+    const prove = (ls) => {
+        proofs++;
+        if (rule)
+            return stepLaws.length ? proveSteps(rule, ls, stepLaws) : proveRule(rule, ls);
+        const out = stepLaws.length ? proveStepLaws(m, ls, stepLaws) : proveLaws(m, ls);
+        return { proven: out.proven, checked: out.checked, ...(out.failed ? { goal: out.failed.goal, stuck: out.failed.stuck, ...(out.failed.witness ? { witness: out.failed.witness } : {}), ...(out.failed.why ? { why: out.failed.why } : {}) } : {}) };
+    };
+    const stats = (samples, candidates, alive) => ({ samples, candidates, alive, proofs, ms: Math.round(performance.now() - t0) });
+    const first = opts.first ?? prove(laws);
+    if ((first.proven && first.checked) || first.run)
+        return { ...first, found: [], stats: stats(0, 0, 0) };
+    // --- runs ------------------------------------------------------------------------------------------------------------
+    const run = interpret(m), rand = seeded(17), kinds = rule ? rule.kindsOfState() : [];
+    const given = rule ? [...rule.kindLaws().filter(k => !laws.some(l => l.name === k.name)), ...laws] : laws;
+    const randomParams = (bound) => (rule ? rule.randomParams(rand, bound) : Object.fromEntries(m.params.map(p => [p, rand(bound + 1)])));
+    const randomInput = (params, bound) => (rule ? rule.randomInput(rand, bound, params)
+        : { ...Object.fromEntries(m.inputs.map(i => [i, rand(bound + 1)])), ...Object.fromEntries((m.inputMaps ?? []).map(i => [i, new Map()])) });
+    const samples = [], cap = 3000;
+    const keep = (s) => { if (samples.length < cap)
+        samples.push(s);
+    else if (rand(4) === 0)
+        samples[rand(cap)] = s; };
+    for (const st of opts.seen ?? [])
+        if (!m.params.length)
+            keep({ params: {}, st });
+    const mapsText = (st) => JSON.stringify(Object.values(st.maps).map(c => [...c]));
+    const runsUntil = Math.min(until, performance.now() + (opts.runsMs ?? 500));
+    for (let trial = 0, bound = 2; performance.now() < runsUntil; trial++, bound = trial % 20 === 0 ? (bound >= 1024 ? 2 : bound * 2) : bound) {
+        const params = randomParams(bound);
+        if (m.pre && !evalC(m.pre, params, { scalars: {}, maps: {} }, m))
+            continue;
+        let st;
+        try {
+            st = run.init(params);
+        }
+        catch {
+            continue;
+        }
+        keep({ params, st });
+        for (let d = 0, tries = 0; d < 40 && tries < 200; tries++) {
+            const input = randomInput(params, bound);
+            let next;
+            try {
+                if (!allowed(m, run, params, st, input))
+                    continue;
+                next = run.step(params, st, input);
+            }
+            catch {
+                break;
+            }
+            d++;
+            if (JSON.stringify(next.scalars) !== JSON.stringify(st.scalars) || mapsText(next) !== mapsText(st))
+                keep({ params, st: next });
+            st = next;
+        }
+    }
+    opts.progress?.('runs', { samples: samples.length });
+    // --- atoms and rows --------------------------------------------------------------------------------------------------
+    const scalars = Object.keys(m.state), stateSet = new Set(scalars), mapNames = Object.keys(m.maps ?? {}), mapSet = new Set(mapNames);
+    const atoms = [];
+    const add = (name, has, param, cell) => {
+        if (name.endsWith('$neg') && has(name.slice(0, -4)))
+            return;
+        const neg = `${name}$neg`, int = has(neg);
+        atoms.push({ name: cell ? `${name}[k]` : name, parts: int ? [[name, 1], [neg, -1]] : [[name, 1]], param, int, cell });
+    };
+    for (const name of scalars)
+        add(name, p => stateSet.has(p), false, false);
+    for (const name of m.params)
+        add(name, p => m.params.includes(p), true, false);
+    for (const name of mapNames)
+        add(name, p => mapSet.has(p), false, true);
+    const A = atoms.length, cellAtoms = atoms.flatMap((a, i) => (a.cell ? [i] : []));
+    const valueOf = (a, env) => { let s = 0; for (const [p, sign] of a.parts)
+        s += sign * (env[a.cell ? AT + p : p] ?? 0); return s; };
+    const cellOf = (st, map, key) => st.maps[map]?.get(key) ?? st.defaults?.[map] ?? m.maps[map];
+    // The scalar rows (one per state reached), and the cell rows (one per state and key a map holds, and one fresh key).
+    const keysIn = (st) => { const ks = new Set(); for (const c of Object.values(st.maps))
+        for (const k of c.keys())
+            ks.add(k); return [...ks]; };
+    const cellRows = (params, st) => {
+        if (!mapNames.length)
+            return [];
+        const ks = keysIn(st), fresh = ks.length ? Math.max(...ks) + 1 : 0;
+        return [...ks, fresh].map(k => ({ ...params, ...st.scalars, [K]: k, ...Object.fromEntries(mapNames.map(mp => [AT + mp, cellOf(st, mp, k)])) }));
+    };
+    const rowsS = samples.map(s => ({ ...s.params, ...s.st.scalars }));
+    const rowsK = [];
+    for (const s of samples) {
+        if (rowsK.length > 6000)
+            break;
+        rowsK.push(...cellRows(s.params, s.st));
+    }
+    const valsS = atoms.map(a => Float64Array.from(rowsS, r => valueOf(a, r))), valsK = atoms.map(a => Float64Array.from(rowsK, r => valueOf(a, r)));
+    const kindOf = new Map(kinds.map(([name, k]) => [name, k]));
+    const modes = [];
+    atoms.forEach((a, i) => {
+        if (a.param || a.int)
+            return;
+        const k = a.cell ? undefined : kindOf.get(a.name), seenValues = [...new Set(a.cell ? valsK[i] : valsS[i])].sort((p, q) => p - q);
+        const decoded = k?.vars(a.name).length === 1 ? k.decode(a.name, { [a.name]: 0 }) : undefined;
+        const values = k?.values;
+        if (typeof decoded === 'boolean')
+            modes.push({ atom: i, values: [0, 1], bool: true });
+        else if (typeof decoded === 'string' && values)
+            modes.push({ atom: i, values: values.map((_, j) => j), choice: values });
+        else if (!k && seenValues.length && seenValues.length <= 4 && seenValues.every(v => v <= 8))
+            modes.push({ atom: i, values: seenValues });
+    });
+    const modeOf = (i) => modes.find(mo => mo.atom === i);
+    // --- candidates ----------------------------------------------------------------------------------------------------
+    const consts = [...new Set([...constantsOf(m, laws), ...(opts.constants ?? [])].map(Math.abs))].filter(k => k > 0).sort((p, q) => p - q);
+    const mags = [...new Set([1, 2, 3, ...consts.filter(k => k > 3 && k <= 1000).slice(0, 4)])];
+    const bounds = [...new Set([...consts, ...consts.flatMap(a => consts.map(b => a * b)), ...consts.flatMap(a => consts.map(b => a + b))].flatMap(k => [k, -k])), 0].sort((p, q) => p - q);
+    const maxCandidates = opts.maxCandidates ?? 60000;
+    // The shapes: every coefficient vector over up to three atoms, coprime; a scalar form reads a state variable, a
+    // cell form a cell (and at most one scalar).
+    const shapes = [];
+    const pick = (terms, ms, pool, ok, cells) => {
+        const cs = ms.flatMap(k => [k, -k]);
+        const go = (from, acc) => {
+            if (shapes.length > maxCandidates)
+                return;
+            if (acc.length === terms) {
+                if (ok(acc) && acc.reduce((g, [, c]) => gcd(g, c), 0) === 1)
+                    shapes.push({ coef: [...acc], cells });
+                return;
+            }
+            for (let i = from; i < pool.length; i++)
+                for (const c of cs)
+                    go(i + 1, [...acc, [pool[i], c]]);
+        };
+        go(0, []);
+    };
+    const choose = (k, of) => { let r = 1; for (let i = 0; i < k; i++)
+        r = r * (of - i) / (i + 1); return r; };
+    const plain = atoms.flatMap((a, i) => (a.cell ? [] : [i])), P = plain.length;
+    const scalarOk = (acc) => acc.some(([i]) => !atoms[i].param);
+    pick(1, [1], plain, scalarOk, false);
+    pick(2, choose(2, P) * 4 * mags.length ** 2 <= maxCandidates / 4 ? mags : [1], plain, scalarOk, false);
+    if (choose(3, P) * 8 * mags.length ** 3 <= maxCandidates / 2)
+        pick(3, mags, plain, scalarOk, false);
+    else if (choose(3, P) * 8 <= maxCandidates / 2)
+        pick(3, [1], plain, scalarOk, false);
+    if (cellAtoms.length) {
+        const all = atoms.map((_, i) => i), cellOk = (acc) => acc.some(([i]) => atoms[i].cell) && acc.filter(([i]) => !atoms[i].cell).length <= 1;
+        pick(1, [1], cellAtoms, () => true, true);
+        pick(2, [1], all, cellOk, true);
+        if (choose(3, A) * 8 <= maxCandidates / 4)
+            pick(3, [1], all, acc => cellOk(acc) && acc.filter(([i]) => atoms[i].cell).length >= 2, true);
+    }
+    const sizeOf = (coef) => coef.length * 100 + coef.reduce((s, [, c]) => s + Math.abs(c), 0);
+    const forms = [];
+    const NS = rowsS.length, NK = rowsK.length;
+    const at = (coef, vals, j) => { let s = 0; for (const [i, c] of coef)
+        s += c * vals[i][j]; return s; };
+    const keyNots = plain.filter(i => !atoms[i].param && !atoms[i].int);
+    // The guards: the choices first, then yes/nos, then small naturals, at most eight; each shape's largest value per
+    // guard in one pass over (at most 1,500 of) the rows. Building candidates takes at most a quarter of the time.
+    const guards = [...modes].sort((p, q) => Number(!!q.choice) - Number(!!p.choice) || Number(!!q.bool) - Number(!!p.bool)).slice(0, 8);
+    const strideS = Math.max(1, Math.ceil(NS / 1500)), strideK = Math.max(1, Math.ceil(NK / 1500));
+    const buildUntil = Math.min(until, performance.now() + (until - performance.now()) / 4);
+    for (const [n_, { coef, cells }] of shapes.entries()) {
+        if (forms.length > maxCandidates || (n_ % 256 === 0 && performance.now() > buildUntil))
+            break;
+        const vals = cells ? valsK : valsS, N = cells ? NK : NS, rows = cells ? rowsK : rowsS;
+        let d = -Infinity;
+        for (let j = 0; j < N; j++)
+            d = Math.max(d, at(coef, vals, j));
+        if (!Number.isFinite(d))
+            continue;
+        forms.push({ coef, d, cells, size: sizeOf(coef) + (cells ? 10 : 0) });
+        // The rule's constants just above the largest value reached, a bound a run may not have hit.
+        for (const b of bounds.filter(b => b > d).slice(0, 2))
+            forms.push({ coef, d: b, cells, size: sizeOf(coef) + 1 + (cells ? 10 : 0) });
+        if (coef.length > 2)
+            continue;
+        const here = guards.filter(mode => !coef.some(([i]) => i === mode.atom) && (cells || !atoms[mode.atom].cell));
+        const most = here.map(() => new Map()), away = cells ? keyNots.map(() => -Infinity) : [];
+        for (let j = 0; j < N; j += cells ? strideK : strideS) {
+            const value = at(coef, vals, j);
+            here.forEach((mode, g) => { const v = vals[mode.atom][j], b = most[g]; b.set(v, Math.max(b.get(v) ?? -Infinity, value)); });
+            // At every key but a scalar's: the largest value away from that key.
+            if (cells)
+                keyNots.forEach((s, g) => { if (rows[j][K] !== valsK[s][j])
+                    away[g] = Math.max(away[g], value); });
+        }
+        here.forEach((mode, g) => { for (const [value, dv] of most[g])
+            if (mode.values.includes(value) && dv < d)
+                forms.push({ coef, d: dv, cells, guard: { atom: mode.atom, value }, size: sizeOf(coef) + 50 }); });
+        keyNots.forEach((s, g) => { if (cells && Number.isFinite(away[g]) && away[g] < d)
+            forms.push({ coef, d: away[g], cells, guard: { keyNot: s }, size: sizeOf(coef) + 60 }); });
+    }
+    for (const mode of modes)
+        if (!atoms[mode.atom].cell)
+            for (const value of mode.values)
+                if (NS && !valsS[mode.atom].includes(value))
+                    forms.push({ coef: [], d: 0, cells: false, unreachable: { atom: mode.atom, value }, size: 1 });
+    opts.progress?.('candidates', { atoms: A, shapes: shapes.length, forms: forms.length });
+    // --- how a form reads, and as a law ------------------------------------------------------------------------------------
+    const nameOf = (i) => atoms[i].name;
+    const shownValue = (i, value) => { const mo = modeOf(i); return mo?.choice ? (mo.choice[value] ?? String(value)) : mo?.bool ? (value === 1 ? 'yes' : 'no') : String(value); };
+    const sides = (f) => {
+        const term = ([i, c]) => `${Math.abs(c) === 1 ? '' : `${Math.abs(c)}·`}${nameOf(i)}`;
+        const left = f.coef.filter(([, c]) => c > 0), right = f.coef.filter(([, c]) => c < 0);
+        return { left, right, l: [...left.map(term), ...(f.d < 0 ? [String(-f.d)] : [])].join(' + ') || '0', r: [...right.map(term), ...(f.d > 0 ? [String(f.d)] : [])].join(' + ') || '0' };
+    };
+    // A bound on a choice alone reads as the values it allows.
+    const allowedValues = (f) => {
+        const only = f.coef.length === 1 ? modeOf(f.coef[0][0]) : undefined;
+        if (!only?.choice)
+            return undefined;
+        const c = f.coef[0][1];
+        return only.values.filter(v => c * v <= f.d);
+    };
+    const textOf = (f) => {
+        if (f.unreachable)
+            return `${nameOf(f.unreachable.atom)} is never ${shownValue(f.unreachable.atom, f.unreachable.value)}`;
+        const { l, r } = sides(f), within = allowedValues(f);
+        const body = within ? `${nameOf(f.coef[0][0])} is ${within.map(v => shownValue(f.coef[0][0], v)).join(' or ')}` : `${l} <= ${r}`;
+        const guarded = !f.guard ? body : 'keyNot' in f.guard ? `k = ${nameOf(f.guard.keyNot)} or ${body}` : `${nameOf(f.guard.atom)} is ${shownValue(f.guard.atom, f.guard.value)} → ${body}`;
+        return f.cells ? `every k: ${guarded}` : guarded;
+    };
+    const sum = (es) => es.reduce((p, q) => plus(p, q), n(0));
+    const part = (a, p) => (a.cell ? get(p, x(KEY)) : x(p));
+    const partsOf = (f, sign) => f.coef.flatMap(([i, c]) => atoms[i].parts.filter(([, s]) => s * c * sign > 0).map(([p]) => { const e = part(atoms[i], p); return Math.abs(c) === 1 ? e : times(Math.abs(c), e); }));
+    // Σ c·v ≤ d over naturals: the positive parts on the left, the negative ones and d on the right (an integer's
+    // negative part goes to the other side of its sign).
+    const condOf = (f) => {
+        // Not at a value, one-sided where it can be (less splitting for the kernel): a natural not 0 is at least 1, and a
+        // yes/no or a choice not at its last value is below it (its kind's law bounds it).
+        const notAt = (i, value) => {
+            const e = part(atoms[i], atoms[i].parts[0][0]), mo = modeOf(i), lastValue = mo?.bool ? 1 : mo?.choice ? mo.choice.length - 1 : undefined;
+            return value === 0 ? atMost(n(1), e) : value === lastValue ? atMost(e, n(value - 1)) : not(same(e, n(value)));
+        };
+        if (f.unreachable)
+            return notAt(f.unreachable.atom, f.unreachable.value);
+        const lhs = sum([...partsOf(f, 1), ...(f.d < 0 ? [n(-f.d)] : [])]), rhs = sum([...partsOf(f, -1), ...(f.d > 0 ? [n(f.d)] : [])]);
+        const body = atMost(lhs, rhs);
+        return !f.guard ? body : 'keyNot' in f.guard ? any(same(x(KEY), x(atoms[f.guard.keyNot].parts[0][0])), body) : any(notAt(f.guard.atom, f.guard.value), body);
+    };
+    // The builder call, for a rule whose atoms are its own variables (naturals, or integers alone).
+    const sourceOf = (f, text) => {
+        if (!rule)
+            return undefined;
+        const used = [...new Set([...f.coef.map(([i]) => i), ...(f.guard ? ['keyNot' in f.guard ? f.guard.keyNot : f.guard.atom] : []), ...(f.unreachable ? [f.unreachable.atom] : [])])];
+        const ints = f.coef.filter(([i]) => atoms[i].int).length;
+        if (ints && ints !== f.coef.length)
+            return undefined;
+        const ref = (i) => (atoms[i].cell ? `${atoms[i].parts[0][0]}.at(k)` : nameOf(i));
+        const val = (i) => { const mo = modeOf(i); return mo?.choice && !atoms[i].cell ? `${ref(i)}.index` : mo?.bool && !atoms[i].cell ? `${ref(i)}.n` : ref(i); };
+        const cond = (i, value) => { const mo = modeOf(i); return mo?.choice && !atoms[i].cell ? `${ref(i)}.is('${mo.choice[value]}')` : mo?.bool && !atoms[i].cell ? (value === 1 ? ref(i) : `${ref(i)}.not()`) : `${ref(i)}.eq(${value})`; };
+        const args = `({${[...new Set(used.map(i => (atoms[i].cell ? atoms[i].parts[0][0] : nameOf(i))))].join(', ')}})`;
+        const wrap = (body) => (f.cells ? `forall(k => ${body})` : body);
+        if (f.unreachable)
+            return `r.law('${text}', ${args} => ${cond(f.unreachable.atom, f.unreachable.value)}.not())`;
+        const term = (ts, k) => {
+            const parts = ts.map(([i, c]) => (Math.abs(c) === 1 ? val(i) : `${val(i)}.times(${Math.abs(c)})`));
+            if (!parts.length)
+                return String(k);
+            return parts.slice(1).reduce((acc, p) => `${acc}.plus(${p})`, parts[0]) + (k > 0 ? `.plus(${k})` : '');
+        };
+        const { left, right } = sides(f);
+        const body = left.length ? `${term(left, Math.max(0, -f.d))}.atMost(${term(right, Math.max(0, f.d))})` : `${term(right, Math.max(0, f.d))}.atLeast(${Math.max(0, -f.d)})`;
+        const guarded = !f.guard ? body : 'keyNot' in f.guard ? `k.eq(${nameOf(f.guard.keyNot)}).or(${body})` : `${cond(f.guard.atom, f.guard.value)}.implies(${body})`;
+        return `r.law('${text}', ${args} => ${wrap(guarded)})`;
+    };
+    // --- evaluating a form ---------------------------------------------------------------------------------------------
+    const holdsRow = (f, env) => {
+        if (f.unreachable)
+            return valueOf(atoms[f.unreachable.atom], env) !== f.unreachable.value;
+        if (f.guard) {
+            if ('keyNot' in f.guard) {
+                if (env[K] === valueOf(atoms[f.guard.keyNot], env))
+                    return true;
+            }
+            else if (valueOf(atoms[f.guard.atom], env) !== f.guard.value)
+                return true;
+        }
+        let s = 0;
+        for (const [i, c] of f.coef)
+            s += c * valueOf(atoms[i], env);
+        return s <= f.d;
+    };
+    const pointOf = (params, st) => ({ scalar: { ...params, ...st.scalars }, cells: cellRows(params, st) });
+    const holdsAt = (f, p) => (f.cells ? p.cells.every(r => holdsRow(f, r)) : holdsRow(f, p.scalar));
+    // A kernel witness as a point: its scalars, and a cell row per key it reads a map at.
+    const witnessPoint = (w) => {
+        const scalar = Object.fromEntries([...scalars, ...m.params].map(v => [v, w[v] ?? 0]));
+        const byKey = new Map();
+        for (const [name, value] of Object.entries(w)) {
+            const br = name.indexOf('[');
+            if (br < 0 || !name.endsWith(']') || !mapSet.has(name.slice(0, br)))
+                continue;
+            const key = keyValue(name, w);
+            if (key === undefined)
+                continue;
+            const row = byKey.get(key) ?? { ...scalar, [K]: key };
+            row[AT + name.slice(0, br)] = value;
+            byKey.set(key, row);
+        }
+        return { scalar, cells: [...byKey.values()] };
+    };
+    // --- Houdini on the runs' neighbors ----------------------------------------------------------------------------------
+    let alive = forms.slice().sort((p, q) => p.size - q.size).slice(0, maxCandidates);
+    const ctis = [];
+    const lawful = (params, st) => { try {
+        return given.every(l => watch(m, run, l, params, 4).start(st));
+    }
+    catch {
+        return false;
+    } };
+    const houdiniUntil = Math.min(until, performance.now() + Math.max(500, (until - performance.now()) / 4));
+    for (let quiet = 0; samples.length && performance.now() < houdiniUntil && quiet < 3;) {
+        const killed = new Set();
+        for (let tries = 0; tries < 400 && performance.now() < houdiniUntil; tries++) {
+            const base = samples[rand(samples.length)], scal = { ...base.st.scalars }, maps = { ...base.st.maps };
+            for (let k = 0, moves = 1 + rand(2); k < moves; k++) {
+                if (mapNames.length && rand(2) === 0) {
+                    const mp = mapNames[rand(mapNames.length)], ks = keysIn(base.st), key = ks.length && rand(3) ? ks[rand(ks.length)] : rand(5);
+                    const cells = new Map(maps[mp] ?? []);
+                    cells.set(key, Math.max(0, cellOf(base.st, mp, key) + (rand(7) - 3)));
+                    maps[mp] = cells;
+                }
+                else if (scalars.length) {
+                    const v = scalars[rand(scalars.length)];
+                    scal[v] = Math.max(0, scal[v] + (rand(7) - 3));
+                }
+            }
+            const st = { ...base.st, scalars: scal, maps }, pre = pointOf(base.params, st);
+            if (!alive.every(f => killed.has(f) || holdsAt(f, pre)) || !lawful(base.params, st))
+                continue;
+            const input = randomInput(base.params, 4);
+            let next;
+            try {
+                if (!allowed(m, run, base.params, st, input))
+                    continue;
+                next = run.step(base.params, st, input);
+            }
+            catch {
+                continue;
+            }
+            const post = pointOf(base.params, next);
+            let broke = false;
+            for (const f of alive)
+                if (!killed.has(f) && !holdsAt(f, post)) {
+                    killed.add(f);
+                    broke = true;
+                }
+            if (!broke && !lawful(base.params, next))
+                ctis.push(pre);
+        }
+        quiet = killed.size ? 0 : quiet + 1;
+        alive = alive.filter(f => !killed.has(f));
+    }
+    opts.progress?.('houdini', { alive: alive.length, ctis: ctis.length });
+    // --- the kernel ----------------------------------------------------------------------------------------------------
+    const lawOf = new Map();
+    const lawFor = (f) => { let l = lawOf.get(f); if (!l)
+        lawOf.set(f, (l = { name: textOf(f), holds: condOf(f), ...(f.cells ? { forall: KEY } : {}) })); return l; };
+    const names = new Set(given.map(l => l.name));
+    alive = alive.filter(f => !names.has(textOf(f)));
+    let pool = alive.slice(), chosen = [];
+    const goalName = (g) => g.replace(/ @[^@]*$/, '');
+    let last = first;
+    const slow = Math.max(3000, (opts.ms ?? 20000) / 10);
+    // A point a form is false at; a cell form is judged only at rows that read every map it reads.
+    const reads = (f, r) => f.coef.every(([i]) => !atoms[i].cell || atoms[i].parts.every(([q]) => AT + q in r));
+    const falseAt = (f, p) => (f.cells ? p.cells.some(r => reads(f, r) && !holdsRow(f, r)) : !holdsRow(f, p.scalar));
+    const best = (p) => {
+        let pickF, score = -Infinity;
+        for (const f of pool) {
+            if (chosen.includes(f) || !falseAt(f, p))
+                continue;
+            const s = ctis.reduce((k, c) => k + (falseAt(f, c) ? 1 : 0), 0) * 1000 - f.size;
+            if (s > score)
+                (pickF = f, score = s);
+        }
+        return pickF;
+    };
+    // The search proves one law at a time (proveLaw), each with every law assumed, and keeps what it proved while laws
+    // are only added (more laws assumed keep a proof a proof); dropping one forgets it all. Once every law is proven so,
+    // the set is proven as a whole, by the rule's own prover: that verdict is the answer.
+    // A law of the caller's (or a kind's) proven before any candidate was added stays proven whatever is added or dropped.
+    const done = new Set(), base = new Set();
+    const forget = () => { done.clear(); for (const b of base)
+        done.add(b); };
+    const drop = (f) => { chosen = chosen.filter(g => g !== f); pool = pool.filter(g => g !== f); forget(); };
+    const search = (ls) => {
+        for (let i = 0; i < ls.length; i++) {
+            if (done.has(ls[i].name))
+                continue;
+            proofs++;
+            const r = proveLaw(m, ls, i);
+            if (!r.proven)
+                return { proven: false, checked: false, goal: r.goal, stuck: r.stuck, ...(r.witness ? { witness: r.witness } : {}) };
+            done.add(ls[i].name);
+            if (!chosen.length)
+                base.add(ls[i].name);
+        }
+        if (stepLaws.length) {
+            proofs++;
+            const r = proveStepLaws(m, ls, stepLaws);
+            if (!r.proven)
+                return { proven: false, checked: false, ...(r.failed ? { goal: r.failed.goal, stuck: r.failed.stuck, ...(r.failed.witness ? { witness: r.failed.witness } : {}) } : {}) };
+        }
+        const whole = prove([...laws, ...chosen.map(lawFor)]);
+        if (!(whole.proven && whole.checked))
+            forget();
+        return whole;
+    };
+    for (let iter = 0; iter < 300 && performance.now() < until; iter++) {
+        const began = performance.now();
+        last = search([...given, ...chosen.map(lawFor)]);
+        const took = performance.now() - began;
+        opts.progress?.('proof', { chosen: chosen.length, goal: last.goal ?? '', stuck: last.stuck ?? '', ms: Math.round(took) });
+        if (last.proven && last.checked)
+            break;
+        if (!last.goal)
+            break;
+        const name = goalName(last.goal), stuckOn = chosen.find(f => lawFor(f).name === name);
+        if (last.run) {
+            // A real run breaks it: a candidate is false (dropped); a law of the caller's is false (the answer).
+            if (!stuckOn)
+                break;
+            drop(stuckOn);
+            continue;
+        }
+        // A proof the last candidate made slow (more cases to split) fails: that candidate goes.
+        if (chosen.length && took > slow) {
+            drop(chosen.at(-1));
+            continue;
+        }
+        const p = /@step|@\d+ steps/.test(last.goal) && last.witness ? witnessPoint(last.witness) : undefined;
+        if (p)
+            ctis.push(p);
+        const next = p ? best(p) : undefined;
+        if (next) {
+            chosen.push(next);
+            continue;
+        }
+        // Stuck with no counterexample on a goal not a candidate's: the last candidate made it harder, so it goes.
+        if (chosen.length && !stuckOn && !p) {
+            drop(chosen.at(-1));
+            continue;
+        }
+        if (!stuckOn)
+            break;
+        drop(stuckOn);
+    }
+    if (!(last.proven && last.checked))
+        return { ...last, found: [], stats: stats(samples.length, forms.length, alive.length) };
+    // Take out what the proof doesn't need, the last added first.
+    for (const f of [...chosen].reverse()) {
+        if (performance.now() > until)
+            break;
+        const without = chosen.filter(g => g !== f), v = prove([...laws, ...without.map(lawFor)]);
+        if (v.proven && v.checked)
+            (chosen = without, last = v);
+    }
+    return { ...last, found: chosen.map(f => { const law = lawFor(f), text = law.name, source = sourceOf(f, text); return { law, text, ...(source ? { source } : {}) }; }), stats: stats(samples.length, forms.length, alive.length) };
+}

package/dist/kernel/kernel.d.ts

@@ -8,6 +8,7 @@ export type Tree = {
 } | {
     leaf: Step[];
     products?: [number, number][];
+    squares?: Lin[];
 };
 export type Goal = {
     name: string;
@@ -25,6 +26,9 @@ export declare const termColumn: (e: E) => string;
 export declare const columnTerm: (name: string) => E | undefined;
 export declare function decided(e: E, path: Path): boolean;
 export declare function termRows(name: string, path: Path): Lin[];
+export declare function factorsOf(name: string): string[];
+export declare const isMonomial: (name: string) => boolean;
+export declare const isCell: (name: string) => boolean;
 export declare function truth(c: C, path: Path): boolean | undefined;
 export declare function facts(c: C, path: Path, positive?: boolean): Lin[];
 export declare function leafConstraints(goal: Goal, path: Path): Constraint[];
@@ -43,7 +47,7 @@ export type Seen<T> = {
     size?: number;
 };
 export declare function reusing<T>(seen: Seen<T>, path: Path, f: (path: Path) => T): T;
-export declare function withProducts(rows: Constraint[], pairs: [number, number][]): Constraint[];
+export declare function withProducts(rows: Constraint[], pairs: [number, number][], squares?: Lin[]): Constraint[];
 export declare function check(goal: Goal, tree: Tree, path?: Path): boolean;
 export type Subst = {
     vars: Record<string, E>;