gdp-wired 0.19.0 → 0.21.0

package/dist/core/discover.js

@@ -83,8 +83,8 @@ function linearCands(target, forms, samples, show) {
     return dedupe(out.filter(c => samples.every(s => holds(c, s))));
 }
 const dedupe = (cs) => [...new Map(cs.map(c => [c.name, c])).values()];
-// A polynomial in x of degree 2 at most, exact over the rationals, as d·f = a·x·x + b·x + c with whole numbers: fitted to
-// three points, kept when every sample meets it.
+// A polynomial in x of degree 3 at most, exact over the rationals, as d·f = a·x·x·x + b·x·x + c·x + e with whole
+// numbers: fitted to four points (Newton's differences), kept when every sample meets it.
 function closedForm(samples, show) {
     const at = new Map();
     for (const s of samples) {
@@ -95,22 +95,30 @@ function closedForm(samples, show) {
     if (![0, 1, 2].every(x => at.has(x)))
         return [];
     const [f0, f1, f2] = [at.get(0), at.get(1), at.get(2)];
+    const keep = (lin) => {
+        const g = Object.values(lin).reduce((p, q) => gcd(p, Math.abs(q)), 0);
+        const c = { name: '', rel: '=', lin: Object.fromEntries(Object.entries(lin).map(([a, k]) => [a, k / g]).filter(([, k]) => k !== 0)) };
+        c.name = nameOf(c, show, 'f');
+        return samples.every(s => holds(c, s)) ? [c] : [];
+    };
     // f = a x² + b x + c: c = f0, a = (f2 - 2 f1 + f0) / 2, b = f1 - f0 - a; times 2 to keep whole numbers.
     const A = f2 - 2 * f1 + f0, B = 2 * (f1 - f0) - A, C = 2 * f0;
-    if (A === 0)
-        return []; // linear: the bounds find it
-    const g = [A, B, C, 2].reduce((p, q) => gcd(p, Math.abs(q)), 0);
-    const c = { name: '', rel: '=', lin: Object.fromEntries(Object.entries({ f: 2 / g, xx: -A / g, x: -B / g, 1: -C / g }).filter(([, k]) => k !== 0)) };
-    c.name = nameOf(c, show, 'f');
-    return samples.every(s => holds(c, s)) ? [c] : [];
+    const square = A === 0 ? [] : keep({ f: 2, xx: -A, x: -B, 1: -C });
+    if (square.length || !at.has(3))
+        return square;
+    // f = Δ0 + Δ1·x + Δ2·x(x − 1)/2 + Δ3·x(x − 1)(x − 2)/6, times 6: x³ by Δ3, x² by 3Δ2 − 3Δ3, x by 6Δ1 − 3Δ2 + 2Δ3.
+    const d1 = f1 - f0, d2 = f2 - 2 * f1 + f0, d3 = at.get(3) - 3 * f2 + 3 * f1 - f0;
+    if (d3 === 0)
+        return []; // degree 2 at most: above, or linear (the bounds find it)
+    return keep({ f: 6, xxx: -d3, xx: -(3 * d2 - 3 * d3), x: -(6 * d1 - 3 * d2 + 2 * d3), 1: -6 * f0 });
 }
 // The law a goal is of (the kernel names each goal after its law: '<law> @step').
 const lawOfGoal = (goal) => goal.replace(/ @(start|step|step law|\d+ steps|leaf|node)$/, '');
 const isGoalOf = (goal) => (c) => { const law = lawOfGoal(goal); return law === c.name || law === `${c.name} at y`; };
 const gcd = (a, b) => (b === 0 ? Math.abs(a) : gcd(b, a % b));
 // --- recurrences ---------------------------------------------------------------------------------------------------
-const showRecur = (a) => (a === 'f' ? 'f(x)' : a === 'g' ? 'f(y)' : a === 'xx' ? 'x·x' : a);
-const srcRecur = (a) => (a === 'xx' ? 'x.mul(x)' : a);
+const showRecur = (a) => (a === 'f' ? 'f(x)' : a === 'g' ? 'f(y)' : a === 'xx' ? 'x·x' : a === 'xxx' ? 'x·x·x' : a);
+const srcRecur = (a) => (a === 'xx' ? 'x.mul(x)' : a === 'xxx' ? 'x.mul(x).mul(x)' : a);
 // The function's values: x from 0 to 40 at a few values of each further argument (all of them for two at most).
 function recurSamples(d, args) {
     const f = (typeof d.js === 'function' ? d.js : compileFunction([], `return (${d.js})`)());
@@ -128,7 +136,7 @@ function recurSamples(d, args) {
                     break;
                 throw e;
             }
-            out.push({ x, f: y, xx: x * x, ...Object.fromEntries(args.map((a, i) => [a, t[i]])) });
+            out.push({ x, f: y, xx: x * x, xxx: x * x * x, ...Object.fromEntries(args.map((a, i) => [a, t[i]])) });
         }
     return out;
 }
@@ -167,9 +175,9 @@ function recurCands(samples, args) {
         c.name = nameOf(c, showRecur, 'g');
     return { lemmas, between };
 }
-const recurAtoms = (args, x, f, env, y, g) => ({ x, f, xx: x.mul(x), ...(y && g ? { y, g } : {}), ...Object.fromEntries(args.map(a => [a, env[a]])) });
+const recurAtoms = (args, x, f, env, y, g) => ({ x, f, xx: x.mul(x), xxx: x.mul(x).mul(x), ...(y && g ? { y, g } : {}), ...Object.fromEntries(args.map(a => [a, env[a]])) });
 const recurSrc = (c, args, between) => {
-    const reads = (a) => Object.keys(c.lin).includes(a) || (a === 'x' && 'xx' in c.lin);
+    const reads = (a) => Object.keys(c.lin).includes(a) || (a === 'x' && ('xx' in c.lin || 'xxx' in c.lin));
     const names = between ? ['x', 'f', 'y', 'g'] : ['x', 'f'];
     let unused = 0;
     const params = [...names.map(n => (reads(n) ? n : '_'.repeat(++unused))), ...(args.some(reads) ? [`{${args.filter(reads).join(', ')}}`] : [])];
@@ -268,27 +276,40 @@ function discoverSearch(r, laws, stepLaws, first) {
     if (first.proven && first.checked)
         return { verdict: first, rule: r, found: {} };
     const { params, fns, lists } = r.parts, ps = natParams(params);
-    // Per function and per list: what is proven, made into the rule.
-    const fnMade = {};
-    for (const [n, d] of fns) {
-        const src = recurOf(d);
-        if (!src)
-            continue;
-        const args = [...(src.def.args ?? [])], { lemmas, between } = recurCands(recurSamples(d, args), args);
-        const made = houdiniRecur(d, lemmas, between);
-        if (made && (made.lemmas.length || made.between.length))
-            fnMade[n] = made;
-    }
-    let rule = r.withParts(Object.fromEntries(Object.entries(fnMade).map(([n, m]) => [n, m.d])));
-    const listKept = {};
-    for (const part of lists) {
-        const out = houdiniList(rule, part, listCands(part, params, listSamples(part, params)), ps);
-        if (out && out.kept.length) {
-            rule = out.rule;
-            listKept[part[0]] = out.kept;
+    // Per function and per list: what is proven, made into the rule. A function with a closed form (of degree 2 or 3,
+    // fitted exactly) first with it alone: it decides the function, and the bounds beside it, which the closed form
+    // implies only through products, are slow to prove by induction; the rest where the laws aren't proven with it.
+    const cands = new Map(fns.flatMap(([n, d]) => { const src = recurOf(d); if (!src)
+        return []; const args = [...(src.def.args ?? [])]; return [[n, recurCands(recurSamples(d, args), args)]]; }));
+    const exact = (c) => c.rel === '=' && ('xx' in c.lin || 'xxx' in c.lin);
+    const makeFns = (closedOnly) => {
+        const out = {};
+        for (const [n, d] of fns) {
+            const cs = cands.get(n);
+            if (!cs)
+                continue;
+            const closed = cs.lemmas.filter(exact), made = closedOnly && closed.length ? houdiniRecur(d, closed, []) : houdiniRecur(d, cs.lemmas, cs.between);
+            if (made && (made.lemmas.length || made.between.length))
+                out[n] = made;
         }
-    }
-    const verdict = proveSteps(rule, laws, stepLaws, { search: false });
+        return out;
+    };
+    const withLists = (fnMade) => {
+        let rule = r.withParts(Object.fromEntries(Object.entries(fnMade).map(([n, m]) => [n, m.d])));
+        const listKept = {};
+        for (const part of lists) {
+            const out = houdiniList(rule, part, listCands(part, params, listSamples(part, params)), ps);
+            if (out && out.kept.length) {
+                rule = out.rule;
+                listKept[part[0]] = out.kept;
+            }
+        }
+        return { fnMade, rule, listKept, verdict: proveSteps(rule, laws, stepLaws, { search: false }) };
+    };
+    let made = [...cands.values()].some(cs => cs.lemmas.some(exact)) ? withLists(makeFns(true)) : undefined;
+    if (!made || !(made.verdict.proven && made.verdict.checked))
+        made = withLists(makeFns(false));
+    const { fnMade, rule, listKept, verdict } = made;
     const found = () => ({
         ...Object.fromEntries(Object.entries(fnMade).map(([n, m]) => { const args = [...(recurOf(m.d).def.args ?? [])]; return [n, { ...(m.lemmas.length ? { lemmas: m.lemmas.map(c => recurSrc(c, args, false)) } : {}), ...(m.between.length ? { between: m.between.map(c => recurSrc(c, args, true)) } : {}) }]; })),
         ...Object.fromEntries(Object.entries(listKept).map(([n, cs]) => [n, { lemmas: cs.map(c => listSrc(c, Object.keys(lists.find(l => l[0] === n)[2]), ps, c.target)) }])),

package/dist/core/dsl.d.ts

@@ -10,6 +10,8 @@ export declare class Term {
     minus(b: TermLike): Term;
     times(k: number): Term;
     mul(b: TermLike): Term;
+    modBy(k: number): Term;
+    divBy(k: number): Term;
     lt(b: TermLike): Cond;
     atMost(b: TermLike): Cond;
     gt(b: TermLike): Cond;
@@ -20,7 +22,8 @@ export declare class Term {
 export declare class Cond {
     readonly c: C;
     readonly ok?: boolean | undefined;
-    constructor(c: C, ok?: boolean | undefined);
+    readonly ex?: readonly Bound[] | undefined;
+    constructor(c: C, ok?: boolean | undefined, ex?: readonly Bound[] | undefined);
     and(...xs: Cond[]): Cond;
     or(...xs: Cond[]): Cond;
     not(): Cond;
@@ -94,6 +97,8 @@ export declare class Int {
     min(b: IntLike): Int;
     max(b: IntLike): Int;
     get isNegative(): Cond;
+    modBy(k: number): Term;
+    divBy(k: number): Int;
     get abs(): Term;
     get clamped(): Term;
 }
@@ -261,6 +266,20 @@ export type MapWrite = {
 };
 export declare const everyKey: (f: (key: Term, key2: Term, key3: Term) => Cond) => Cond;
 export declare const someKey: (f: (key: Term) => Cond, witness?: TermLike) => Cond;
+export type ExistsWitness<V> = V | number | {
+    start: V | number;
+    step: (before: V, env: never) => V | number;
+};
+type Bound = {
+    vars: string[];
+    body: C;
+    pos: boolean;
+    terms?: Record<string, E>;
+    start?: Record<string, E>;
+    step?: (env: Record<string, unknown>) => Record<string, E>;
+};
+export declare function exists(f: (x: Term) => Cond, witness?: ExistsWitness<Term>): Cond;
+export declare function exists<V>(kind: Kind<V>, f: (x: V) => Cond, witness?: ExistsWitness<V>): Cond;
 export declare class MapRef {
     readonly name: string;
     readonly init: number;
@@ -498,6 +517,7 @@ type Spec = {
     lists2?: [string, Kind<unknown>, Record<string, ListFold<unknown>>, Record<string, ListLemma>][];
     fns?: [string, FnDef][];
     facts?: ((env: never) => Record<string, Cond | Forall>)[];
+    arith?: Set<number>;
     flags: ((env: never) => Record<string, Cond>)[];
     step?: (env: never) => Record<string, TermLike | MapWrite | undefined>;
     pre: ((p: never) => Cond)[];
@@ -588,13 +608,17 @@ export declare class Rule<P extends Obj = {}, I extends Obj = {}, S extends Obj
     prune(order: keyof R & string, after: (p: P) => TermLike): Rule<P, I, S, M, F, R, Su, Q>;
     law(name: string, f: (env: P & S & M & Su) => Cond | Forall): Law;
     private lawOf;
+    private someOf;
+    private divides;
+    dividesBy(...ks: number[]): this;
+    withDivisors(...ks: number[]): this;
     kindLaws(): Law[];
     stepLaw(name: string, then: (before: P & I & S & M & F & Su & Q, after: S & M & Su) => Cond | Forall, when?: (before: P & I & S & M & F & Su & Q) => Cond): StepLaw;
     stepsLaw(name: string, k: number, then: (first: P & I & S & M & F & Su & Q, last: S & M & Su, requests: (I & Q)[]) => Cond | Forall, when?: (before: P & I & S & M & F & Su & Q, j: number) => Cond | undefined): StepLaw;
     leadsTo(name: string, spec: {
         from: (env: P & S & M & Su) => Cond;
         to: (env: P & S & M & Su) => Cond;
-        rank: (env: P & S & M & Su) => TermLike | TermLike[];
+        rank?: (env: P & S & M & Su) => TermLike | TermLike[];
         helpful: ((env: P & S & M & Su) => Record<string, TermLike>) | {
             when?: (env: P & S & M & Su) => Cond;
             request: (env: P & S & M & Su) => Record<string, TermLike>;
@@ -631,6 +655,7 @@ export declare class Rule<P extends Obj = {}, I extends Obj = {}, S extends Obj
     encodeParams(values: {
         [k in keyof P]: Raw;
     }): Record<string, number>;
+    private withSkolems;
     encodeInput(values: {
         [k in keyof I]: I[k] extends MapRef ? ReadonlySet<number> | readonly number[] | ReadonlyMap<number, number> : I[k] extends SeqRef ? readonly number[] : I[k] extends SeqTable ? readonly (readonly number[])[] : I[k] extends CarriedList<any, any> ? readonly Raw[] : Raw;
     }, params?: {
@@ -800,6 +825,7 @@ export type Verdict = {
         trace: Record<string, unknown>[];
     };
     found?: Found;
+    witnesses?: Record<string, string>;
 };
 export type Found = {
     laws?: {
@@ -828,7 +854,9 @@ export declare function proveRule(r: Rule<Obj, Obj, Obj, Obj, Obj, Obj, Obj, Obj
 export declare function proveSteps(r: Rule<Obj, Obj, Obj, Obj, Obj, Obj, Obj, Obj>, laws: Law[], stepLaws: StepLaw[], opts?: ProveOptions): Verdict;
 export type { StepLaw };
 export type { Liveness };
-export declare function proveLeadsTo(r: Rule<Obj, Obj, Obj, Obj, Obj, Obj, Obj, Obj>, laws: Law[], l: Liveness): Verdict;
+export declare function proveLeadsTo(r: Rule<Obj, Obj, Obj, Obj, Obj, Obj, Obj, Obj>, laws: Law[], l: Liveness, opts?: {
+    ms?: number;
+}): Verdict;
 export declare const proveDecision: (d: Decision) => Verdict;
 export declare function crossCheckDecision(d: Decision, opts?: {
     trials?: number;