gdp-wired 0.10.1 → 0.12.0

package/dist/core/gdp.js

@@ -21,7 +21,7 @@ export function guard(prover, fn, field, opts) {
     if (m.pre && !evalC(m.pre, ps, { scalars: {}, maps: {} }, m))
         throw new Error(`${fn.name}: the params ${JSON.stringify(params)} don't meet its precondition`);
     return (args, ...about) => {
-        const input = r.encodeInput(args);
+        const input = r.encodeInput(args, params);
         if (m.assume && !evalC(m.assume, { ...ps, ...input }, { scalars: {}, maps: {} }, m))
             return null;
         return atPath(fn.run(args, params), field) === true ? prover.prove(...about) : null;
@@ -46,7 +46,7 @@ export function gate(prover, r, flag, opts) {
     let st = opts.state ?? compiled.init(ps);
     return {
         request: (args, ...about) => {
-            const input = r.encodeInput(args);
+            const input = r.encodeInput(args, params);
             if (!allowed(m, run, ps, st, input))
                 return null;
             const granted = requestEnv(m, run, ps, st, input)[`?${flag}`] === 1;

package/dist/core/machine.d.ts

@@ -46,6 +46,7 @@ export type C = {
 } | {
     op: 'all';
     key: string;
+    keys?: string[];
     c: C;
     witness?: E;
 };
@@ -71,6 +72,8 @@ export type Fn = {
     js: string;
     lean?: string;
     recur?: Recurrence;
+    arity?: number;
+    call?: string;
 };
 export type Recurrence = {
     args: string[];
@@ -162,6 +165,7 @@ export type Request = Record<string, number | ReadonlyMap<number, number>>;
 export declare const naturalIn: (v: unknown, what: string) => number;
 export declare function evalE(e: E, env: Env, st: State, m: Machine): number;
 export declare const fnValue: (fn: Fn, key: number) => number;
+export declare function pairedArgs(key: E, n: number): E[] | undefined;
 export declare function evalC(c: C, env: Env, st: State, m: Machine): boolean;
 export declare function carriedView(m: Machine, st: State, input: Request, rename?: (map: string) => string): State;
 export declare const numbersOf: (input: Request) => Record<string, number>;

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