gdp-wired 0.19.0 → 0.21.0

package/dist/core/infer.js

@@ -1,6 +1,7 @@
 // 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
+//   - runs: random runs from the start (params and requests by their kinds, the assumption met) give reachable states,
+//     3,000 kept as samples
 //   - 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
@@ -14,11 +15,23 @@
 //     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 { quietly } from "./cyclic.js";
-import { any, atMost, evalC, get, interpret, n, not, plus, same, times, x } from "./machine.js";
+import { any, atMost, divisorsIn, evalC, get, interpret, machineTerms, modName, n, not, plus, same, times, withArithmetic, x } from "./machine.js";
 import { proveRule, proveSteps } from "./dsl.js";
 import { allowed, watch } from "./watch.js";
 import { proveLaw, proveLaws, proveStepLaws, withDeadline } from "../kernel/prove.js";
-const KEY = 'key$found', AT = '@', K = '#';
+import { work } from "./solver.js";
+const KEY = 'key$found', AT = '@', K = '#', SOME = 'k$found';
+// The counted clock's rates, units a millisecond: about the slowest tenth of what Modal's 1-vCPU containers do in each
+// phase (`runs/modal/infer/after2`, GDP_INFER_TRACE=1: requests tried 85 a ms, rows 13,093, forms evaluated 11,240, the
+// kernel's work 37; laws watched 198 by a fit), so a counted budget runs out no later than a timed one would there.
+// The runs' requests: 16,000, 400 trials of a rule whose every request is allowed. Every search of the suite's and the
+// frontier corpus's then keeps 3,000 samples, at least as many as 500 ms of wall time gave on 2 vCPU (`runs/modal/infer/
+// before`'s cal2 jobs: 29 to 11,625 trials, 745 to 3,000 samples). Of 100 to 3,000 trials (`runs/modal/infer/grid`),
+// 100 lost a corpus item (metered blocks) and 200 to 3,000 none: 400 is a step above the least that lost none.
+export const inferRates = { tries: 100, rows: 10_000, evals: 10_000, watched: 100, work: 40 };
+export const inferRuns = 16_000;
+// GDP_INFER_TRACE=1: each phase's wall time beside what it counted, to stderr (the calibration's numbers).
+const inferTrace = !!globalThis.process?.env?.GDP_INFER_TRACE;
 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));
@@ -110,17 +123,54 @@ export function inferLaws(target, laws, stepLaws = [], opts = {}) {
     return quietly(() => withDeadline(performance.now() + (opts.ms ?? 20000), () => inferLawsSearch(target, laws, stepLaws, opts)));
 }
 function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
-    const t0 = performance.now(), until = t0 + (opts.ms ?? 20000), rule = isRule(target) ? target : undefined;
+    const t0 = performance.now(), ms = opts.ms ?? 20000, wallUntil = t0 + ms, rule = isRule(target) ? target : undefined;
+    // The clock the budgets read (counted milliseconds since the start, or wall time where `timed`), and the stop.
+    const timed = !!opts.timed, w0 = work.n, used = { tries: 0, rows: 0, evals: 0, watched: 0 };
+    const now = () => (timed ? performance.now() - t0
+        : used.tries / inferRates.tries + used.rows / inferRates.rows + used.evals / inferRates.evals + used.watched / inferRates.watched + (work.n - w0) / inferRates.work);
+    let stopped = false;
+    const stop = () => stopped || (stopped = performance.now() > wallUntil);
+    const until = ms;
+    let tp = performance.now(), cp = 0, wp = w0;
+    const trace = (what, o = {}) => {
+        if (!inferTrace)
+            return;
+        const t = performance.now(), c = now();
+        globalThis.process.stderr.write(`[infer] ${what} ${JSON.stringify({ ms: Math.round(t - tp), counted: Math.round(c - cp), work: work.n - wp, ...used, ...o })}\n`);
+        tp = t;
+        cp = c;
+        wp = work.n;
+    };
+    if (rule) {
+        const ks = divisorsIn([...laws, ...stepLaws]);
+        if (ks.size)
+            rule.dividesBy(...ks);
+    }
     const m = rule ? rule.machine : target;
     let proofs = 0;
+    // The rule (or machine) the kernel proves the candidates with: once a remainder is among them, one that declares
+    // div$k and mod$k for its divisors (rule.withDivisors leaves the caller's rule as it was until a found law needs them).
+    // Only the laws proven read: a search none of whose chosen candidates is a remainder proves with the rule as it is.
+    const byDivisors = new Map();
+    const forLaws = (ls) => {
+        const ks = [...divisorsIn(ls.map(l => l.holds))].filter(k2 => !m.fns?.[modName(k2)]).sort((a, b) => a - b), key = ks.join(',');
+        let out = byDivisors.get(key);
+        if (!out) {
+            const r2 = ks.length ? rule?.withDivisors(...ks) : rule;
+            out = { r: r2, m: r2 ? r2.machine : withArithmetic(m, [], ks) };
+            byDivisors.set(key, out);
+        }
+        return out;
+    };
     const prove = (ls) => {
         proofs++;
-        if (rule)
-            return stepLaws.length ? proveSteps(rule, ls, stepLaws, { search: false }) : proveRule(rule, ls, { search: false });
-        const out = stepLaws.length ? proveStepLaws(m, ls, stepLaws) : proveLaws(m, ls);
+        const { r: searchRule, m: mm } = forLaws(ls);
+        if (searchRule)
+            return stepLaws.length ? proveSteps(searchRule, ls, stepLaws, { search: false }) : proveRule(searchRule, ls, { search: false });
+        const out = stepLaws.length ? proveStepLaws(mm, ls, stepLaws) : proveLaws(mm, 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 stats = (samples, candidates, alive) => ({ samples, candidates, alive, proofs, ms: Math.round(performance.now() - t0), stopped: stop() });
     const first = opts.first ?? prove(laws);
     if ((first.proven && first.checked) || first.run)
         return { ...first, found: [], stats: stats(0, 0, 0) };
@@ -138,9 +188,19 @@ function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
     for (const st of opts.seen ?? [])
         if (!m.params.length)
             keep({ params: {}, st });
+    trace('start');
     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) {
+    // Counted: `runs` requests tried at least, and on until the samples are full (a trial keeps its start at least, so as
+    // many trials as they hold fill them), the trials at most `runs` or that many. Timed: `runsMs` of wall time.
+    const runsTimed = timed || opts.runsMs !== undefined, runsUntil = Math.min(wallUntil, performance.now() + (opts.runsMs ?? 500)), least = opts.runs ?? inferRuns;
+    const moreRuns = (trial) => (runsTimed ? performance.now() < runsUntil : trial < Math.max(cap, least) && (used.tries < least || samples.length < cap) && !stop());
+    let trials = 0;
+    // (an assumption with "there exists", a value the request brings, may admit no request at a small bound, a multiple
+    // of 5 but 0, say: a trial whose steps moved nothing doubles the bound at once)
+    const skolems = m.inputs.some(i => i.startsWith('some$a'));
+    for (let trial = 0, bound = 2, stuck = false; moreRuns(trial); trial++, bound = trial % 20 === 0 || stuck ? (bound >= 1024 ? 2 : bound * 2) : bound) {
+        stuck = false;
+        trials++;
         const params = randomParams(bound);
         if (m.pre && !evalC(m.pre, params, { scalars: {}, maps: {} }, m))
             continue;
@@ -152,7 +212,9 @@ function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
             continue;
         }
         keep({ params, st });
+        let took = 0;
         for (let d = 0, tries = 0; d < 40 && tries < 200; tries++) {
+            used.tries++;
             const input = randomInput(params, bound);
             let next;
             try {
@@ -164,12 +226,16 @@ function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
                 break;
             }
             d++;
-            if (JSON.stringify(next.scalars) !== JSON.stringify(st.scalars) || mapsText(next) !== mapsText(st))
+            if (JSON.stringify(next.scalars) !== JSON.stringify(st.scalars) || mapsText(next) !== mapsText(st)) {
                 keep({ params, st: next });
+                took++;
+            }
             st = next;
         }
+        stuck = skolems && took === 0;
     }
-    opts.progress?.('runs', { samples: samples.length });
+    opts.progress?.('runs', { samples: samples.length, trials });
+    trace('runs', { samples: samples.length, trials });
     // --- atoms and rows --------------------------------------------------------------------------------------------------
     const scalars = Object.keys(m.state), stateSet = new Set(scalars), mapNames = Object.keys(m.maps ?? {}), mapSet = new Set(mapNames);
     const atoms = [];
@@ -276,11 +342,12 @@ function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
     // 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);
+    const buildUntil = Math.min(until, now() + (until - now()) / 4);
     for (const [n_, { coef, cells }] of shapes.entries()) {
-        if (forms.length > maxCandidates || (n_ % 256 === 0 && performance.now() > buildUntil))
+        if (forms.length > maxCandidates || (n_ % 256 === 0 && (now() > buildUntil || stop())))
             break;
         const vals = cells ? valsK : valsS, N = cells ? NK : NS, rows = cells ? rowsK : rowsS;
+        used.rows += N + (coef.length > 2 ? 0 : Math.ceil(N / (cells ? strideK : strideS)));
         let d = -Infinity;
         for (let j = 0; j < N; j++)
             d = Math.max(d, at(coef, vals, j));
@@ -313,7 +380,76 @@ function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
             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 });
+    // Remainders: a value, or the sum or difference of two, at one remainder by k in every run (or in every run where a
+    // guard holds), k each divisor the rule and its laws read (modBy, divBy) and 2: x mod 2 = 0 for a counter that steps
+    // by 2, the parity of a sum that two counters keep. No form above states one (no linear bound does).
+    // The moduli: the divisors the rule and its laws read, then 2, 3, 4 and the rule's own constants up to 64 (six in all).
+    const divisors = [...new Set([...[...divisorsIn([...machineTerms(m), ...laws.map(l => l.holds)])].filter(k => k >= 2 && k <= 1_000_000).sort((p, q) => p - q), 2, 3, 4, ...consts.filter(k => k > 4 && k <= 64)])].slice(0, 6);
+    const modAtoms = terms.filter(i => !atoms[i].param && !modeOf(i)?.bool), modShapes = modAtoms.map(i => [[i, 1]]);
+    if (modAtoms.length * (modAtoms.length - 1) <= 2000)
+        for (const [a, i] of modAtoms.entries())
+            for (const j of modAtoms.slice(a + 1))
+                modShapes.push([[i, 1], [j, 1]], [[i, 1], [j, -1]]);
+    const residue = (v, k) => ((v % k) + k) % k;
+    // A shape whose runs reached two values or fewer is a bound's (above), not a remainder's.
+    const varied = (coef) => { const vs = new Set(); for (let j = 0; j < NS && vs.size < 3; j += strideS) {
+        used.rows++;
+        vs.add(at(coef, valsS, j));
+    } return vs.size >= 3; };
+    for (const coef of NS && opts.remainders !== false ? modShapes.filter(varied) : [])
+        for (const k of divisors) {
+            if (forms.length > maxCandidates || now() > buildUntil || stop())
+                break;
+            const all = new Set(), byGuard = guards.map(() => new Map());
+            used.rows += Math.ceil(NS / strideS);
+            for (let j = 0; j < NS; j += strideS) {
+                const r = residue(at(coef, valsS, j), k);
+                all.add(r);
+                guards.forEach((mode, g) => { const v = valsS[mode.atom][j], b = byGuard[g]; if (!b.has(v))
+                    b.set(v, new Set()); b.get(v).add(r); });
+            }
+            const size = sizeOf(coef) + 30 + k;
+            if (all.size === 1) {
+                forms.push({ coef, d: 0, cells: false, mod: { k, r: [...all][0] }, size });
+                continue;
+            }
+            guards.forEach((mode, g) => { if (coef.some(([i]) => i === mode.atom))
+                return; for (const [value, rs] of byGuard[g])
+                if (rs.size === 1 && mode.values.includes(value))
+                    forms.push({ coef, d: 0, cells: false, guard: { atom: mode.atom, value }, mod: { k, r: [...rs][0] }, size: size + 50 }); });
+        }
+    // Congruences, where remainders are off: a state value (or the sum or difference of two) whose every sample leaves
+    // one remainder by a constant of the rule's (2 first), with at least three values reached: ∃k. v = c·k + r. The
+    // remainder above says the same without a quantifier, so the kernel proves it as it stands (no witness to choose),
+    // under a guard where only some runs keep it, and Lean states it with %: that is the form tried by default.
+    if (opts.remainders === false && opts.existentials !== false && NS) {
+        const mods = [...new Set([2, 3, 4, ...consts.filter(k => k > 4 && k <= 64)])].slice(0, 6);
+        const congOf = (coef) => {
+            const vs = new Set();
+            used.rows += NS;
+            for (let j = 0; j < NS; j++)
+                vs.add(at(coef, valsS, j));
+            if (vs.size < 3)
+                return;
+            const nat = coef.every(([i, c]) => !atoms[i].int && c > 0), list = [...vs];
+            for (const c of mods) {
+                const r = ((list[0] % c) + c) % c;
+                if (list.every(x => ((x % c) + c) % c === r) && (!nat || list.every(x => x >= r)))
+                    forms.push({ coef, d: 0, cells: false, cong: { mod: c, rest: r }, size: sizeOf(coef) + 40 + c });
+            }
+        };
+        const st = plain.filter(i => !atoms[i].param && !modeOf(i));
+        for (const i of st)
+            congOf([[i, 1]]);
+        if (st.length <= 24)
+            for (const [a, i] of st.entries())
+                for (const j of st.slice(a + 1)) {
+                    congOf([[i, 1], [j, 1]]);
+                    congOf([[i, 1], [j, -1]]);
+                }
+    }
     opts.progress?.('candidates', { atoms: A, shapes: shapes.length, forms: forms.length });
+    trace('candidates', { 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); };
@@ -333,13 +469,18 @@ function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
     const textOf = (f) => {
         if (f.unreachable)
             return `${nameOf(f.unreachable.atom)} is never ${shownValue(f.unreachable.atom, f.unreachable.value)}`;
+        if (f.cong)
+            return `∃k. ${f.coef.map(([i, c], j) => `${j ? (c > 0 ? ' + ' : ' − ') : c < 0 ? '−' : ''}${nameOf(i)}`).join('')} = ${f.cong.mod}·k${f.cong.rest ? ` + ${f.cong.rest}` : ''}`;
         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 body = f.mod ? `${f.coef.map(([i, c], j) => `${c < 0 ? (j ? ' − ' : '−') : j ? ' + ' : ''}${nameOf(i)}`).join('')} mod ${f.mod.k} = ${f.mod.r}` : within ? `${nameOf(f.coef[0][0])} is ${within.map(v => shownValue(f.coef[0][0], v)).join(' or ')}` : `${l} <= ${r}`;
         const under = f.when ? (({ l: wl, r: wr }) => `${wl} <= ${wr} → `)(sides({ coef: f.when.coef, d: f.when.d, cells: false, size: 0 })) : '';
         const guarded = !f.guard ? under + body : 'keyNot' in f.guard ? `k = ${nameOf(f.guard.keyNot)} or ${body}` : `${nameOf(f.guard.atom)} is ${shownValue(f.guard.atom, f.guard.value)} → ${under}${body}`;
         return f.cells ? `every k: ${guarded}` : guarded;
     };
     const sum = (es) => es.reduce((p, q) => plus(p, q), n(0));
+    // Each congruence its own witness's name (each may be a ghost of the machine).
+    const someNames = new Map(), someName = (f) => { let k = someNames.get(f); if (!k)
+        someNames.set(f, (k = `${SOME}${someNames.size}`)); return k; };
     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
@@ -353,6 +494,19 @@ function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
         };
         if (f.unreachable)
             return notAt(f.unreachable.atom, f.unreachable.value);
+        if (f.mod) {
+            // Σ c·v = P − N over naturals (P the positive parts, N the negative ones), whose remainder by k is that of the
+            // natural P + (k − 1)·N.
+            const { k: dk, r } = f.mod, neg = partsOf(f, -1), e = get(modName(dk), sum([...partsOf(f, 1), ...neg.map(t => times(dk - 1, t))]));
+            const body = same(e, n(r));
+            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);
+        }
+        // Σ = c·k + r, k = SOME (an integer's two parts where Σ reads an integer or a difference): the negative parts and
+        // c·k's negative part on the other side.
+        if (f.cong) {
+            const k = someName(f), intK = f.coef.some(([i, c]) => atoms[i].int || c < 0), ck = times(f.cong.mod, x(k)), ckNeg = times(f.cong.mod, x(`${k}$neg`));
+            return same(sum([...partsOf(f, 1), ...(intK ? [ckNeg] : [])]), sum([...partsOf(f, -1), ck, ...(f.cong.rest ? [n(f.cong.rest)] : [])]));
+        }
         const lhs = sum([...partsOf(f, 1), ...(f.d < 0 ? [n(-f.d)] : [])]), rhs = sum([...partsOf(f, -1), ...(f.d > 0 ? [n(f.d)] : [])]);
         // Under a condition Σ ≤ d: its negation, −Σ ≤ −d − 1, or the body.
         const body = f.when ? any(condOf({ coef: f.when.coef.map(([i, c]) => [i, -c]), d: -f.when.d - 1, cells: false, size: 0 }), atMost(lhs, rhs)) : atMost(lhs, rhs);
@@ -360,7 +514,7 @@ function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
     };
     // The builder call, for a rule whose atoms are its own variables (naturals, or integers alone).
     const sourceOf = (f, text) => {
-        if (!rule || f.when)
+        if (!rule || f.when || f.mod)
             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;
@@ -373,6 +527,12 @@ function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
         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())`;
+        if (f.cong) {
+            if (f.coef.length !== 1 || f.coef[0][1] !== 1)
+                return undefined;
+            const intK = atoms[f.coef[0][0]].int;
+            return `r.law('${text}', ${args} => exists(${intK ? 'int, ' : ''}k => ${val(f.coef[0][0])}.eq(k.times(${f.cong.mod})${f.cong.rest ? `.plus(${f.cong.rest})` : ''})))`;
+        }
         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)
@@ -385,28 +545,49 @@ function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
         return `r.law('${text}', ${args} => ${wrap(guarded)})`;
     };
     // --- evaluating a form ---------------------------------------------------------------------------------------------
+    // (each row's atom values read once, however many forms are evaluated there: rows are never changed once made)
+    const valuesAt = new WeakMap();
+    const valuesOf = (env) => {
+        let vs = valuesAt.get(env);
+        if (!vs) {
+            vs = new Float64Array(A);
+            for (let i = 0; i < A; i++)
+                vs[i] = valueOf(atoms[i], env);
+            valuesAt.set(env, vs);
+        }
+        return vs;
+    };
     const holdsRow = (f, env) => {
+        used.evals++;
+        const vs = valuesOf(env);
         if (f.unreachable)
-            return valueOf(atoms[f.unreachable.atom], env) !== f.unreachable.value;
+            return vs[f.unreachable.atom] !== f.unreachable.value;
+        if (f.cong) {
+            let v = 0;
+            for (const [i, c] of f.coef)
+                v += c * vs[i];
+            const nat = f.coef.every(([i, c]) => !atoms[i].int && c > 0);
+            return ((v - f.cong.rest) % f.cong.mod + f.cong.mod) % f.cong.mod === 0 && (!nat || v >= f.cong.rest);
+        }
         if (f.guard) {
             if ('keyNot' in f.guard) {
-                if (env[K] === valueOf(atoms[f.guard.keyNot], env))
+                if (env[K] === vs[f.guard.keyNot])
                     return true;
             }
-            else if (valueOf(atoms[f.guard.atom], env) !== f.guard.value)
+            else if (vs[f.guard.atom] !== f.guard.value)
                 return true;
         }
         if (f.when) {
             let w = 0;
             for (const [i, c] of f.when.coef)
-                w += c * valueOf(atoms[i], env);
+                w += c * vs[i];
             if (w > f.when.d)
                 return true;
         }
         let s = 0;
         for (const [i, c] of f.coef)
-            s += c * valueOf(atoms[i], env);
-        return s <= f.d;
+            s += c * vs[i];
+        return f.mod ? residue(s, f.mod.k) === f.mod.r : 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));
@@ -430,16 +611,16 @@ function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
     // --- 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 {
+    const lawful = (params, st) => { used.watched += given.length; 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 houdiniUntil = Math.min(until, now() + Math.max(500, (until - now()) / 4));
+    for (let quiet = 0; samples.length && now() < houdiniUntil && !stop() && quiet < 3;) {
         const killed = new Set();
-        for (let tries = 0; tries < 400 && performance.now() < houdiniUntil; tries++) {
+        for (let tries = 0; tries < 400 && now() < houdiniUntil && !stop(); 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) {
@@ -480,23 +661,27 @@ function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
         alive = alive.filter(f => !killed.has(f));
     }
     opts.progress?.('houdini', { alive: alive.length, ctis: ctis.length });
+    trace('houdini', { alive: alive.length });
     // --- the kernel ----------------------------------------------------------------------------------------------------
     const lawOf = new Map();
+    const someOf = (f) => (!f.cong ? [] : f.coef.some(([i, c]) => atoms[i].int || c < 0) ? [someName(f), `${someName(f)}$neg`] : [someName(f)]);
     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; };
+        lawOf.set(f, (l = { name: textOf(f), holds: condOf(f), ...(f.cells ? { forall: KEY } : {}), ...(f.cong ? { some: someOf(f) } : {}) })); 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);
+    const slow = Math.max(3000, ms / 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) => {
+    // (a remainder or a congruence only where no bound of the candidates rules the point out, before the counterexample's own forms:
+    // false at half the states a run doesn't reach, it would otherwise be chosen first everywhere)
+    const best = (p, congs = false) => {
         let pickF, score = -Infinity;
         for (const f of pool) {
-            if (chosen.includes(f) || !falseAt(f, p))
+            if (chosen.includes(f) || !!(f.cong || f.mod) !== congs || !falseAt(f, p))
                 continue;
             const s = ctis.reduce((k, c) => k + (falseAt(f, c) ? 1 : 0), 0) * 1000 - f.size;
             if (s > score)
@@ -511,7 +696,7 @@ function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
     const choiceMode = modes.find(mo => mo.choice && !atoms[mo.atom].cell);
     const condAtoms = plain.filter(i => !atoms[i].param && i !== choiceMode?.atom);
     const fromCti = (p) => {
-        const stop = Math.min(until, performance.now() + Math.max(300, (until - performance.now()) / 8));
+        const end = Math.min(until, now() + Math.max(300, (until - now()) / 8));
         const sc = p.scalar, pv = (coef) => { let v = 0; for (const [i, c] of coef)
             v += c * valueOf(atoms[i], sc); return v; };
         const gv = choiceMode ? valueOf(atoms[choiceMode.atom], sc) : undefined;
@@ -561,9 +746,10 @@ function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
         for (const coef of conds) {
             const here = pv(coef);
             for (const d of [...new Set([here, 0, 1, -1])].filter(d => here <= d)) {
-                if (performance.now() > stop)
+                if (now() > end || stop())
                     break;
                 const rows = [];
+                used.rows += inGuard.length;
                 for (const j of inGuard)
                     if (at(coef, valsS, j) <= d)
                         rows.push(j);
@@ -574,9 +760,10 @@ function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
                 }
                 const stride = Math.max(1, Math.ceil(rows.length / 600));
                 for (const [q, sh] of bodies.entries()) {
-                    if (q % 256 === 0 && performance.now() > stop)
+                    if (q % 256 === 0 && (now() > end || stop()))
                         break;
                     const v = pv(sh.coef);
+                    used.rows += Math.ceil(rows.length / stride);
                     let most = -Infinity, ok = true;
                     for (let t = 0; t < rows.length; t += stride) {
                         const w = at(sh.coef, valsS, rows[t]);
@@ -604,11 +791,18 @@ function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
         done.add(b); };
     const drop = (f) => { chosen = chosen.filter(g => g !== f); pool = pool.filter(g => g !== f); forget(); };
     const search = (ls) => {
+        // (laws with "there exists" are proven as a set, their witnesses chosen together: core/exists.ts)
+        if (ls.some(l => l.some?.length)) {
+            const whole = prove([...laws, ...chosen.map(lawFor)]);
+            if (!(whole.proven && whole.checked))
+                forget();
+            return whole;
+        }
         for (let i = 0; i < ls.length; i++) {
             if (done.has(ls[i].name))
                 continue;
             proofs++;
-            const r = proveLaw(m, ls, i);
+            const r = proveLaw(forLaws(ls).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);
@@ -617,7 +811,7 @@ function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
         }
         if (stepLaws.length) {
             proofs++;
-            const r = proveStepLaws(m, ls, stepLaws);
+            const r = proveStepLaws(forLaws(ls).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 } : {}) } : {}) };
         }
@@ -626,11 +820,11 @@ function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
             forget();
         return whole;
     };
-    for (let iter = 0; iter < 300 && performance.now() < until; iter++) {
-        const began = performance.now();
+    for (let iter = 0; iter < 300 && now() < until && !stop(); iter++) {
+        const began = now(), wall = 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) });
+        const took = now() - began;
+        opts.progress?.('proof', { chosen: chosen.length, goal: last.goal ?? '', stuck: last.stuck ?? '', ms: Math.round(performance.now() - wall), counted: Math.round(took) });
         if (last.proven && last.checked)
             break;
         if (!last.goal)
@@ -652,6 +846,8 @@ function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
         if (p)
             ctis.push(p);
         let next = p ? best(p) : undefined;
+        if (!next && p)
+            next = best(p, true);
         if (!next && p) {
             const t = performance.now(), made = fromCti(p);
             pool.push(...made);
@@ -671,15 +867,36 @@ function inferLawsSearch(target, laws, stepLaws = [], opts = {}) {
             break;
         drop(stuckOn);
     }
-    if (!(last.proven && last.checked))
+    // Unproven: each congruence the runs left alive, with the laws alone (the counterexamples' choice may have gone to the
+    // bounds instead), at most four.
+    if (!(last.proven && last.checked)) {
+        for (const f of alive.filter(g => g.cong).slice(0, 4)) {
+            if (now() > until || stop())
+                break;
+            const v = prove([...laws, lawFor(f)]);
+            if (v.proven && v.checked) {
+                chosen = [f];
+                last = v;
+                break;
+            }
+        }
+    }
+    trace('kernel', { chosen: chosen.length, proven: !!(last.proven && last.checked) });
+    if (!(last.proven && last.checked)) {
+        trace('end', { proven: false, stopped: stop() });
         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)
+        if (now() > until || stop())
             break;
         const without = chosen.filter(g => g !== f), v = prove([...laws, ...without.map(lawFor)]);
         if (v.proven && v.checked)
             (chosen = without, last = v);
     }
+    const kept = chosen.flatMap(f => (f.mod ? [f.mod.k] : []));
+    if (kept.length)
+        rule?.dividesBy(...kept);
+    trace('end', { proven: true, stopped: stop(), found: chosen.map(f => textOf(f)).join('; ') });
     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/core/machine.d.ts

@@ -134,6 +134,22 @@ export type Law = {
     forall?: string;
     keys?: string[];
     stated?: C;
+    some?: string[];
+    witness?: SomeWitness;
+    ex?: SomeProof;
+};
+export type SomeWitness = {
+    terms?: Record<string, E>;
+    ghost?: Record<string, {
+        start: E;
+        step: E;
+    }>;
+};
+export type SomeProof = {
+    vars: string[];
+    body: C;
+    sub?: Record<string, E>;
+    ghost?: true;
 };
 export { unreachable } from '../kernel/kernel.js';
 export declare const x: (name: string) => E;
@@ -153,6 +169,17 @@ export declare const all: (...xs: C[]) => C;
 export declare const any: (...xs: C[]) => C;
 export declare const not: (c: C) => C;
 export declare const bit: (name: string) => C;
+export declare const divName: (k: number) => string;
+export declare const modName: (k: number) => string;
+export declare const isArithmetic: (name: string) => boolean;
+export declare const divisor: (k: number, what: string) => number;
+export declare function divisorsIn(ts: readonly (E | C)[], out?: Set<number>): Set<number>;
+export declare function arithmetic(ks: Iterable<number>): {
+    fns: Record<string, Fn>;
+    facts: Law[];
+};
+export declare function withArithmetic(m: Machine, more?: readonly (E | C)[], ks?: Iterable<number>): Machine;
+export declare const machineTerms: (m: Machine) => (E | C)[];
 export type State = {
     scalars: Record<string, number>;
     maps: Record<string, Map<number, number>>;

package/dist/core/machine.js

@@ -33,6 +33,51 @@ export const all = (...xs) => ({ op: 'and', xs });
 export const any = (...xs) => ({ op: 'or', xs });
 export const not = (c) => ({ op: 'not', x: c });
 export const bit = (name) => any(same(x(name), n(0)), same(x(name), n(1)));
+// --- division and remainder by a constant ------------------------------------------------------------------------
+// x div k and x mod k, for a constant k >= 1, are reads of two functions of the rule, div$k and mod$k, at x. The kernel
+// knows them by two facts: x = k·div$k(x) + mod$k(x), and mod$k(x) < k (both naturals, as every value is), which fix
+// both values (Euclid's division), so a goal about them is Presburger arithmetic the kernel already decides: nothing
+// new is trusted. The runtimes compute them as Math.floor(x / k) and x % k; the Lean export defines them as Lean's
+// x / k and x % k and proves the two facts of those by omega.
+export const divName = (k) => `div$${k}`;
+export const modName = (k) => `mod$${k}`;
+const arithRe = /^(div|mod)\$(\d+)$/;
+export const isArithmetic = (name) => arithRe.test(name);
+export const divisor = (k, what) => {
+    if (!Number.isSafeInteger(k) || k < 1)
+        throw new RangeError(`${what} divides by a whole number at least 1, not ${k}`);
+    return k;
+};
+// The constants some terms divide by.
+export function divisorsIn(ts, out = new Set()) {
+    for (const t of ts)
+        for (const m of JSON.stringify(t).matchAll(/"op":"get","map":"(?:div|mod)\$(\d+)"/g))
+            out.add(Number(m[1]));
+    return out;
+}
+// The two functions and their facts for each divisor: what a machine that divides by k declares.
+export function arithmetic(ks) {
+    const fns = {}, facts = [];
+    for (const k of [...new Set(ks)].sort((a, b) => a - b)) {
+        const d = divName(k), r = modName(k), key = `x$${r}`, at = (map) => get(map, x(key));
+        fns[d] = { js: `x => Math.floor(x / ${k})`, lean: `fun x => x / ${k}` };
+        fns[r] = { js: `x => x % ${k}`, lean: `fun x => x % ${k}` };
+        facts.push({ name: `${r}: x = ${k}·(x div ${k}) + x mod ${k}`, forall: key, holds: same(x(key), plus(times(k, at(d)), at(r))) }, { name: `${r}: x mod ${k} < ${k}`, forall: key, holds: less(at(r), n(k)) });
+    }
+    return { fns, facts };
+}
+// A machine with the functions and facts of every divisor its terms (or the laws given) read, those it lacks added.
+export function withArithmetic(m, more = [], ks = []) {
+    const all = divisorsIn(more, divisorsIn(machineTerms(m), new Set(ks)));
+    const { fns, facts } = arithmetic([...all].filter(k => !m.fns?.[modName(k)]));
+    if (!Object.keys(fns).length)
+        return m;
+    return { ...m, fns: { ...m.fns, ...fns }, facts: [...(m.facts ?? []), ...facts] };
+}
+// Every term and condition a machine holds.
+export const machineTerms = (m) => [...Object.values(m.state), ...Object.values(m.step.flags ?? {}), ...Object.values(m.step.state ?? {}),
+    ...Object.values(m.step.maps ?? {}).flatMap(w => ('key' in w ? [w.key, w.value] : [w.value])), ...(m.pre ? [m.pre] : []), ...(m.assume ? [m.assume] : []),
+    ...(m.facts ?? []).map(f => f.holds), ...(m.history ? [m.history.keep, ...Object.values(m.history.sums), ...Object.values(m.history.queries), ...(m.history.relations ?? []).flatMap(r => [r.when, r.holds])] : [])];
 // A condition at every key, or a value at every key. Where the bound key is read only as a map's key, each key a map
 // read holds a cell at, and one key past them all (where every map reads its default), are every case there is.
 const mapsIn = (t) => [...new Set([...JSON.stringify(t).matchAll(/"op":"get","map":"([^"]+)"/g)].map(x => x[1]))];

package/dist/core/solver.d.ts

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