gdp-wired 0.3.0 → 0.4.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

@@ -33,6 +33,7 @@ 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 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;

package/dist/kernel/kernel.js

@@ -344,7 +344,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;

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;

package/dist/kernel/prove.js

@@ -1,5 +1,5 @@
 import { add, k, scale, solve, sub } from "../core/solver.js";
-import { canon, check, checkLaws, checkStepLaws, historyMachine, leafConstraints, linear, livenessHelpful, livenessParts, obligations, plainKey, progressObligations, stepLawObligations, trueC, truth, unreachable, withProducts } from "./kernel.js";
+import { assumed, canon, check, checkLaws, checkStepLaws, historyMachine, leafConstraints, linear, livenessHelpful, livenessParts, obligations, plainKey, progressObligations, stepLawObligations, trueC, truth, unreachable, withProducts } from "./kernel.js";
 // The atoms the path leaves open, in evaluation order: deciding any of them makes progress.
 function openE(e, path, out) {
     switch (e.op) {
@@ -117,7 +117,7 @@ function parse(text) {
 // is left `unknown`. A goal with many instances (a law about two keys at its pairs) has that many more rows per leaf.
 export function grow(goal, path = new Map(), budget = { nodes: 0, until: performance.now() + Math.max(20_000, 1_000 * goal.hyps.length) }) {
     if (++budget.nodes > 200_000 || (budget.until !== undefined && performance.now() > budget.until))
-        return { stuck: 'unknown', path };
+        return { stuck: 'unknown', path, why: outOfBudget(goal, budget.nodes > 200_000 ? 'nodes' : 'time', path.size) };
     const rows = leafConstraints(goal, path);
     const verdict = solve(rows);
     if (verdict.kind === 'refuted')
@@ -182,6 +182,13 @@ export function grow(goal, path = new Map(), budget = { nodes: 0, until: perform
         return no;
     return { tree: { split, yes: yes.tree, no: no.tree }, nodes: budget.nodes };
 }
+// What ran out, for a goal left unknown: its size, how deep the case splits went, and the two shapes that usually cause it.
+function outOfBudget(goal, limit, depth) {
+    const steps = Number(/@(\d+) steps/.exec(goal.name)?.[1] ?? 1);
+    return `the prover's ${limit === 'nodes' ? '200,000-node' : 'time'} budget ran out at ${goal.hyps.length} hypotheses, ${depth} case splits deep. ` +
+        `Each case a step decides multiplies the cases to refute, so ${steps > 1 ? `a law over ${steps} steps` : 'many interacting cases'} can outgrow it: ` +
+        'state the law over fewer steps (a one-step law and an invariant often give the same), or split it into laws about fewer conditions';
+}
 // Integer completeness for bounded systems: when elimination is inexact and finds no witness, halve a variable's range
 // (x <= mid or x >= mid + 1). Each half is a split like any other, so the kernel checks it the same way; a variable
 // pinned to one value becomes an equality, which the solver substitutes exactly.
@@ -449,7 +456,7 @@ function proveLawsAsGiven(m, laws) {
     for (const goal of obligations(m, laws, instances)) {
         const out = grow(goal);
         if (!('tree' in out))
-            return { proven: false, nodes, leaves, failed: { goal: goal.name, stuck: out.stuck, ...(out.witness ? { witness: out.witness } : {}) }, checked: false };
+            return { proven: false, nodes, leaves, failed: { goal: goal.name, stuck: out.stuck, ...(out.witness ? { witness: out.witness } : {}), ...(out.why ? { why: out.why } : {}) }, checked: false };
         trees[goal.name] = out.tree;
         nodes += out.nodes;
         leaves += countLeaves(out.tree);
@@ -492,7 +499,7 @@ function proveStepLawsAsGiven(m, laws, stepLaws, base) {
         for (const goal of stepLawObligations(m, laws, perStep[sl.name] ?? instances, sl)) {
             const out = grow(goal);
             if (!('tree' in out))
-                return { proven: false, nodes, leaves, failed: { goal: goal.name, stuck: out.stuck, ...(out.witness ? { witness: out.witness } : {}) }, checked: false };
+                return { proven: false, nodes, leaves, failed: { goal: goal.name, stuck: out.stuck, ...(out.witness ? { witness: out.witness } : {}), ...(out.why ? { why: out.why } : {}) }, checked: false };
             trees[goal.name] = out.tree;
             nodes += out.nodes;
             leaves += countLeaves(out.tree);
@@ -516,7 +523,7 @@ export function proveProgress(m, laws, p) {
     for (const goal of progressObligations(m, ls, instances, p)) {
         const out = grow(goal);
         if (!('tree' in out))
-            return { proven: false, nodes, leaves, failed: { goal: goal.name, stuck: out.stuck, ...(out.witness ? { witness: out.witness } : {}) }, checked: false };
+            return { proven: false, nodes, leaves, failed: { goal: goal.name, stuck: out.stuck, ...(out.witness ? { witness: out.witness } : {}), ...(out.why ? { why: out.why } : {}) }, checked: false };
         trees[goal.name] = out.tree;
         nodes += out.nodes;
         leaves += countLeaves(out.tree);
@@ -562,7 +569,7 @@ function readKeysC(c) {
 export const countLeaves = (t) => ('leaf' in t ? 1 : countLeaves(t.yes) + countLeaves(t.no));
 // A real counterexample for a goal the prover couldn't close (with products, its witness may be abstract): the free
 // variables over 0..bound, every hypothesis evaluated with true arithmetic. Goals that read maps are left to the
-// machine searches (search/), which run whole histories.
+// machine searches (research/search/), which run whole histories.
 export function concretize(goal, bound = 12) {
     const names = new Set();
     let reads = false;
@@ -604,6 +611,14 @@ export function concretize(goal, bound = 12) {
     }
     return undefined;
 }
+// The facts a goal needs, as hypotheses: each fact about every key at the keys the goal reads a function at (and at
+// the keys those facts read, a second round), each plain fact as it is.
+export function factsFor(m, goal) {
+    let instances = {};
+    for (let round = 0; round < 2; round++)
+        instances = withFacts(m, instances, fnKeys(m, [{ ...goal, hyps: [...assumed(m.facts ?? [], instances), ...goal.hyps] }]));
+    return assumed(m.facts ?? [], instances);
+}
 // A goal built from its instances (an exporter's goal, shaped as its Lean twin builds it): the every-key laws, the
 // quantified flags and the facts assumed at every key it reads a map or function at, then a tree, checked.
 export function proveBuilt(m, laws, build) {

package/dist/lean-kernel/emit.d.ts

@@ -57,16 +57,6 @@ export declare function mmachineToLean(id: string, m: Machine, laws: Law[], opts
     progress?: ProgressCase[];
     free?: string[];
     stepLaws?: StepLaw[];
-    liveness?: Liveness[];
-    ghosts?: string[];
-    after?: (ix: (name: string) => number) => string;
-    refined?: {
-        impl: Machine;
-        spec: Machine;
-        wit: Record<string, E>;
-        stutter: C;
-        specPre: number;
-    };
 }): string;
 export declare const hasSets: (m: Machine) => boolean;
 export declare function smachineToLean(id: string, m: Machine, laws: Law[], opts?: {
@@ -78,6 +68,8 @@ export declare function smachineToLean(id: string, m: Machine, laws: Law[], opts
     };
     simp?: string[];
     free?: string[];
+    ghosts?: string[];
+    after?: (ix: (name: string) => number) => string;
     refined?: {
         impl: Machine;
         spec: Machine;