gdp-wired 0.11.0 → 0.12.1

package/README.md

@@ -51,7 +51,8 @@ All of these are proven automatically, and each proof is also a Lean theorem:
 
 - **Invariants**: a law that holds after every sequence of requests ("spend stays within the budget").
 - **Maps, sets and lists of names**: laws at every key ("no day passes its cap"), sets a request carries, conditions
-  about every key, lists kept in order (`examples/sets.ts`, `examples/lists.ts`).
+  about every key or every two keys ("a batch is taken only when its values increase"), lists kept in order
+  (`examples/sets.ts`, `examples/lists.ts`, `examples/pairs.ts`).
 - **Step laws**: what one step does ("a balance only goes down", "a grant adds one"), and laws over several steps in a
   row.
 - **Histories**: sums and queries over a log of requests, like a sliding-window rate limit.
@@ -261,7 +262,8 @@ const soon = retry.law('the next try is at most 64 after the last request', ({ne
 - **Arithmetic** over the naturals: `plus`, `minus` (truncated), `times(k)`, `mul` (a product of two terms), `min`,
   `max`, `when(cond, a, b)`, `count(cond)`; conditions `lt`, `atMost`, `eq`, `and`, `or`, `not`, `implies`.
 - **Sets and quantifiers**: `.carries(...)` for sets a request brings, `everyKey(k => ...)` (and `has`, `subsetOf`,
-  `disjointFrom`, `sameAs`) anywhere in a step or inside a law, `M.each(k => ...)` to write every key, and
+  `disjointFrom`, `sameAs`) anywhere in a step or inside a law, `everyKey((i, j) => ...)` in a step for every two keys
+  (each read on its own, compared with the other plainly: `i.lt(j)`), `M.each(k => ...)` to write every key, and
   `someKey(k => ..., witness?)` for "some key where", proven through a witness the prover finds or the one given.
 - **Functions** (`.fns({perMinute: divBy(60)})`, or `fn(arity, js, {facts, lean})` for your own): read like params that
   take arguments, `perMinute(t)`; the kernel knows each only by its facts (`.facts(...)`, and a library function's

package/dist/core/compose.js

@@ -37,7 +37,7 @@ function renameC(c, prefix, m, inputs) {
     if (c.op === 'and' || c.op === 'or')
         return { op: c.op, xs: c.xs.map(y => renameC(y, prefix, m, inputs)) };
     if (c.op === 'all')
-        return { op: 'all', key: `${prefix}${c.key}`, c: renameC(c.c, prefix, m, inputs) }; // the key renamed with its side
+        return { ...c, key: `${prefix}${c.key}`, ...(c.keys ? { keys: c.keys.map(k => `${prefix}${k}`) } : {}), c: renameC(c.c, prefix, m, inputs) }; // the keys renamed with their side
     return { ...c, a: rename(c.a, prefix, m, inputs), b: rename(c.b, prefix, m, inputs) };
 }
 // A condition (or law) of one side, read in the composed machine.

package/dist/core/dsl.d.ts

@@ -253,7 +253,7 @@ export type MapWrite = {
         at: (key: Term) => TermLike;
     };
 };
-export declare const everyKey: (f: (key: Term) => Cond) => Cond;
+export declare const everyKey: (f: (key: Term, key2: Term, key3: Term) => Cond) => Cond;
 export declare const someKey: (f: (key: Term) => Cond, witness?: TermLike) => Cond;
 export declare class MapRef {
     readonly name: string;

package/dist/core/dsl.js

@@ -774,8 +774,15 @@ export const decimal = (places) => {
 };
 let boundCounter = 0;
 // A condition at every key: only as a whole flag (`flags: ({...}) => ({covered: everyKey(k => ...)})`), the key read
-// only as a map's key. The kernel closes it (instances where it holds, a witness where it fails).
-export const everyKey = (f) => { const key = `k$${++boundCounter}`; return new Cond({ op: 'all', key, c: f(v(key)).c }, everyOk(scope?.keys, k => f(keyTerm(k)).ok)); };
+// only as a map's key. The kernel closes it (instances where it holds, a witness where it fails). With two parameters
+// or more, at every two keys or more (`everyKey((i, j) => i.lt(j).implies(At.at(i).atMost(At.at(j))))`): each key read
+// on its own, and compared with another only plainly (i < j, i <= j, i = j); the runtimes decide it on every tuple of
+// a few keys per breakpoint, so it costs the square of the cells (the cube, over three keys).
+export const everyKey = (f) => {
+    const names = Array.from({ length: Math.max(1, f.length) }, () => `k$${++boundCounter}`), g = f;
+    const ok = (picked) => (picked.length === names.length ? g(...picked).ok : everyOk(scope?.keys, k => ok([...picked, keyTerm(k)])));
+    return new Cond({ op: 'all', key: names[0], ...(names.length > 1 ? { keys: names.slice(1) } : {}), c: g(...names.map(v)).c }, ok([]));
+};
 // Some key where f holds, in a law or a step law's conclusion (¬∀k. ¬f(k)): proven through a witness, a term naming the
 // key, given here or found by the prover among a few candidates (kernel/prove.ts).
 export const someKey = (f, witness) => {
@@ -1079,7 +1086,7 @@ function swapC(c, from, to) {
         case 'not': return { op: 'not', x: swapC(c.x, from, to) };
         case 'and':
         case 'or': return { op: c.op, xs: c.xs.map(y => swapC(y, from, to)) };
-        case 'all': return { op: 'all', key: c.key, c: swapC(c.c, from, to) };
+        case 'all': return { ...c, c: swapC(c.c, from, to) };
         case 'flag': return c;
         case '<':
         case '<=':
@@ -1170,15 +1177,15 @@ class Hoister {
     quantifier(q, bound, name) {
         const outer = bound.filter(key => namesIn(q).includes(key));
         if (outer.length)
-            throw new Error(`a condition at every key reads ${outer[0]}, a key bound outside it: two keys at once are outside the kernel`);
-        const inner = perStep(q.c);
+            throw new Error(`a condition at every key reads ${outer[0]}, a key bound outside it: two keys at once are named together (everyKey((i, j) => ...))`);
+        const inner = perStep(q.c), keys = q.keys?.length ? { keys: q.keys } : {};
         if (!inner) {
             const f = name ?? `${this.prefix}${++this.n}`;
-            this.flags[f] = { op: 'all', key: q.key, c: q.c };
+            this.flags[f] = { op: 'all', key: q.key, ...keys, c: q.c };
             return { op: 'flag', name: f };
         }
-        const truth = inner.op === 'flag' ? inner : this.quantifier(inner, [...bound, q.key]);
-        const split = (by) => this.quantifier({ op: 'all', key: q.key, c: swapC(q.c, inner, by) }, bound);
+        const truth = inner.op === 'flag' ? inner : this.quantifier(inner, [...bound, q.key, ...(q.keys ?? [])]);
+        const split = (by) => this.quantifier({ op: 'all', key: q.key, ...keys, c: swapC(q.c, inner, by) }, bound);
         return { op: 'or', xs: [{ op: 'and', xs: [truth, split(yes.c)] }, { op: 'and', xs: [{ op: 'not', x: truth }, split(no.c)] }] };
     }
 }
@@ -1211,6 +1218,8 @@ function prenex(c, what, key) {
     const walk = (d, positive) => {
         switch (d.op) {
             case 'all':
+                if (d.keys?.length)
+                    throw new Error(`${what}: a condition at every two keys in a law is the law's own keys (forall((i, j) => ...))`);
                 if (!positive)
                     return d;
                 found = true;
@@ -1456,7 +1465,7 @@ const markedE = (e) => {
         case 'prod': return { ...e, a: markedE(e.a), b: markedE(e.b) };
     }
 };
-const marked = (c) => c.op === 'flag' ? c : c.op === 'all' ? { op: 'all', key: c.key, c: marked(c.c) } : c.op === 'not' ? { op: 'not', x: marked(c.x) } : c.op === 'and' || c.op === 'or' ? { op: c.op, xs: c.xs.map(marked) } : { ...c, a: markedE(c.a), b: markedE(c.b) };
+const marked = (c) => c.op === 'flag' ? c : c.op === 'all' ? { ...c, c: marked(c.c) } : c.op === 'not' ? { op: 'not', x: marked(c.x) } : c.op === 'and' || c.op === 'or' ? { op: c.op, xs: c.xs.map(marked) } : { ...c, a: markedE(c.a), b: markedE(c.b) };
 // P params, I inputs, S state, M maps, F flags, R a history's record, Su its sums, Q its queries: each a record of the
 // values the builders hand out, grown by each call.
 export class Rule {

package/dist/core/machine.d.ts

@@ -46,6 +46,7 @@ export type C = {
 } | {
     op: 'all';
     key: string;
+    keys?: string[];
     c: C;
     witness?: E;
 };

package/dist/core/machine.js

@@ -6,7 +6,7 @@
 // Arithmetic is linear: +, −, × by a constant, min, max, if. Maps are naturals indexed by naturals, every cell starting
 // at the same value; a law about a map holds for every key x, and is proven at one arbitrary x (with the law assumed at
 // every other key the step reads).
-import { historyMachine, keyTerm, plainKey, scope } from "../kernel/kernel.js";
+import { boundOf, crossFree, historyMachine, keyTerm, plainKey, scope } from "../kernel/kernel.js";
 import { add, eq, k, le, lt, nat, scale, show, solve, sub, v } from "./solver.js";
 // A write at one key, for the parts that take no write at every key (the symbolic prover, the GPU synthesizers, the
 // hand-written shader, the first Lean export): they refuse one by name.
@@ -49,7 +49,7 @@ function keysAt(st, maps) {
 }
 const breaksCache = new WeakMap();
 function breaksOf(t, key) {
-    const hit = breaksCache.get(t);
+    const hit = breaksCache.get(t)?.get(key);
     if (hit)
         return hit;
     const out = { reads: [], cmps: [] };
@@ -70,7 +70,9 @@ function breaksOf(t, key) {
                 (Array.isArray(v) ? v : [v]).forEach(y => walk(y));
     };
     walk(t);
-    breaksCache.set(t, out);
+    if (!breaksCache.has(t))
+        breaksCache.set(t, new Map());
+    breaksCache.get(t).set(key, out);
     return out;
 }
 function breakKeys(b, env, st, m) {
@@ -103,6 +105,25 @@ function breakKeys(b, env, st, m) {
     const sorted = [...keys].sort((a, b) => a - b);
     return [...sorted, sorted.at(-1) + 1];
 }
+// A condition at every tuple of n keys: the breakpoints of each key (each read on its own, the comparisons between two
+// of them set aside) together, each case with the n - 1 keys after it. Every stretch where no read moves and no
+// comparison turns starts at one of those cases (a breakpoint, the key after one, or 0), so the keys after its start
+// place n keys there in every order they can take; keys read only as a map's key need only the cells and one past them.
+// Keys read only as a map's key and compared with each other: a read changes only at a cell, so each cell, the n keys
+// after it (the stretch up to the next cell), 0 and the n after it, and past the last cell are every case.
+function tupleKeys(c, env, st, m) {
+    const names = boundOf(c);
+    if (names.every(n => plainKey(c.c, n)))
+        return keysAt(st, mapsIn(c.c));
+    if (names.length === 1)
+        return breakKeys(breaksOf(c.c, c.key), env, st, m);
+    const body = crossFree(c.c, names);
+    if (names.every(n => plainKey(body, n)))
+        return spread([0, ...keysAt(st, mapsIn(c.c))], names.length + 1);
+    const parts = names.map(n => breaksOf(body, n));
+    return spread(breakKeys({ reads: parts.flatMap(b => b.reads), cmps: parts.flatMap(b => b.cmps) }, env, st, m), names.length);
+}
+const spread = (keys, n) => [...new Set(keys.flatMap(k => Array.from({ length: n }, (_, i) => k + i)))].sort((a, b) => a - b);
 export const naturalIn = (v, what) => {
     if (typeof v !== 'number' || !Number.isSafeInteger(v) || v < 0)
         throw new RangeError(`${what} must be a natural below 2^53, not ${String(v)}`);
@@ -189,7 +210,11 @@ export function evalC(c, env, st, m) {
         case 'or': return c.xs.some(y => evalC(y, env, st, m));
         case 'not': return !evalC(c.x, env, st, m);
         case 'flag': return env[`?${c.name}`] === 1;
-        case 'all': return (plainKey(c.c, c.key) ? keysAt(st, mapsIn(c.c)) : breakKeys(breaksOf(c.c, c.key), env, st, m)).every(key => evalC(c.c, { ...env, [c.key]: key }, st, m));
+        case 'all': {
+            const names = boundOf(c), keys = tupleKeys(c, env, st, m);
+            const go = (i, at) => (i === names.length ? evalC(c.c, at, st, m) : keys.every(key => go(i + 1, { ...at, [names[i]]: key })));
+            return go(0, env);
+        }
     }
 }
 // A write at every key: its value at each key the maps it reads hold a cell at, and its new default past them.
@@ -343,11 +368,11 @@ export function compileJs(m) {
     const { h, plain, queries, carried } = runnable(m);
     const id = (name) => JSON.stringify(name);
     const flags = Object.keys(plain.step.flags ?? {}), carriedMaps = m.inputMaps ?? [], fns = Object.keys(m.fns ?? {});
-    // A key bound by a quantified flag or a write at every key is the JS parameter k.
-    let bound;
+    // A key bound by a quantified flag or a write at every key is the JS parameter k (k1, k2 for a flag's further keys).
+    let bound = {};
     const ex = (e) => {
         switch (e.op) {
-            case 'var': return e.name === bound ? 'k' : e.name.startsWith('r.') ? `r[${id(e.name.slice(2))}]` : plain.params.includes(e.name) || plain.inputs.includes(e.name) ? `env[${id(e.name)}]` : `s[${id(e.name)}]`;
+            case 'var': return bound[e.name] ?? (e.name.startsWith('r.') ? `r[${id(e.name.slice(2))}]` : plain.params.includes(e.name) || plain.inputs.includes(e.name) ? `env[${id(e.name)}]` : `s[${id(e.name)}]`);
             case 'const': return String(e.value);
             case 'add': return `$x(${ex(e.a)} + ${ex(e.b)})`;
             case 'sub': return `Math.max(0, ${ex(e.a)} - ${ex(e.b)})`;
@@ -374,11 +399,11 @@ export function compileJs(m) {
             case 'not': return `(!${cx(c.x)})`;
             case 'flag': return `flag${flags.indexOf(c.name)}`;
             case 'all': {
-                const keys = keysJs(c.c, c.key), outer = bound;
-                bound = c.key;
+                const names = boundOf(c), ks = names.map((_, i) => (i ? `k${i}` : 'k')), keys = names.length === 1 ? keysJs(c.c, c.key) : tupleJs(c), outer = bound;
+                bound = { ...bound, ...Object.fromEntries(names.map((n, i) => [n, ks[i]])) };
                 const body = cx(c.c);
                 bound = outer;
-                return `${keys}.every(k => ${body})`;
+                return names.length === 1 ? `${keys}.every(k => ${body})` : `(ks => ${ks.map(k => `ks.every(${k} => `).join('')}${body}${')'.repeat(ks.length)})(${keys})`;
             }
         }
     };
@@ -386,10 +411,24 @@ export function compileJs(m) {
     const keysJs = (t, key) => {
         if (plainKey(t, key))
             return `$keys(maps, ${JSON.stringify(mapsIn(t).filter(mp => !fns.includes(mp)))})`;
-        const b = breaksOf(t, key), off = (o) => (o ? ex(o) : '0');
+        return breaksJs(breaksOf(t, key));
+    };
+    const breaksJs = (b) => {
+        const off = (o) => (o ? ex(o) : '0');
         return `$breaks(maps, [${b.reads.map(r => `[${id(r.map)}, ${off(r.off)}, ${r.minus}]`).join(', ')}], [${b.cmps.map(c => `[${ex(c.value)}, ${off(c.off)}, ${c.minus}]`).join(', ')}])`;
     };
-    const every = (w) => { const keys = keysJs(w.value, w.each), dense = !plainKey(w.value, w.each), outer = bound; bound = w.each; const body = ex(w.value); bound = outer; return `${dense ? '$dense' : '$every'}(${keys}, k => ${body})`; };
+    // The interpreter's tupleKeys.
+    const tupleJs = (c) => {
+        const names = boundOf(c);
+        if (names.every(n => plainKey(c.c, n)))
+            return `$keys(maps, ${JSON.stringify(mapsIn(c.c).filter(mp => !fns.includes(mp)))})`;
+        const body = crossFree(c.c, names);
+        if (names.every(n => plainKey(body, n)))
+            return `$spread([0, ...$keys(maps, ${JSON.stringify(mapsIn(c.c).filter(mp => !fns.includes(mp)))})], ${names.length + 1})`;
+        const parts = names.map(n => breaksOf(body, n));
+        return `$spread(${breaksJs({ reads: parts.flatMap(b => b.reads), cmps: parts.flatMap(b => b.cmps) })}, ${names.length})`;
+    };
+    const every = (w) => { const keys = keysJs(w.value, w.each), dense = !plainKey(w.value, w.each), outer = bound; bound = { [w.each]: 'k' }; const body = ex(w.value); bound = outer; return `${dense ? '$dense' : '$every'}(${keys}, k => ${body})`; };
     const writes = Object.entries(plain.step.maps ?? {});
     const env = (input) => `{${[...m.params.map(p => `${id(p)}: $n(params[${id(p)}], ${id(`param ${p}`)})`), ...(input ? carried.map(i => `${id(i)}: $n(input[${id(i)}], ${id(`input ${i}`)})`) : [])].join(', ')}}`;
     // Reads go through `maps` (with the maps the request carries); writes go to the state's own.
@@ -418,6 +457,7 @@ function $x(v) { if (v > 9007199254740991) throw new RangeError('a value passed
 function $m(v, what) { if (!(v instanceof Map)) throw new RangeError(what + ' must be a Map of naturals'); for (const [key, x] of v) { $n(key, 'a key of ' + what); $n(x, 'a cell of ' + what); } return v; }
 function $keys(maps, names) { const keys = new Set(); let past = 0; for (const c of Object.values(maps)) for (const key of c.keys()) past = Math.max(past, key + 1); for (const n of names) for (const key of maps[n].keys()) keys.add(key); return [...keys, past]; }
 ${fns.map((name, i) => `const fn${i} = (${m.fns[name].js});\n${m.fns[name].call ? `const fnc${i} = (${m.fns[name].call});\n` : ''}`).join('')}function $breaks(maps, reads, cmps) { const p = new Set([0]); for (const [n, d, minus] of reads) { for (const s of maps[n].keys()) { if (minus) p.add(s + d); else if (s >= d) p.add(s - d); } if (minus) p.add(d); } for (const [v, d, minus] of cmps) { if (minus) { p.add(v + d); p.add(d); } else if (v >= d) p.add(v - d); } const keys = new Set(); for (const q of p) for (let i = -1; i <= 2; i++) if (q + i >= 0) keys.add(q + i); const sorted = [...keys].sort((a, b) => a - b); sorted.push(sorted[sorted.length - 1] + 1); return sorted; }
+function $spread(keys, n) { const out = new Set(); for (const k of keys) for (let i = 0; i < n; i++) out.add(k + i); return [...out].sort((a, b) => a - b); }
 function $dense(keys, f) { const top = keys[keys.length - 1]; if (top > 1000000) throw new RangeError('a write at every key reads its key in arithmetic past a million keys (' + top + ')'); const d = f(top), cells = new Map(); for (let k = 0; k < top; k++) { const v = f(k); if (v !== d) cells.set(k, v); } return {cells, d}; }
 function $every(keys, f) { const past = keys[keys.length - 1], d = f(past), cells = new Map(); for (let i = 0; i < keys.length - 1; i++) { const v = f(keys[i]); if (v !== d) cells.set(keys[i], v); } return {cells, d}; }
 export function init(params) {

package/dist/core/solver.d.ts

@@ -2,6 +2,18 @@ export type Lin = Record<string, number>;
 export type Constraint = {
     lin: Lin;
     label: string;
+    src?: RowSrc;
+};
+export type RowSrc = {
+    atom: number;
+} | {
+    fact: number;
+} | {
+    nat: string;
+} | {
+    pair: [string, string];
+} | {
+    term: string;
 };
 export declare const v: (name: string) => Lin;
 export declare const k: (value: number) => Lin;

package/dist/core/solver.js

@@ -54,7 +54,8 @@ export const nat = (...names) => names.flatMap(name => le(k(0), v(name), `${name
 export const negate = (c) => ({ lin: add(k(1), scale(c.lin, -1)), label: `not (${c.label})` });
 const gcd = (a, b) => (b === 0 ? Math.abs(a) : gcd(b, a % b));
 const vars = (lin) => Object.keys(lin).filter(key => key !== '1');
-// maxRows: elimination can square the rows each round; past this many live rows it gives up with `unknown`.
+// maxRows: elimination can square the rows each round; past this many live rows, or a round that would make more than
+// five times as many before merging them, it gives up with `unknown`.
 export function solve(constraints, maxRows = 20_000) {
     const steps = [];
     const lins = [];
@@ -62,26 +63,41 @@ export function solve(constraints, maxRows = 20_000) {
     // A row after its cut, if its variables share a divisor.
     const tighten = (index) => {
         const lin = lins[index];
-        const g = vars(lin).reduce((acc, key) => gcd(acc, lin[key]), 0);
+        let g = 0;
+        for (const key in lin)
+            if (key !== '1') {
+                g = gcd(g, lin[key]);
+                if (g === 1)
+                    return index;
+            }
         if (g <= 1)
             return index;
-        const cut = Object.fromEntries(vars(lin).map(key => [key, lin[key] / g]));
+        const cut = {};
+        for (const key in lin)
+            if (key !== '1')
+                cut[key] = lin[key] / g;
         const constant = Math.ceil((lin['1'] ?? 0) / g);
         return push({ kind: 'cut', of: index, g }, add(cut, k(constant)));
     };
     let rows = constraints.map((c, index) => tighten(push({ kind: 'input', index }, c.lin)));
-    const contradiction = () => rows.find(r => vars(lins[r]).length === 0 && (lins[r]['1'] ?? 0) > 0);
+    // A row with no variable and a positive constant (kept per row: a row never changes once pushed).
+    const contra = [];
+    const isContra = (r) => (contra[r] ??= (lins[r]['1'] ?? 0) > 0 && Object.keys(lins[r]).every(key => key === '1'));
+    const contradiction = () => rows.find(isContra);
     const eliminated = [];
     let exact = true;
     // Equalities first: a pair of rows that are each other's negation, with a variable of coefficient ±1, defines that
     // variable. Substituting it into every other row (a combination with one row of the pair) eliminates it exactly,
     // with |rows| new rows instead of the |pos| × |neg| of a plain elimination.
+    // A row's key and its negation's, kept per row (a row never changes once pushed).
+    const keyOf = (lin) => JSON.stringify(Object.entries(lin).sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)));
+    const keys = [], negKeys = [];
+    const key = (r) => (keys[r] ??= keyOf(lins[r])), negKey = (r) => (negKeys[r] ??= keyOf(scale(lins[r], -1)));
     for (let changed = true; changed && contradiction() === undefined;) {
         changed = false;
-        const key = (lin) => JSON.stringify(Object.entries(lin).sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)));
-        const byKey = new Map(rows.map(r => [key(lins[r]), r]));
+        const byKey = new Map(rows.map(r => [key(r), r]));
         for (const r of rows) {
-            const neg = byKey.get(key(scale(lins[r], -1)));
+            const neg = byKey.get(negKey(r));
             if (neg === undefined || neg === r)
                 continue;
             const x = vars(lins[r]).find(name => Math.abs(lins[r][name]) === 1);
@@ -105,17 +121,52 @@ export function solve(constraints, maxRows = 20_000) {
             break;
         }
     }
+    const sigs = [];
+    const sigOf = (r) => {
+        let sig = sigs[r];
+        if (sig === undefined) {
+            const lin = lins[r], keys = [];
+            for (const key in lin)
+                if (key !== '1')
+                    keys.push(key);
+            keys.sort();
+            sig = JSON.stringify(keys.map(key => [key, lin[key]]));
+            sigs[r] = sig;
+        }
+        return sig;
+    };
     for (let found = contradiction(); found === undefined; found = contradiction()) {
-        const remaining = [...new Set(rows.flatMap(r => vars(lins[r])))];
-        if (remaining.length === 0)
+        // Each variable's rows by sign, in one pass (variables in the order they first appear).
+        const index = new Map();
+        for (const r of rows)
+            for (const [x, c] of Object.entries(lins[r])) {
+                if (x === '1')
+                    continue;
+                let e = index.get(x);
+                if (!e)
+                    index.set(x, (e = { pos: [], neg: [], posUnit: true, negUnit: true }));
+                if (c > 0) {
+                    e.pos.push(r);
+                    e.posUnit &&= c === 1;
+                }
+                else if (c < 0) {
+                    e.neg.push(r);
+                    e.negUnit &&= c === -1;
+                }
+            }
+        if (index.size === 0)
             break;
-        // Eliminate the variable that makes the fewest new rows, preferring exact eliminations.
-        const cost = (x) => {
-            const pos = rows.filter(r => (lins[r][x] ?? 0) > 0), neg = rows.filter(r => (lins[r][x] ?? 0) < 0);
-            const isExact = pos.every(p => lins[p][x] === 1) || neg.every(n => lins[n][x] === -1);
-            return { x, pos, neg, isExact, size: pos.length * neg.length - pos.length - neg.length };
-        };
-        const choice = remaining.map(cost).sort((a, b) => Number(b.isExact) - Number(a.isExact) || a.size - b.size)[0];
+        // Eliminate the variable that makes the fewest new rows, preferring exact eliminations (the first such).
+        let choice;
+        for (const [x, e] of index) {
+            const c = { x, pos: e.pos, neg: e.neg, isExact: e.posUnit || e.negUnit, size: e.pos.length * e.neg.length - e.pos.length - e.neg.length };
+            if (!choice || (c.isExact && !choice.isExact) || (c.isExact === choice.isExact && c.size < choice.size))
+                choice = c;
+        }
+        if (!choice)
+            break;
+        if (choice.pos.length * choice.neg.length > 5 * maxRows)
+            return { kind: 'unknown' };
         exact &&= choice.isExact;
         eliminated.push({ x: choice.x, rows: [...choice.pos, ...choice.neg] });
         const next = rows.filter(r => (lins[r][choice.x] ?? 0) === 0);
@@ -129,7 +180,7 @@ export function solve(constraints, maxRows = 20_000) {
         // say nothing.
         const best = new Map();
         for (const r of next) {
-            const lin = lins[r], sig = JSON.stringify(vars(lin).sort().map(key => [key, lin[key]]));
+            const lin = lins[r], sig = sigOf(r);
             if (sig === '[]' && (lin['1'] ?? 0) <= 0)
                 continue;
             const seen = best.get(sig);

package/dist/kernel/kernel.d.ts

@@ -29,10 +29,19 @@ export declare function truth(c: C, path: Path): boolean | undefined;
 export declare function facts(c: C, path: Path, positive?: boolean): Lin[];
 export declare function leafConstraints(goal: Goal, path: Path): Constraint[];
 export declare function leafConstraintsReusing(goal: Goal, path: Path): Constraint[];
-type Seen<T> = {
-    reads: [string, boolean | undefined][];
+type Decisions = [string, boolean | undefined][];
+type Node<T> = {
+    at: number;
+    key: string;
+    next: Map<boolean | undefined, Node<T>>;
+} | {
+    reads: Decisions;
     out: T;
-}[];
+};
+export type Seen<T> = {
+    root?: Node<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 check(goal: Goal, tree: Tree, path?: Path): boolean;
@@ -45,6 +54,13 @@ export declare function substE(e: E, s: Subst): E;
 export declare function substC(c: C, s: Subst): C;
 export type Instances = Record<string, E[]>;
 export declare const stateName: (n: string, j: number) => string;
+export declare const boundOf: (c: Extract<C, {
+    op: "all";
+}>) => string[];
+export declare const witnessesOf: (f: string, q: Extract<C, {
+    op: "all";
+}>) => string[];
+export declare const crossFree: (c: C, keys: string[]) => C;
 export declare const assumed: (laws: Law[], instances: Instances) => C[];
 export declare function scope(m: Machine, laws?: Law[]): void;
 export declare const keyTerm: (e: E, key: string) => boolean;