gdp-wired 0.14.2 → 0.15.0

package/dist/core/dsl.js

@@ -1416,8 +1416,12 @@ export const recur = (name, def, lemmas = {}, between = {}) => {
         proofs.between = { machine: r.machine, laws };
         verdict = { proven: true, checked: verdict.checked && v.checked };
     }
-    return { ...base, verdict, facts: facts(true) };
+    const out = { ...base, verdict, facts: facts(true) };
+    recurDefs.set(out, { name, def: def, lemmas: lemmas, between: between });
+    return out;
 };
+const recurDefs = new WeakMap();
+export const recurOf = (d) => recurDefs.get(d);
 const distinctNames = (what, names) => { if (new Set(names).size !== names.length)
     throw new Error(`${what}: a name given twice`); };
 // A recurrence as JavaScript: a function of its arguments, the functions it reads inlined (each called on its arguments,
@@ -1527,6 +1531,21 @@ export class Rule {
     }
     with(more) { return new Rule({ ...this.spec, ...more }); }
     get name() { return this.spec.name; }
+    // For core/discover.ts: the functions and carried lists the rule reads, and the same rule with functions made again
+    // and lemmas added to its lists' folds (each proven here, as carriesList proves its own).
+    get parts() {
+        return { params: this.spec.params, fns: this.spec.fns ?? [], lists: this.spec.lists2 ?? [] };
+    }
+    withParts(fns, listLemmas = {}) {
+        const lists = (this.spec.lists2 ?? []).map(([n, k, fs, ls]) => [n, k, fs, { ...ls, ...(listLemmas[n] ?? {}) }]);
+        for (const [n, k, fs, ls] of lists)
+            if (listLemmas[n]) {
+                const v2 = new CarriedList(n, k, v(`${n}_len`), fs, part => new MapRef(part, 0), ls, undefined, this.spec.params).prove();
+                if (!(v2.proven && v2.checked))
+                    throw new Unproven(`${n}'s fold lemmas`, v2);
+            }
+        return this.with({ fns: (this.spec.fns ?? []).map(([n, d]) => [n, fns[n] ?? d]), lists2: lists });
+    }
     params(kinds) { return this.with({ params: [...this.spec.params, ...Object.entries(kinds)] }); }
     inputs(kinds) { return this.with({ inputs: [...this.spec.inputs, ...Object.entries(kinds)] }); }
     // Each variable starts at a natural or at a term over the params, or is declared by a kind and starts where `from`
@@ -1758,6 +1777,8 @@ export class Rule {
     // A decision: whenever the params and the request meet `given`, `then` holds. Decisions don't read the state; the
     // functions' facts are assumed at the arguments the decision reads them at, and a carried list's equations (each
     // fold's start, its step and its lemmas) at the list's end, the key before it and every key the decision reads it at.
+    // A condition about every key (`everyKey`, `subsetOf`, ...) in `given` or `then` makes the decision a step law of
+    // this rule (its conditions as flags, the step left as it is): the flags' quantifiers are what the kernel closes.
     decide(name, given, then) {
         const env = this.env({ flags: false, state: false, queries: false });
         const g = given(env), hyps = [...this.kindAssumptions(), ...this.spec.pre.map(f => f(env).c), ...this.spec.assume.map(f => f(env).c), ...(Array.isArray(g) ? g : [g]).map(c => c.c)];
@@ -1766,7 +1787,14 @@ export class Rule {
         const listed = lists.flatMap(l => l.equationsAt(uniqueTerms([l.len, l.len.minus(1), ...keysRead([...hyps, t], l.maps)])).map(c => c.c));
         const goal = { name, hyps: [...listed, ...hyps, { op: 'not', x: t }] };
         const facts = this.spec.fns?.length || this.spec.facts?.length ? factsFor(this.machine, goal) : [];
-        return withSource({ name, rule: this, given: hyps, then: t, goal: { name, hyps: [...facts, ...goal.hyps] } }, { decision: { given: given, then: then, own: Array.isArray(g) ? g.length : 1 } });
+        const d = { name, rule: this, given: hyps, then: t, goal: { name, hyps: [...facts, ...goal.hyps] } };
+        if ([...(Array.isArray(g) ? g : [g]).map(c => c.c), t].some(quantifiedIn)) {
+            const conds = (e) => { const own = given(e); return { given$: all(...(Array.isArray(own) ? own : [own])), then$: then(e) }; };
+            const r = (this.spec.step ? this : this.step(() => ({}))).flags(conds);
+            const flag = (f) => (env) => env[f];
+            d.steps = { rule: r, law: r.stepLaw(name, flag('then$'), flag('given$')) };
+        }
+        return withSource(d, { decision: { given: given, then: then, own: Array.isArray(g) ? g.length : 1 } });
     }
     // A decision about two requests under the same params (noninterference, say: requests that differ only in a secret
     // are decided alike). `given` and `then` read both; the second request's inputs are named b.<input> in a witness.
@@ -2249,6 +2277,8 @@ const expandParts = (updates) => {
 };
 const encode = (kinds, values) => Object.assign({}, ...kinds.map(([n, k]) => k.encode(n, values[n])));
 export const rule = (name) => new Rule({ name, params: [], inputs: [], state: [], maps: [], flags: [], pre: [], assume: [], sums: [], queries: [] });
+const quantifiedE = (e) => e.op === 'if' ? quantifiedIn(e.c) || quantifiedE(e.then) || quantifiedE(e.else) : 'a' in e && typeof e.a === 'object' ? quantifiedE(e.a) || ('b' in e && typeof e.b === 'object' && quantifiedE(e.b)) : false;
+const quantifiedIn = (c) => c.op === 'all' || (c.op === 'not' ? quantifiedIn(c.x) : c.op === 'and' || c.op === 'or' ? c.xs.some(quantifiedIn) : c.op === 'flag' ? false : quantifiedE(c.a) || quantifiedE(c.b));
 // The kind a result field is kept in.
 const kindOf = (t) => (t instanceof Cond ? bool : t instanceof Int ? int : t instanceof Decimal ? decimal(t.places) : t instanceof Choice ? oneOf(...t.values) : t instanceof Str ? str({ like: t.patterns })
     : t instanceof Variant ? t.kind : t instanceof Maybe ? maybe(kindOf(t.inner)) : isRecord(t) ? record(Object.fromEntries(Object.entries(t).map(([f, x]) => [f, kindOf(x)]))) : nat);
@@ -2487,7 +2517,7 @@ export function proveLeadsTo(r, laws, l) {
     const out = proveLiveness(r.machine, withKinds(r, laws), l);
     return { proven: out.proven, checked: out.checked, ...(out.failed ? { goal: out.failed.goal, stuck: out.failed.stuck, ...(out.failed.witness ? { witness: out.failed.witness } : {}), ...(out.failed.why ? { why: out.failed.why } : {}) } : {}) };
 }
-export const proveDecision = (d) => goalsVerdict([d.goal]);
+export const proveDecision = (d) => (d.steps ? proveSteps(d.steps.rule, [], [d.steps.law]) : goalsVerdict([d.goal]));
 const seeded = (seed) => { let x = seed; return k => { x = (x * 1103515245 + 12345) % 2 ** 31; return Math.floor(x / 2 ** 31 * k); }; };
 // A decision's callbacks against its condition, on random params and requests: `given` and `then` each run with every
 // value known, against what the interpreter evaluates of the decision built from them.

package/dist/core/infer.d.ts

@@ -0,0 +1,29 @@
+import { type Law, type Machine, type State } from './machine.js';
+import { type StepLaw, type Verdict, proveRule } from './dsl.js';
+type AnyRule = Parameters<typeof proveRule>[0];
+export type InferOptions = {
+    ms?: number;
+    runsMs?: number;
+    seen?: State[];
+    constants?: number[];
+    maxCandidates?: number;
+    first?: Verdict;
+    progress?: (phase: string, info: Record<string, number | string>) => void;
+};
+export type Found = {
+    law: Law;
+    text: string;
+    source?: string;
+};
+export type Inferred = Verdict & {
+    found: Found[];
+    stats: {
+        samples: number;
+        candidates: number;
+        alive: number;
+        proofs: number;
+        ms: number;
+    };
+};
+export declare function inferLaws(target: AnyRule | Machine, laws: Law[], stepLaws?: StepLaw[], opts?: InferOptions): Inferred;
+export {};