gdp-wired 0.1.0 → 0.3.0

package/dist/core/dsl.d.ts

@@ -1,5 +1,5 @@
-import { type C, type E, type Law, type Machine, type State } from './machine.js';
-import { type Goal, type Loop, type StepLaw, type Tree } from '../kernel/kernel.js';
+import { type C, type E, type Law, type Machine, type Request, type State } from './machine.js';
+import { type Goal, type Liveness, type Loop, type StepLaw, type Tree } from '../kernel/kernel.js';
 export type TermLike = Term | number;
 export declare const termOf: (t: TermLike) => E;
 export declare class Term {
@@ -87,7 +87,13 @@ export type MapWrite = {
     readonly map: string;
     readonly key: E;
     readonly value: E;
+} | {
+    readonly map: string;
+    readonly each: string;
+    readonly value: E;
 };
+export declare const everyKey: (f: (key: Term) => Cond) => Cond;
+export declare const someKey: (f: (key: Term) => Cond, witness?: TermLike) => Cond;
 export declare class MapRef {
     readonly name: string;
     readonly init: number;
@@ -95,16 +101,57 @@ export declare class MapRef {
     at(key: TermLike): Term;
     set(key: TermLike, value: TermLike): MapWrite;
     bump(key: TermLike, c?: Cond, by?: TermLike): MapWrite;
+    each(f: (key: Term) => TermLike): MapWrite;
+    has(key: TermLike): Cond;
+    subsetOf(other: MapRef): Cond;
+    disjointFrom(other: MapRef): Cond;
+    sameAs(other: MapRef): Cond;
+    within(n: number): Cond;
+    sizeBelow(n: number): Term;
+}
+export type ListOp = {
+    readonly when: Cond;
+    readonly at: (k: Term) => TermLike;
+    readonly len: TermLike;
+};
+export declare class ListRef {
+    readonly name: string;
+    readonly len: Term;
+    constructor(name: string, len: Term);
+    at(i: TermLike): Term;
+    has(x: TermLike): Cond;
+    sorted(): Cond;
+    push(x: TermLike, when?: Cond): ListOp;
+    pop(when?: Cond): ListOp;
+    set(i: TermLike, x: TermLike, when?: Cond): ListOp;
+    insertAt(i: TermLike, x: TermLike, when?: Cond): ListOp;
+    removeAt(i: TermLike, when?: Cond): ListOp;
+    apply(...ops: ListOp[]): Record<string, TermLike | MapWrite>;
+    within(): Forall;
+    increasing(): Forall;
 }
 export type Forall = {
-    readonly forall: (key: Term) => Cond;
+    readonly forall: (key: Term, ...more: Term[]) => Cond;
 };
-export declare const forall: (f: (key: Term) => Cond) => Forall;
+export declare function forall(f: (key: Term, key2: Term, key3: Term, key4: Term) => Cond): Forall;
 export type Relation = {
     readonly when: Cond;
     readonly holds: Cond;
 };
 export declare const relation: (holds: Cond, whenever?: Cond) => Relation;
+export declare function nameQuantifiers(m: Machine): Machine;
+export type FnDef = {
+    arity: number;
+    js: string | ((...args: number[]) => number);
+    lean?: string;
+    facts?: (f: (...args: TermLike[]) => Term) => Record<string, Cond | Forall>;
+};
+export declare const fn: (arity: number, js: FnDef["js"], opts?: {
+    lean?: string;
+    facts?: FnDef["facts"];
+}) => FnDef;
+export declare const divBy: (c: number) => FnDef;
+export declare const modBy: (c: number) => FnDef;
 type Kinds = Record<string, Kind<unknown>>;
 type ValuesOf<K extends Kinds> = {
     [n in keyof K]: K[n] extends Kind<infer V> ? V : never;
@@ -121,6 +168,10 @@ type Spec = {
     inputs: [string, Kind<unknown>][];
     state: [string, number | ((p: never) => TermLike)][];
     maps: [string, number][];
+    lists?: string[];
+    carried?: string[];
+    fns?: [string, FnDef][];
+    facts?: ((env: never) => Record<string, Cond | Forall>)[];
     flags: ((env: never) => Record<string, Cond>)[];
     step?: (env: never) => Record<string, TermLike | MapWrite | undefined>;
     pre: ((p: never) => Cond)[];
@@ -148,6 +199,18 @@ export declare class Rule<P extends Obj = {}, I extends Obj = {}, S extends Obj
     maps<T extends Record<string, number>>(init: T): Rule<P, I, S, M & {
         [k in keyof T]: MapRef;
     }, F, R, Su, Q>;
+    lists<const N extends string>(...names: N[]): Rule<P, I, S & {
+        [k in N as `${k}_len`]: Term;
+    }, M & {
+        [k in N]: ListRef;
+    }, F, R, Su, Q>;
+    fns<T extends Record<string, FnDef>>(defs: T): Rule<P & {
+        [k in keyof T]: (...args: TermLike[]) => Term;
+    }, I, S, M, F, R, Su, Q>;
+    facts(f: (p: P) => Record<string, Cond | Forall>): Rule<P, I, S, M, F, R, Su, Q>;
+    carries<const N extends string>(...names: N[]): Rule<P, I & {
+        [k in N]: MapRef;
+    }, S, M, F, R, Su, Q>;
     flags<T extends Record<string, Cond>>(f: (env: P & I & S & M & F & Su & Q) => T): Rule<P, I, S, M, F & {
         [k in keyof T]: Cond;
     }, R, Su, Q>;
@@ -165,7 +228,18 @@ export declare class Rule<P extends Obj = {}, I extends Obj = {}, S extends Obj
     relations(f: (env: P & I & Su & Q) => Relation[]): Rule<P, I, S, M, F, R, Su, Q>;
     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;
     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[];
+        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>;
+        }[];
+    }): Liveness;
     decide(name: string, given: (env: P & I) => Cond | Cond[], then: (env: P & I) => Cond): Decision;
     private kindAssumptions;
     private env;
@@ -174,10 +248,10 @@ export declare class Rule<P extends Obj = {}, I extends Obj = {}, S extends Obj
         [k in keyof P]: Raw;
     }): Record<string, number>;
     encodeInput(values: {
-        [k in keyof I]: Raw;
-    }): Record<string, number>;
+        [k in keyof I]: I[k] extends MapRef ? ReadonlySet<number> | readonly number[] | ReadonlyMap<number, number> : Raw;
+    }): Request;
     randomParams(rand: Rand, bound: number): Record<string, number>;
-    randomInput(rand: Rand, bound: number): Record<string, number>;
+    randomInput(rand: Rand, bound: number): Request;
     get orderedBy(): string | undefined;
     interpreter(): {
         init: (params: {
@@ -185,16 +259,12 @@ export declare class Rule<P extends Obj = {}, I extends Obj = {}, S extends Obj
         }) => State;
         queries: (params: {
             [x: string]: number;
-        }, st: State, input: {
-            [x: string]: number;
-        }) => {
+        }, st: State, input: Request) => {
             [x: string]: number;
         };
         step: (params: {
             [x: string]: number;
-        }, st: State, input: {
-            [x: string]: number;
-        }) => State;
+        }, given: State, input: Request) => State;
     };
     compiled(): {
         init: (params: object) => State & {
@@ -263,5 +333,7 @@ export type Verdict = {
 export declare function proveRule(r: Rule<Obj, Obj, Obj, Obj, Obj, Obj, Obj, Obj>, laws: Law[]): Verdict;
 export declare function proveSteps(r: Rule<Obj, Obj, Obj, Obj, Obj, Obj, Obj, Obj>, laws: Law[], stepLaws: StepLaw[]): 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 const proveDecision: (d: Decision) => Verdict;
 export declare const proveLoop: (l: LoopRule<Obj, Obj, Obj>, laws: Law[]) => Verdict;