gdp-wired 0.3.0 → 0.5.0

package/dist/core/watch.d.ts

@@ -0,0 +1,14 @@
+import { type Law, type Machine, type Request, type State, type interpret } from './machine.js';
+import type { StepLaw } from '../kernel/kernel.js';
+export type Watched = Law | StepLaw;
+export declare const isStepLaw: (w: Watched) => w is StepLaw;
+type Runtime = ReturnType<typeof interpret>;
+type Env = Record<string, number>;
+export declare function requestEnv(m: Machine, run: Runtime, params: Env, st: State, input: Request): Env;
+export declare const allowed: (m: Machine, run: Runtime, params: Env, st: State, input: Request) => boolean;
+export declare const keysOf: (bound: number, ...states: State[]) => number[];
+export declare function watch(m: Machine, run: Runtime, w: Watched, params: Env, bound: number): {
+    start: (st: State) => boolean;
+    step: (_before: State, _input: Request, after: State) => boolean;
+};
+export {};

package/dist/core/watch.js

@@ -0,0 +1,78 @@
+// A law or a step law read off one run as it happens: the concrete side of kernel.ts's goals. The same description
+// (a Law, or a StepLaw with its `steps`, `when` and `then`) is proven about every run by the kernel, searched for a
+// breaking run by Handwired (research/hw/compile.ts), and read here on one run: the examples' random runs (examples/harness.ts),
+// the replay of every counterexample the search finds, and the reference the Handwired search is checked against.
+//
+// A law holds at the start and after every step (at every key, for a law about every key). A step law over k steps holds
+// at every k steps in a row the run takes: each step's `when` read with the state it starts from, its request, queries
+// and flags; `then` with the state before the first step (plain names), the first request and its flags, the j-th
+// request as input@j, and the state and maps after the last step (primed names).
+import { carriedView, evalC, numbersOf } from "./machine.js";
+export const isStepLaw = (w) => 'then' in w;
+// A request's environment: the params, its inputs and queries, and the step's flags decided (as ?name).
+export function requestEnv(m, run, params, st, input) {
+    const env = { ...params, ...numbersOf(input), ...run.queries(params, st, input) }, seen = carriedView(m, st, input);
+    for (const [name, c] of Object.entries(m.step.flags ?? {}))
+        env[`?${name}`] = evalC(c, env, seen, m) ? 1 : 0;
+    return env;
+}
+// Whether the machine allows the request: its assumption, read with the queries and flags.
+// A request whose order goes back (with a pruned history) is one the runtimes refuse.
+export const allowed = (m, run, params, st, input) => {
+    const order = m.history?.prune?.order;
+    if (order !== undefined && st.last !== undefined && input[order] < st.last)
+        return false;
+    return !m.assume || evalC(m.assume, requestEnv(m, run, params, st, input), carriedView(m, st, input), m);
+};
+// The keys a law about every key is read at: 0 to bound + 1, and every key a map holds.
+export const keysOf = (bound, ...states) => {
+    const keys = new Set(Array.from({ length: bound + 2 }, (_, i) => i));
+    for (const st of states)
+        for (const cells of Object.values(st.maps))
+            for (const key of cells.keys())
+                keys.add(key);
+    return [...keys];
+};
+// Watches one law or step law along one run: `start` with the state at the start, `step` after each step the run takes
+// (the state before, the request, the state after). Each says whether the law still holds.
+export function watch(m, run, w, params, bound) {
+    // At every tuple of the keys, one key per name.
+    const atKeys = (forall, keys, f, more = []) => {
+        const names = forall ? [forall, ...more] : [];
+        const go = (i, env) => (i === names.length ? f(env) : keys.every(key => go(i + 1, { ...env, [names[i]]: key })));
+        return go(0, {});
+    };
+    if (!isStepLaw(w)) {
+        const holds = (st) => atKeys(w.forall, keysOf(bound, st), extra => evalC(w.holds, { ...params, ...extra }, st, m), w.keys);
+        return { start: holds, step: (_before, _input, after) => holds(after) };
+    }
+    const k = w.steps ?? 1, whens = w.when === undefined ? [] : Array.isArray(w.when) ? w.when : [w.when];
+    // `then` reads a primed map's cells and initial value as its own map's.
+    const primedMaps = { ...m, maps: { ...m.maps, ...Object.fromEntries(Object.entries(m.maps ?? {}).map(([n, init]) => [`${n}'`, init])) } };
+    const window = [];
+    return {
+        start: (_st) => true,
+        step: (before, input, after) => {
+            window.push({ before, input, after });
+            if (window.length > k)
+                window.shift();
+            if (window.length < k)
+                return true;
+            const envs = window.map(t => requestEnv(m, run, params, t.before, t.input));
+            if (whens.some((c, j) => !evalC(c, envs[j], carriedView(m, window[j].before, window[j].input), m)))
+                return true;
+            const env = { ...envs[0] };
+            window.slice(1).forEach((t, j) => { for (const i of m.inputs)
+                env[`${i}@${j + 2}`] = envs[j + 1][i]; });
+            // The first state with the first request's maps; each later request's maps as map@j; the last state primed.
+            let first = carriedView(m, window[0].before, window[0].input);
+            window.slice(1).forEach((t, j) => { first = carriedView(m, first, t.input, map => `${map}@${j + 2}`); });
+            const both = {
+                scalars: { ...first.scalars, ...Object.fromEntries(Object.entries(after.scalars).map(([n, v]) => [`${n}'`, v])) },
+                maps: { ...first.maps, ...Object.fromEntries(Object.entries(after.maps).map(([n, cells]) => [`${n}'`, cells])) },
+                defaults: { ...first.defaults, ...Object.fromEntries(Object.entries(after.defaults ?? {}).map(([n, d]) => [`${n}'`, d])) },
+            };
+            return atKeys(w.forall, keysOf(bound, first, after), extra => evalC(w.then, { ...env, ...extra }, both, primedMaps), w.keys);
+        },
+    };
+}

package/dist/kernel/kernel.d.ts

@@ -20,6 +20,10 @@ export type Path = Map<string, {
 export declare const canon: (lin: Lin) => string;
 export declare const atomOf: (lin: Lin, holds: boolean) => Constraint;
 export declare function linear(e: E, path: Path): Lin | undefined;
+export declare const termColumn: (e: E) => string;
+export declare const columnTerm: (name: string) => E | undefined;
+export declare function decided(e: E, path: Path): boolean;
+export declare function termRows(name: string, path: Path): Lin[];
 export declare function 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[];
@@ -33,6 +37,8 @@ export type Subst = {
 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 assumed: (laws: Law[], instances: Instances) => C[];
 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;
@@ -103,6 +109,7 @@ export declare function checkStepLaws(m: Machine, laws: Law[], stepLaws: StepLaw
     perStep?: Record<string, Instances>;
     trees: Record<string, Tree>;
 }): boolean;
+export declare const stepZone: (m: Machine, k: number) => string[];
 export type Fold = {
     name: string;
     params: string[];

package/dist/kernel/kernel.js

@@ -35,11 +35,24 @@ function decide(lin, path) {
     const flipped = path.get(canon(add(k(1), scale(lin, -1))))?.holds;
     return flipped === undefined ? undefined : !flipped;
 }
-// A term's linear form under the path, or undefined if the path leaves one of its choices open.
-// Reads become cells, named by map and key: `M[key]`.
+// A term's linear form under the path. Reads become cells, named by map and key: `M[key]`; a choice the path leaves
+// open (∸, min, max, if) becomes a column of its own, `⟦n⟧`, standing for the term's value (see termRows).
+// Remembered per path and term (a path is never changed once built; a new decision is a new path), so a term shared
+// across hypotheses, or nested in a k-step run's later states, is read once per path.
+const linearMemo = new WeakMap();
 export function linear(e, path) {
+    let memo = linearMemo.get(path);
+    if (!memo)
+        linearMemo.set(path, (memo = new WeakMap()));
+    if (memo.has(e))
+        return memo.get(e);
+    const out = linearOf(e, path);
+    memo.set(e, out);
+    return out;
+}
+function linearOf(e, path) {
     switch (e.op) {
-        case 'var': return e.name === '1' || /[*[\],:]/.test(e.name) ? undefined : v(e.name); // those characters build cells and monomials
+        case 'var': return e.name === '1' || /[*[\],:⟦]/.test(e.name) ? undefined : v(e.name); // those characters build cells, monomials and term columns
         case 'const': return k(e.value);
         case 'mul': {
             const a = linear(e.a, path);
@@ -61,14 +74,14 @@ export function linear(e, path) {
                 return undefined;
             const aLeB = decide(sub(a, b), path), bLeA = decide(sub(b, a), path);
             if (e.op === 'sub')
-                return bLeA === true ? sub(a, b) : bLeA === false ? k(0) : undefined;
+                return bLeA === true ? sub(a, b) : bLeA === false ? k(0) : v(termColumn(e));
             if (aLeB === undefined)
-                return undefined;
+                return v(termColumn(e));
             return (e.op === 'min') === aLeB ? a : b;
         }
         case 'if': {
             const c = truth(e.c, path);
-            return c === undefined ? undefined : linear(c ? e.then : e.else, path);
+            return c === undefined ? v(termColumn(e)) : linear(c ? e.then : e.else, path);
         }
         case 'get': {
             const key = linear(e.key, path);
@@ -76,6 +89,61 @@ export function linear(e, path) {
         }
     }
 }
+// --- term columns -------------------------------------------------------------------------------------------------------
+// A choice the path leaves open is a column ⟦n⟧ for the n-th term met (one table per process: the name only has to be
+// the same for the same term). A leaf reads it through rows that hold whichever way the choice goes (termRows), so a
+// fact about the choice's value can be split on, and proven, before the choice is decided.
+// Terms are hash-consed: a term's id comes from its operator, its fields and its parts' ids, remembered per object, so a
+// deep term (a k-step run nests k steps) is read once, not once per lookup.
+const termIds = new Map(), termTable = [], memo = new WeakMap();
+function termId(t) {
+    const had = memo.get(t);
+    if (had !== undefined)
+        return had;
+    const parts = Object.entries(t).sort(([x], [y]) => (x < y ? -1 : x > y ? 1 : 0)).map(([key, val]) => (Array.isArray(val) ? `${key}=[${val.map(x => termId(x)).join(',')}]` : typeof val === 'object' && val !== null ? `${key}=#${termId(val)}` : `${key}=${JSON.stringify(val)}`));
+    const key = parts.join(';');
+    let id = termIds.get(key);
+    if (id === undefined) {
+        id = termTable.length;
+        termIds.set(key, id);
+        termTable.push(t);
+    }
+    memo.set(t, id);
+    return id;
+}
+export const termColumn = (e) => `⟦${termId(e)}⟧`;
+export const columnTerm = (name) => { const m = /^⟦(\d+)⟧$/.exec(name); return m ? termTable[Number(m[1])] : undefined; };
+// Whether the path decides a choice's top (an if's condition, which side of min, max or ∸).
+export function decided(e, path) {
+    if (e.op === 'if')
+        return truth(e.c, path) !== undefined;
+    if (e.op !== 'sub' && e.op !== 'min' && e.op !== 'max')
+        return true;
+    const a = linear(e.a, path), b = linear(e.b, path);
+    return !!a && !!b && decide(e.op === 'sub' ? sub(b, a) : sub(a, b), path) !== undefined;
+}
+// The rows a term column brings: its bounds, true whichever way the choice goes (min(a, b) ≤ a and ≤ b; max(a, b) ≥ a
+// and ≥ b; a ∸ b ≥ a − b and ≤ a), and, once the path decides it, its equality to the branch taken.
+export function termRows(name, path) {
+    const e = columnTerm(name), col = v(name), out = [];
+    if (e.op === 'min' || e.op === 'max' || e.op === 'sub') {
+        const a = linear(e.a, path), b = linear(e.b, path);
+        if (a && b) {
+            if (e.op === 'min')
+                out.push(sub(col, a), sub(col, b));
+            if (e.op === 'max')
+                out.push(sub(a, col), sub(b, col));
+            if (e.op === 'sub')
+                out.push(sub(sub(a, b), col), sub(col, a));
+        }
+    }
+    if (decided(e, path)) {
+        const r = linear(e, path);
+        if (r)
+            out.push(sub(col, r), sub(r, col));
+    }
+    return out;
+}
 // Products: multiply out, each monomial (variables joined by '*', sorted) one more natural variable. Forgetting how
 // monomials relate (x*x to x, say) only weakens what a leaf may use, so it stays sound; distributing is what proves
 // spend <= m·count over a node from the same law at its children. Map reads can't be factors.
@@ -83,8 +151,8 @@ function times(a, b) {
     const out = [];
     for (const [p, cp] of Object.entries(a))
         for (const [q, cq] of Object.entries(b)) {
-            if (p.includes('[') || q.includes('['))
-                return undefined;
+            if (p.includes('[') || q.includes('[') || p.includes('⟦') || q.includes('⟦'))
+                return undefined; // factors are variables (and monomials of them)
             const factors = [...(p === '1' ? [] : p.split('*')), ...(q === '1' ? [] : q.split('*'))].sort();
             out.push({ [factors.length ? factors.join('*') : '1']: cp * cq });
         }
@@ -172,6 +240,23 @@ export function leafConstraints(goal, path) {
             if (decide(d, path) === true && decide(scale(d, -1), path) === true)
                 rows.push({ lin: sub(v(p.name), v(q.name)), label: '' }, { lin: sub(v(q.name), v(p.name)), label: '' });
         }
+    // Each term column's rows, and the columns those rows bring in turn.
+    const seen = new Set(), todo = [...names].filter(n => n.startsWith('⟦'));
+    while (todo.length) {
+        const name = todo.pop();
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        for (const lin of termRows(name, path)) {
+            rows.push({ lin, label: '' });
+            for (const key of Object.keys(lin))
+                if (key !== '1') {
+                    names.add(key);
+                    if (key.startsWith('⟦') && !seen.has(key))
+                        todo.push(key);
+                }
+        }
+    }
     for (const name of names)
         rows.push({ lin: { [name]: -1 }, label: '' });
     return rows;
@@ -300,6 +385,14 @@ const step = (r, u) => {
             flags: at.flags,
         } };
 };
+// The state after a step, named: each state variable a fresh name n~j equal to its term there, which later frames read,
+// so a run of k steps is k small frames rather than a term nesting each state in the next (which grows as 3^k when a
+// step reads its state thrice). The names are new to the goal; each equation holds of the run that took the steps.
+const nameState = (r, state, j) => ({
+    hyps: [...r.hyps, ...state.map(n => ({ op: '=', a: { op: 'var', name: stateName(n, j) }, b: r.at.vars[n] ?? { op: 'var', name: n } }))],
+    at: { ...r.at, vars: { ...r.at.vars, ...Object.fromEntries(state.map(n => [n, { op: 'var', name: stateName(n, j) }])) } },
+});
+export const stateName = (n, j) => `${n}~${j}`;
 // The conclusion read at the run's end: plain names at the last frame.
 const atEnd = (r, c) => substC(c, r.at);
 // The conclusion read across the run: plain names at the first frame, primed names (s', and M'[k] as a read of the map
@@ -344,7 +437,7 @@ const laterNames = (m, j) => ({
     maps: Object.fromEntries((m.inputMaps ?? []).map(map => [map, `${map}@${j}`])),
 });
 // The laws assumed where the run is: each plain law, and each every-key law at the keys the proof names.
-const assumed = (laws, instances) => laws.flatMap(l => {
+export const assumed = (laws, instances) => laws.flatMap(l => {
     const keys = instances[l.name] ?? [];
     if (l.keys?.length) {
         const names = [l.forall, ...l.keys], n = names.length;
@@ -799,8 +892,9 @@ export function stepLawObligations(machine, laws, instances, sl) {
     const primes = [...state, ...maps].map(n => `${n}'`);
     const laters = Array.from({ length: k - 1 }, (_, i) => laterNames(m, i + 2));
     const later = laters.flatMap(l => Object.values(l.vars).map(e => e.name)), laterMaps = laters.flatMap(l => Object.values(l.maps));
+    const names = Array.from({ length: k - 1 }, (_, i) => state.map(n => stateName(n, i + 1))).flat();
     const taken = [...m.params, ...m.inputs, ...state, ...maps, ...carried];
-    for (const p of [...primes, ...later, ...laterMaps])
+    for (const p of [...primes, ...later, ...laterMaps, ...names])
         if (taken.includes(p))
             throw new Error(`${m.name}: ${p} is a name of the machine and a name a step law reads`);
     for (const key of [sl.forall, ...(sl.keys ?? [])])
@@ -822,14 +916,30 @@ export function stepLawObligations(machine, laws, instances, sl) {
         if (j > 1)
             run = reading(run, laters[j - 2].vars, laters[j - 2].maps);
         run = step(holds(run, [...assumed(laws, instances), ...assume, ...(whens[j - 1] ? [inlineFlags(m, whens[j - 1])] : []), ...closing(m, instances)]), u);
+        if (j < k)
+            run = nameState(run, state, j);
     }
     return [goal(k === 1 ? `${sl.name} @step law` : `${sl.name} @${k} steps`, run, across(run, sl.then, state, maps, { inputs: {}, flags: flagsOf(m) }))];
 }
 // The laws' proof and every step law's tree: all must check.
 // `perStep`: a step law's own instances, where it has them (else `instances`).
+// Each frame's hypotheses read no name a later step's request is read by: the condition the Lean twin's proof needs
+// (Sets.lean's checkSKStep, `avoids (szone s sl)`; plain flags are inlined here, so their names never occur), checked
+// here alike.
 export function checkStepLaws(m, laws, stepLaws, proof) {
-    return checkLaws(m, laws, proof.laws) && stepLaws.every(sl => stepLawObligations(m, laws, proof.perStep?.[sl.name] ?? proof.instances, sl).every(g => proof.trees[g.name] !== undefined && check(g, proof.trees[g.name])));
+    return checkLaws(m, laws, proof.laws) && stepLaws.every(sl => {
+        const inst = proof.perStep?.[sl.name] ?? proof.instances, plain = m.history ? historyMachine(m).machine : m;
+        const zone = stepZone(plain, sl.steps ?? 1);
+        return [...assumed(laws, inst), ...assumed(plain.facts ?? [], inst), ...closing(plain, inst)].every(c => !mentions(c, zone))
+            && stepLawObligations(m, laws, inst, sl).every(g => proof.trees[g.name] !== undefined && check(g, proof.trees[g.name]));
+    });
 }
+// The names a k-step law's run introduces past its first frame: each later step's inputs, quantified flags and their
+// witnesses, and the state after each step but the last (stateName).
+export const stepZone = (m, k) => [
+    ...Array.from({ length: k - 1 }, (_, i) => Object.values(laterNames(m, i + 2).vars).map(e => e.name)).flat(),
+    ...Array.from({ length: k - 1 }, (_, i) => Object.keys(m.state).map(n => stateName(n, i + 1))).flat(),
+];
 export function foldObligations(f, laws) {
     if (![...Object.values(f.leaf), ...Object.values(f.node)].every(natural) || !laws.every(law => !law.forall && !law.keys?.length && naturalC(law.holds) && !mentions(law.holds, f.inputs)))
         throw new Error('outside the kernel');

package/dist/kernel/prove.d.ts

@@ -7,6 +7,7 @@ export type Outcome = {
     stuck: 'sat' | 'unknown';
     witness?: Record<string, number>;
     path: Path;
+    why?: string;
 };
 export declare function grow(goal: Goal, path?: Path, budget?: {
     nodes: number;
@@ -20,6 +21,7 @@ export type Report = {
         goal: string;
         stuck: string;
         witness?: Record<string, number>;
+        why?: string;
     };
     checked: boolean;
 };
@@ -58,6 +60,7 @@ export declare function proveLiveness(m: Machine, laws: Law[], l: Liveness): Rep
 };
 export declare const countLeaves: (t: Tree) => number;
 export declare function concretize(goal: Goal, bound?: number): Record<string, number> | undefined;
+export declare function factsFor(m: Machine, goal: Goal): C[];
 export declare function proveBuilt(m: Machine, laws: Law[], build: (inst: Instances) => Goal): {
     proven: boolean;
     instances?: Instances;