gdp-wired 0.12.4 → 0.12.5

package/README.md

@@ -234,7 +234,9 @@ const soon = retry.law('the next try is at most 64 after the last request', ({ne
   lemmas too, at the list's end and wherever it reads the list. A lemma reads the folds, the prefix's length and the
   params, not the items: a fact about every item is a fold's (a count of the items that meet it). A fold's start and
   step, and a lemma, may read the params (`{from: ({fee}) => fee, step: (acc, line, {ceil}) => acc.plus(min(line.amount, ceil))}`); a request is then
-  encoded with them, `rule.encodeInput(values, params)` (`examples/invoices.ts`).
+  encoded with them, `rule.encodeInput(values, params)` (`examples/invoices.ts`). `rule.foldsOf({Lines: [...]}, params)`
+  gives each fold at the list's end, computed the same way, without running the rule (to compare a decision's folds
+  with the code it describes).
 - **Folds over trees** (`fold(name).params(...).inputs(...).leaf(env => ({...})).node((env, left, right) => ({...}))`,
   `proveFold`): a tree as a value (`{leaf: inputs}` or `{node: inputs, left, right}`), each leaf's values from its inputs
   and each node's from its own and its children's; a law about the values is proven by induction over the tree (the

package/dist/core/dsl.d.ts

@@ -598,6 +598,11 @@ export declare class Rule<P extends Obj = {}, I extends Obj = {}, S extends Obj
     }, params?: {
         [k in keyof P]: Raw;
     }): Request;
+    foldsOf(values: {
+        [k in keyof I]?: I[k] extends CarriedList<any, any> ? readonly Raw[] : never;
+    }, params?: {
+        [k in keyof P]: Raw;
+    }): Record<string, Record<string, number>>;
     randomParams(rand: Rand, bound: number): Record<string, number>;
     private paramValues;
     randomInput(rand: Rand, bound: number, ps?: Record<string, number>): Request;

package/dist/core/dsl.js

@@ -2160,6 +2160,16 @@ export class Rule {
         }
         return out;
     }
+    // Each carried list's folds at its end (what `L.fold.<f>` reads), computed from its items as encodeInput computes
+    // them, without running the rule: `foldsOf({Lines: [...]})` → {Lines: {total: 30}}. Only the lists given.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    foldsOf(values, params) {
+        const at = params && this.paramValues(this.encodeParams(params));
+        return Object.fromEntries((this.spec.lists2 ?? []).filter(([n]) => n in values).map(([n, k, fs]) => {
+            const { maps, len } = new CarriedList(n, k, v(`${n}_len`), fs, part => new MapRef(part, 0), {}, at).encode(values[n]);
+            return [n, Object.fromEntries(Object.keys(fs).map(f => [f, maps[`${n}$${f}`].get(len) ?? 0]))];
+        }));
+    }
     // Random params and inputs that meet their kinds (not the user's `pre` or `assume`, which a caller checks).
     randomParams(rand, bound) { return Object.assign({}, ...this.spec.params.map(([n, k]) => k.random(n, rand, bound))); }
     // The params' values by their kinds, as constants (what a fold that reads them is computed with).

package/dist/kernel/prove.js

@@ -667,14 +667,15 @@ const flagInstances = (m, keys, focus = []) => Object.fromEntries(Object.entries
 }));
 // A k-step law whose steps keep a condition (a flag that holds at one step and is read again at the next) fails at a
 // later step's witness only where the condition held before: so, per quantified flag over one key, the instances at the
-// law's own keys and that flag's witness at every step (a later step's witness is a key an earlier frame may name, as a
-// flag holds at every key: kernel.ts's checkStepLaws). Few instances, where the shared ones are many and mostly idle.
+// law's own keys and that flag's witness at every step (a later step's input or witness is a key an earlier frame may
+// name, as a flag holds at every key: kernel.ts's checkStepLaws). Few instances, where the shared ones are many and
+// mostly idle.
 const keptAcross = (m, laws, inst, own, k) => k < 2 ? [] : Object.entries(m.step.flags ?? {}).flatMap(([f, c]) => {
     if (c.op !== 'all' || c.keys?.length)
         return [];
     const ws = Array.from({ length: k }, (_, i) => ({ op: 'var', name: i ? `w?${f}@${i + 1}` : `w?${f}` })), keys = [...own, ...ws.slice(0, 1)];
     const keep = new Set(keys.map(e => JSON.stringify(e)));
-    return [Object.fromEntries(Object.entries(inst).map(([n, ks]) => [n, arity(m, laws, n) === 1 ? [...ks.filter(e => keep.has(JSON.stringify(e))), ...(n === `?${f}` ? ws.slice(1) : [])] : ks]))];
+    return [Object.fromEntries(Object.entries(inst).map(([n, ks]) => [n, n === `?${f}` ? [...keys, ...ws.slice(1)].filter((e, i, all) => all.findIndex(o => JSON.stringify(o) === JSON.stringify(e)) === i) : arity(m, laws, n) === 1 ? ks.filter(e => keep.has(JSON.stringify(e))) : ks]))];
 });
 const pairFlags = (m) => Object.values(m.step.flags ?? {}).some(c => c.op === 'all' && !!c.keys?.length);
 // How many keys each instance of a name takes: a law's, or a quantified flag's (?f).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdp-wired",
-  "version": "0.12.4",
+  "version": "0.12.5",
   "description": "An automatic prover for stateful rules (budgets, caps, windows, workflows, policies): laws proven with no proof to write, checked again in Lean, counterexamples found on the GPU, the rule shipped as code",
   "keywords": [
     "verification",