gdp-wired 0.2.0 → 0.3.0

package/dist/core/machine.js

@@ -6,8 +6,14 @@
 // 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, scope } from "../kernel/kernel.js";
+import { 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.
+export const pointWrite = (w, where) => { if ('each' in w)
+    throw new Error(`${where} takes no write at every key`); return w; };
+// The same for a quantified flag.
+export const noQuantifier = (where) => { throw new Error(`${where} takes no quantified flag`); };
 export { unreachable } from "../kernel/kernel.js";
 // Builders.
 export const x = (name) => ({ op: 'var', name });
@@ -27,6 +33,76 @@ 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)));
+// 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]))];
+function keysAt(st, maps) {
+    const keys = new Set();
+    let past = 0;
+    for (const cells of Object.values(st.maps))
+        for (const key of cells.keys())
+            past = Math.max(past, key + 1);
+    for (const map of maps)
+        for (const key of st.maps[map]?.keys() ?? [])
+            keys.add(key);
+    return [...keys, past];
+}
+const breaksCache = new WeakMap();
+function breaksOf(t, key) {
+    const hit = breaksCache.get(t);
+    if (hit)
+        return hit;
+    const out = { reads: [], cmps: [] };
+    const termOf = (e) => (e.op === 'var' ? { minus: false } : e.op === 'add' ? { off: e.a.op === 'var' && e.a.name === key ? e.b : e.a, minus: false } : { off: e.b, minus: true });
+    const walk = (u) => {
+        if (u.op === 'get' && keyTerm(u.key, key)) {
+            out.reads.push({ map: u.map, ...termOf(u.key) });
+            return;
+        }
+        if ((u.op === '<' || u.op === '<=' || u.op === '=') && (keyTerm(u.a, key) || keyTerm(u.b, key))) {
+            const [kt, other] = keyTerm(u.a, key) ? [u.a, u.b] : [u.b, u.a];
+            out.cmps.push({ value: other, ...termOf(kt) });
+            walk(other);
+            return;
+        }
+        for (const v of Object.values(u))
+            if (v && typeof v === 'object')
+                (Array.isArray(v) ? v : [v]).forEach(y => walk(y));
+    };
+    walk(t);
+    breaksCache.set(t, out);
+    return out;
+}
+function breakKeys(b, env, st, m) {
+    const points = new Set([0]);
+    for (const r of b.reads) {
+        const d = r.off ? evalE(r.off, env, st, m) : 0;
+        for (const s of st.maps[r.map]?.keys() ?? []) {
+            if (r.minus)
+                points.add(s + d);
+            else if (s >= d)
+                points.add(s - d);
+        }
+        if (r.minus)
+            points.add(d);
+    }
+    for (const c of b.cmps) {
+        const v = evalE(c.value, env, st, m), d = c.off ? evalE(c.off, env, st, m) : 0;
+        if (c.minus) {
+            points.add(v + d);
+            points.add(d);
+        }
+        else if (v >= d)
+            points.add(v - d);
+    }
+    const keys = new Set();
+    for (const p of points)
+        for (let i = -1; i <= 2; i++)
+            if (p + i >= 0)
+                keys.add(p + i);
+    const sorted = [...keys].sort((a, b) => a - b);
+    return [...sorted, sorted.at(-1) + 1];
+}
 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)}`);
@@ -53,9 +129,24 @@ export function evalE(e, env, st, m) {
         case 'min': return Math.min(evalE(e.a, env, st, m), evalE(e.b, 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': return st.maps[e.map].get(evalE(e.key, env, st, m)) ?? m.maps[e.map];
+        case 'get': {
+            const key = evalE(e.key, env, st, m), fn = m.fns?.[e.map];
+            return fn ? naturalIn(fnOf(fn)(key), `${e.map}(${key})`) : st.maps[e.map].get(key) ?? st.defaults?.[e.map] ?? m.maps[e.map];
+        }
     }
 }
+// A function's value at a key (the GPU search tabulates functions with it).
+export const fnValue = (fn, key) => naturalIn(fnOf(fn)(key), `a function at ${key}`);
+// A function's JavaScript, compiled once.
+const compiledFns = new WeakMap();
+const fnOf = (fn) => {
+    let f = compiledFns.get(fn);
+    if (!f) {
+        f = compileFunction(['k'], `return (${fn.js})(k)`);
+        compiledFns.set(fn, f);
+    }
+    return f;
+};
 export function evalC(c, env, st, m) {
     switch (c.op) {
         case '<': return evalE(c.a, env, st, m) < evalE(c.b, env, st, m);
@@ -65,7 +156,33 @@ 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));
+    }
+}
+// A write at every key: its value at each key the maps it reads hold a cell at, and its new default past them.
+// With the key in key terms, every key up to the last breakpoint is computed (the stretches between breakpoints hold the
+// same value, which need not be the default), and past it the value is the new default.
+function writeEvery(w, env, st, m) {
+    if (!plainKey(w.value, w.each)) {
+        const top = breakKeys(breaksOf(w.value, w.each), env, st, m).at(-1);
+        if (top > 1_000_000)
+            throw new RangeError(`a write at every key reads its key in arithmetic past a million keys (${top})`);
+        const fallback = evalE(w.value, { ...env, [w.each]: top }, st, m), cells = new Map();
+        for (let key = 0; key < top; key++) {
+            const v = evalE(w.value, { ...env, [w.each]: key }, st, m);
+            if (v !== fallback)
+                cells.set(key, v);
+        }
+        return { cells, default: fallback };
+    }
+    const keys = keysAt(st, mapsIn(w.value)), past = keys.at(-1);
+    const fallback = evalE(w.value, { ...env, [w.each]: past }, st, m), cells = new Map();
+    for (const key of keys.slice(0, -1)) {
+        const v = evalE(w.value, { ...env, [w.each]: key }, st, m);
+        if (v !== fallback)
+            cells.set(key, v);
     }
+    return { cells, default: fallback };
 }
 // The machine a runtime steps (with a history, kernel.ts's plain machine), its queries, and the inputs a request carries.
 function runnable(m) {
@@ -77,6 +194,26 @@ function runnable(m) {
     return { h, plain, queries, carried: m.inputs.filter(i => !queries.includes(i)) };
 }
 const empty = { scalars: {}, maps: {} };
+// The state as a step reads it: with the maps the request carries (cells past them read 0), each checked natural.
+export function carriedView(m, st, input, rename = map => map) {
+    if (!m.inputMaps?.length)
+        return st;
+    const maps = { ...st.maps }, defaults = { ...st.defaults };
+    for (const map of m.inputMaps) {
+        const cells = input[map];
+        if (!(cells instanceof Map))
+            throw new RangeError(`input ${map} must be a Map of naturals`);
+        for (const [key, v] of cells) {
+            naturalIn(key, `a key of ${map}`);
+            naturalIn(v, `a cell of ${map}`);
+        }
+        maps[rename(map)] = cells;
+        defaults[rename(map)] = 0;
+    }
+    return { ...st, maps, defaults };
+}
+// A request's numbers (its inputs), without the maps it carries.
+export const numbersOf = (input) => Object.fromEntries(Object.entries(input).filter((e) => typeof e[1] === 'number'));
 // The interpreter: persistent (a step leaves the state it was given as it was), so searches can branch from any state.
 export function interpret(m) {
     const { h, plain, carried } = runnable(m);
@@ -89,6 +226,7 @@ export function interpret(m) {
                 env[i] = naturalIn(input[i], `input ${i}`);
         return env;
     };
+    const viewed = (st, input) => carriedView(m, st, input);
     // The records a request's queries read: with pruning, those not yet spent at its order.
     const live = (env, st) => {
         const records = st.history;
@@ -134,8 +272,8 @@ export function interpret(m) {
             ordered(env, st);
             return queriesOf(env, live(env, st));
         },
-        step: (params, st, input) => {
-            const env = args(params, input);
+        step: (params, given, input) => {
+            const env = args(params, input), st = viewed(given, input);
             let records = [];
             if (h) {
                 ordered(env, st);
@@ -147,12 +285,19 @@ export function interpret(m) {
             const scalars = { ...st.scalars };
             for (const [name, e] of Object.entries(plain.step.state ?? {}))
                 scalars[name] = evalE(e, env, st, plain);
-            const writes = Object.entries(plain.step.maps ?? {}).map(([name, { key, value }]) => [name, evalE(key, env, st, plain), evalE(value, env, st, plain)]);
-            const maps = Object.fromEntries(Object.entries(st.maps).map(([name, cells]) => [name, new Map(cells)]));
-            for (const [name, key, value] of writes)
-                maps[name].set(key, value);
+            const writes = Object.entries(plain.step.maps ?? {}).map(([name, w]) => [name, 'each' in w ? writeEvery(w, env, st, plain) : { key: evalE(w.key, env, st, plain), value: evalE(w.value, env, st, plain) }]);
+            const maps = Object.fromEntries(Object.entries(given.maps).map(([name, cells]) => [name, new Map(cells)]));
+            const defaults = { ...given.defaults };
+            for (const [name, w] of writes)
+                if ('cells' in w) {
+                    maps[name] = w.cells;
+                    defaults[name] = w.default;
+                }
+                else
+                    maps[name].set(w.key, w.value);
+            const withDefaults = Object.keys(defaults).length ? { defaults } : {};
             if (!h)
-                return { scalars, maps };
+                return { scalars, maps, ...withDefaults };
             const kept = evalC(h.keep, env, st, plain);
             return { scalars, maps, history: kept ? [...records, Object.fromEntries(h.record.map(f => [f, env[f]]))] : records, ...(h.prune ? { last: env[h.prune.order] } : {}) };
         },
@@ -164,10 +309,12 @@ export function interpret(m) {
 export function compileJs(m) {
     const { h, plain, queries, carried } = runnable(m);
     const id = (name) => JSON.stringify(name);
-    const flags = Object.keys(plain.step.flags ?? {});
+    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;
     const ex = (e) => {
         switch (e.op) {
-            case 'var': return 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 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 '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)})`;
@@ -176,7 +323,7 @@ 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 `(maps[${id(e.map)}].get(${ex(e.key)}) ?? ${plain.maps[e.map]})`;
+            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]}`})`;
         }
     };
     const cx = (c) => {
@@ -188,11 +335,27 @@ export function compileJs(m) {
             case 'or': return `(${c.xs.map(cx).join(' || ')})`;
             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 body = cx(c.c);
+                bound = outer;
+                return `${keys}.every(k => ${body})`;
+            }
         }
     };
+    // The keys a quantifier or a write at every key is decided on (the interpreter's keysAt, or its breakKeys).
+    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 `$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})`; };
     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(', ')}}`;
-    const lines = [`const env = ${env(true)}, s = state.scalars, maps = state.maps;`];
+    // Reads go through `maps` (with the maps the request carries); writes go to the state's own.
+    const lines = [`const env = ${env(true)}, s = state.scalars, dft = {...state.defaults}, maps = ${carriedMaps.length ? `{...state.maps, ${carriedMaps.map(mp => `${id(mp)}: $m(input[${id(mp)}], ${id(`input ${mp}`)})`).join(', ')}}` : 'state.maps'};`];
     if (h) {
         lines.push('const records = state.history;', 'let head = state.head;');
         if (h.prune) {
@@ -201,33 +364,39 @@ export function compileJs(m) {
         }
         lines.push(`let ${queries.map((_, i) => `q${i} = 0`).join(', ')};`, `for (let i = head; i < records.length; i++) { const r = records[i]; ${queries.map((q, i) => `q${i} = $x(q${i} + ${ex(h.queries[q])});`).join(' ')} }`, ...queries.map((q, i) => `env[${id(q)}] = q${i};`));
     }
-    lines.push(...flags.map((name, i) => `const flag${i} = ${cx(plain.step.flags[name])};`), `const scalars = {...s, ${Object.entries(plain.step.state ?? {}).map(([name, e]) => `${id(name)}: ${ex(e)}`).join(', ')}};`, ...writes.map(([, { key, value }], i) => `const key${i} = ${ex(key)}, value${i} = ${ex(value)};`));
+    lines.push(...flags.map((name, i) => `const flag${i} = ${cx(plain.step.flags[name])};`), `const scalars = {...s, ${Object.entries(plain.step.state ?? {}).map(([name, e]) => `${id(name)}: ${ex(e)}`).join(', ')}};`, ...writes.map(([, w], i) => ('each' in w ? `const write${i} = ${every(w)};` : `const key${i} = ${ex(w.key)}, value${i} = ${ex(w.value)};`)));
     if (h)
         lines.push(`const keep = ${cx(h.keep)};`);
-    lines.push(...writes.map(([name], i) => `maps[${id(name)}].set(key${i}, value${i});`));
+    lines.push(...writes.map(([name, w], i) => ('each' in w ? `state.maps[${id(name)}] = write${i}.cells; dft[${id(name)}] = write${i}.d;` : `state.maps[${id(name)}].set(key${i}, value${i});`)));
     if (h)
         lines.push(`if (keep) records.push({${h.record.map(f => `${id(f)}: env[${id(f)}]`).join(', ')}});`, 
         // Drop the spent prefix now and then, not every step: amortized, each record is moved a bounded number of times.
-        'if (head > 1024 && 2 * head > records.length) { records.splice(0, head); head = 0; }', `return {scalars, maps, history: records, head${h.prune ? ', last: order' : ''}};`);
+        'if (head > 1024 && 2 * head > records.length) { records.splice(0, head); head = 0; }', `return {scalars, maps: state.maps, history: records, head${h.prune ? ', last: order' : ''}};`);
     else
-        lines.push('return {scalars, maps};');
+        lines.push('return Object.keys(dft).length ? {scalars, maps: state.maps, defaults: dft} : {scalars, maps: state.maps};');
     return `// Generated from the machine ${m.name}. step consumes its state: keep the one it returns (fork to branch).
 function $n(v, what) { if (typeof v !== 'number' || !Number.isSafeInteger(v) || v < 0) throw new RangeError(what + ' must be a natural below 2^53, not ' + v); return 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; }
+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) {
   const env = ${env(false)}, s = {};
   return {scalars: {${Object.entries(plain.state).map(([name, e]) => `${id(name)}: ${ex(e)}`).join(', ')}}, maps: {${Object.keys(plain.maps ?? {}).map(name => `${id(name)}: new Map()`).join(', ')}}${h ? ', history: [], head: 0' : ''}};
 }
 export function fork(state) {
-  return {scalars: {...state.scalars}, maps: Object.fromEntries(Object.entries(state.maps).map(([name, cells]) => [name, new Map(cells)]))${h ? ', history: state.history.slice(state.head), head: 0, last: state.last' : ''}};
+  return {scalars: {...state.scalars}, maps: Object.fromEntries(Object.entries(state.maps).map(([name, cells]) => [name, new Map(cells)])), ...(state.defaults ? {defaults: {...state.defaults}} : {})${h ? ', history: state.history.slice(state.head), head: 0, last: state.last' : ''}};
 }
 export function step(params, state, input) {
   ${lines.join('\n  ')}
 }
 `;
 }
-// Generated code as a function. Every caller passes source this library generated from its own terms, never from data,
-// which is what makes compiling it safe; the lint's implied-eval rule is waived here and nowhere else.
+// Generated code as a function. Every caller passes source this library generated from its own terms, or a function's
+// `js` the rule's author wrote (code, as the rule itself is), never data; the lint's implied-eval rule is waived here
+// and nowhere else.
 export function compileFunction(params, body) {
     // oxlint-disable-next-line typescript/no-implied-eval
     return new Function(...params, body);
@@ -279,6 +448,7 @@ function symE(e, s) {
 // The cases in which c has the given truth value.
 function symC(c, s, truth) {
     switch (c.op) {
+        case 'all': throw new Error('the symbolic prover takes no quantified flag (the kernel does)');
         case '<':
         case '<=':
         case '=':
@@ -318,7 +488,7 @@ function feasible(cases) {
 function readsOf(c) {
     const inE = (e) => e.op === 'get' ? [{ map: e.map, key: e.key }, ...inE(e.key)]
         : e.op === 'if' ? [...readsOfC(e.c), ...inE(e.then), ...inE(e.else)] : 'a' in e ? [...inE(e.a), ...('b' in e ? inE(e.b) : [])] : [];
-    const readsOfC = (y) => y.op === 'flag' ? [] : y.op === 'not' ? readsOfC(y.x) : y.op === 'and' || y.op === 'or' ? y.xs.flatMap(readsOfC) : [...inE(y.a), ...inE(y.b)];
+    const readsOfC = (y) => y.op === 'flag' || y.op === 'all' ? [] : y.op === 'not' ? readsOfC(y.x) : y.op === 'and' || y.op === 'or' ? y.xs.flatMap(readsOfC) : [...inE(y.a), ...inE(y.b)];
     return readsOfC(c);
 }
 const keyLin = (e, names) => symE(e, { names, reads: noReads })[0].value;
@@ -389,7 +559,7 @@ export function prove(m, goal, invariants = [goal]) {
     const stepReads = [
         ...Object.values(m.step.flags ?? {}).flatMap(readsOf),
         ...Object.values(m.step.state ?? {}).flatMap(e => readsOf({ op: '=', a: e, b: e })),
-        ...Object.entries(m.step.maps ?? {}).flatMap(([map, w]) => [{ map, key: w.key }, ...readsOf({ op: '=', a: w.value, b: w.value })]),
+        ...Object.entries(m.step.maps ?? {}).flatMap(([map, w]) => [...('each' in w ? [] : [{ map, key: w.key }]), ...readsOf({ op: '=', a: w.value, b: w.value })]),
     ];
     const pairs = new Map();
     for (const r of stepReads) {
@@ -424,6 +594,8 @@ export function prove(m, goal, invariants = [goal]) {
             cases = feasible(cross(cases, acc => {
                 if (write === undefined)
                     return [{ path: [], value: { ...acc, [`${f.cell}'`]: v(f.cell) } }];
+                if ('each' in write)
+                    throw new Error('the symbolic prover takes no write at every key (the kernel does)');
                 return cross(symE(write.key, preSymF), key => {
                     const decided = preSymF.decided?.[`${show(key)}|${show(f.key)}`];
                     const written = () => symE(write.value, preSymF).map(val => ({ path: [...val.path, ...(decided ? [] : eq(key, f.key))], value: { ...acc, [`${f.cell}'`]: val.value } }));

package/dist/kernel/kernel.d.ts

@@ -25,14 +25,17 @@ export declare function facts(c: C, path: Path, positive?: boolean): Lin[];
 export declare function leafConstraints(goal: Goal, path: Path): Constraint[];
 export declare function withProducts(rows: Constraint[], pairs: [number, number][]): Constraint[];
 export declare function check(goal: Goal, tree: Tree, path?: Path): boolean;
-type Subst = {
+export type Subst = {
     vars: Record<string, E>;
     maps: Record<string, (key: E) => E>;
     flags: Record<string, C>;
 };
+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 function scope(m: Machine, laws?: Law[]): void;
+export declare const keyTerm: (e: E, key: string) => boolean;
+export declare const plainKey: (t: E | C, key: string) => boolean;
 export declare function historyMachine(m: Machine): {
     machine: Machine;
     goals: Goal[];
@@ -59,11 +62,35 @@ export declare function progressObligations(m: Machine, laws: Law[], instances:
     then: C;
     request: Record<string, E>;
 }): Goal[];
+export type Helpful = {
+    when?: C;
+    request: Record<string, E>;
+};
+export type Liveness = {
+    name: string;
+    from: C;
+    to: C;
+    rank: E | E[];
+    request?: Record<string, E>;
+    helpful?: Helpful[];
+};
+export declare const trueC: C, falseC: C;
+export declare const livenessRanks: (l: Liveness) => E[];
+export declare const livenessHelpful: (l: Liveness) => {
+    when: C;
+    request: Record<string, E>;
+}[];
+export declare function livenessParts(m: Machine, l: Liveness): {
+    stay: StepLaw;
+    cover: StepLaw;
+    helps: StepLaw[];
+};
 export type StepLaw = {
     name: string;
     when?: C | C[];
     then: C;
     forall?: string;
+    keys?: string[];
     steps?: number;
 };
 export declare function stepLawObligations(machine: Machine, laws: Law[], instances: Instances, sl: StepLaw): Goal[];
@@ -73,6 +100,7 @@ export declare function checkStepLaws(m: Machine, laws: Law[], stepLaws: StepLaw
         trees: Record<string, Tree>;
     };
     instances: Instances;
+    perStep?: Record<string, Instances>;
     trees: Record<string, Tree>;
 }): boolean;
 export type Fold = {
@@ -85,4 +113,3 @@ export type Fold = {
     assume?: C;
 };
 export declare function foldObligations(f: Fold, laws: Law[]): Goal[];
-export {};