gdp-wired 0.2.0 → 0.4.0

package/dist/core/dsl.d.ts

@@ -1,10 +1,11 @@
-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 {
     readonly e: E;
-    constructor(e: E);
+    readonly val?: number | undefined;
+    constructor(e: E, val?: number | undefined);
     plus(b: TermLike): Term;
     minus(b: TermLike): Term;
     times(k: number): Term;
@@ -18,7 +19,8 @@ export declare class Term {
 }
 export declare class Cond {
     readonly c: C;
-    constructor(c: C);
+    readonly ok?: boolean | undefined;
+    constructor(c: C, ok?: boolean | undefined);
     and(...xs: Cond[]): Cond;
     or(...xs: Cond[]): Cond;
     not(): Cond;
@@ -33,7 +35,10 @@ export declare const any: (...cs: Cond[]) => Cond;
 export declare const not: (c: Cond) => Cond;
 export declare const min: (a: TermLike, b: TermLike) => Term;
 export declare const max: (a: TermLike, b: TermLike) => Term;
-export declare const when: (c: Cond, then: TermLike, otherwise: TermLike) => Term;
+export declare function when(c: Cond, then: TermLike, otherwise: TermLike): Term;
+export declare function when(c: Cond, then: Decimal, otherwise: Decimal | number): Decimal;
+export declare function when(c: Cond, then: Decimal | number, otherwise: Decimal): Decimal;
+export declare function when(c: Cond, then: IntLike, otherwise: IntLike): Int;
 export declare const choose: (c: Cond, then: Cond, otherwise: Cond) => Cond;
 export declare const count: (c: Cond) => Term;
 export declare const sum: (first: TermLike, ...rest: TermLike[]) => Term;
@@ -46,6 +51,50 @@ export declare abstract class Kind<V> {
     abstract value(name: string, prefix?: string): V;
     abstract encode(name: string, raw: Raw): Record<string, number>;
     abstract random(name: string, rand: Rand, bound: number): Record<string, number>;
+    sample(_rand: Rand, _bound: number): Raw;
+}
+export type IntLike = Int | Term | number;
+export declare class Int {
+    readonly pos: Term;
+    readonly neg: Term;
+    constructor(pos: Term, neg: Term);
+    static of(x: IntLike): Int;
+    plus(b: IntLike): Int;
+    minus(b: IntLike): Int;
+    negate(): Int;
+    times(k: number): Int;
+    lt(b: IntLike): Cond;
+    atMost(b: IntLike): Cond;
+    gt(b: IntLike): Cond;
+    atLeast(b: IntLike): Cond;
+    eq(b: IntLike): Cond;
+    ne(b: IntLike): Cond;
+    min(b: IntLike): Int;
+    max(b: IntLike): Int;
+    get isNegative(): Cond;
+    get abs(): Term;
+    get clamped(): Term;
+}
+export type DecimalLike = Decimal | IntLike;
+export declare class Decimal {
+    readonly int: Int;
+    readonly places: number;
+    constructor(int: Int, places: number);
+    lift(b: DecimalLike): Int;
+    private with;
+    plus(b: DecimalLike): Decimal;
+    minus(b: DecimalLike): Decimal;
+    negate(): Decimal;
+    times(k: number): Decimal;
+    lt(b: DecimalLike): Cond;
+    atMost(b: DecimalLike): Cond;
+    gt(b: DecimalLike): Cond;
+    atLeast(b: DecimalLike): Cond;
+    eq(b: DecimalLike): Cond;
+    ne(b: DecimalLike): Cond;
+    min(b: DecimalLike): Decimal;
+    max(b: DecimalLike): Decimal;
+    get isNegative(): Cond;
 }
 export declare const nat: Kind<Term>;
 export declare const upTo: (maxValue: number) => Kind<Term>;
@@ -83,35 +132,112 @@ export declare class Maybe<V> {
     }): Term;
 }
 export declare const maybe: <V>(of: Kind<V>) => Kind<Maybe<V>>;
+export declare const intern: ((text: string) => number) & {
+    load(entries: [string, number][]): void;
+};
+export declare const interned: () => [string, number][];
+export declare const globMatch: (pattern: string, text: string) => boolean;
+export declare class Str {
+    readonly id: Term;
+    readonly length: Term;
+    private readonly bits;
+    constructor(id: Term, length: Term, bits: ReadonlyMap<string, Term>);
+    like(pattern: string): Cond;
+    get isEmpty(): Cond;
+    eq(b: Str | string): Cond;
+    ne(b: Str | string): Cond;
+}
+export declare const str: (opts?: {
+    like?: readonly string[];
+    maxLength?: number;
+}) => Kind<Str>;
+export declare const int: Kind<Int>;
+export declare const decimal: (places: number) => Kind<Decimal>;
 export type MapWrite = {
     readonly map: string;
     readonly key: E;
     readonly value: E;
+    readonly concrete?: {
+        key?: number;
+        value?: number;
+    };
+} | {
+    readonly map: string;
+    readonly each: string;
+    readonly value: E;
+    readonly concrete?: {
+        at: (key: Term) => TermLike;
+    };
 };
+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;
+    private readonly cells;
     constructor(name: string, init: number);
     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;
+    private readonly cells;
+    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;
 };
 type Obj = object;
 type Update<S extends Obj, M extends Obj> = Partial<{
-    [k in keyof S]: TermLike;
+    [k in keyof S]: S[k] extends Decimal ? DecimalLike : S[k] extends Int ? IntLike : TermLike;
 } & {
     [k in keyof M]: MapWrite;
 }>;
@@ -121,6 +247,11 @@ type Spec = {
     inputs: [string, Kind<unknown>][];
     state: [string, number | ((p: never) => TermLike)][];
     maps: [string, number][];
+    lists?: string[];
+    signed?: [string, number | undefined][];
+    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 +279,25 @@ 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>;
+    ints<T extends Record<string, number | ((p: P) => IntLike)>>(init: T): Rule<P, I, S & {
+        [k in keyof T]: Int;
+    }, M, F, R, Su, Q>;
+    decimals<T extends Record<string, number | string | ((p: P) => DecimalLike)>>(places: number, init: T): Rule<P, I, S & {
+        [k in keyof T]: Decimal;
+    }, M, F, R, Su, Q>;
+    private signedState;
+    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,20 +315,64 @@ 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;
+    relate(name: string, given: (a: P & I, b: P & I) => Cond | Cond[], then: (a: P & I, b: P & I) => Cond): Decision;
     private kindAssumptions;
+    private signedValue;
     private env;
+    private names;
+    private whatIs;
+    private distinct;
     get machine(): Machine;
+    crossCheck(laws: Law[], stepLaws?: StepLaw[], opts?: {
+        trials?: number;
+        depth?: number;
+        bound?: number;
+        rand?: Rand;
+    }): {
+        checked: number;
+        failure?: string;
+    };
+    private verdict;
+    private crossStep;
+    compare<St extends Record<string, number>>(reference: {
+        init: (params: {
+            [k in keyof P]: Raw;
+        }) => St;
+        step: (params: {
+            [k in keyof P]: Raw;
+        }, st: St, request: {
+            [k in keyof I]: Raw;
+        }) => St;
+    }, opts?: Draws<{
+        [k in keyof I]: Raw;
+    }> & {
+        params?: (rand: Rand) => {
+            [k in keyof P]: Raw;
+        };
+        depth?: number;
+    }): Agreement;
     encodeParams(values: {
         [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;
+    decode(st: State): Record<string, number>;
     get orderedBy(): string | undefined;
     interpreter(): {
         init: (params: {
@@ -186,16 +380,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 & {
@@ -219,6 +409,60 @@ export type Decision = {
     then: C;
     goal: Goal;
 };
+type Result<T> = {
+    [k in keyof T]: T[k] extends Cond ? Cond : T[k] extends Decimal ? Decimal : T[k] extends Int ? Int : Term;
+};
+type Value<T> = {
+    [k in keyof T]: T[k] extends Cond ? boolean : number;
+};
+export declare class Fun<P extends Obj = {}, I extends Obj = {}, O extends Obj = {}> {
+    private readonly r;
+    private readonly out?;
+    constructor(r: Rule<P, I>, out?: ((env: never) => Record<string, TermLike | Cond | Int | Decimal>) | undefined);
+    get name(): string;
+    params<K extends Kinds>(kinds: K): Fun<P & ValuesOf<K>, I, O>;
+    inputs<K extends Kinds>(kinds: K): Fun<P, I & ValuesOf<K>, O>;
+    fns<T extends Record<string, FnDef>>(defs: T): Fun<P & {
+        [k in keyof T]: (...args: TermLike[]) => Term;
+    }, I, O>;
+    facts(f: (p: P) => Record<string, Cond | Forall>): Fun<P, I, O>;
+    pre(f: (p: P) => Cond): Fun<P, I, O>;
+    assume(f: (env: P & I) => Cond): Fun<P, I, O>;
+    returns<T extends Record<string, TermLike | Cond | Int | Decimal>>(f: (env: P & I) => T): Fun<P, I, Result<T>>;
+    private result;
+    law(name: string, given: (env: P & I, out: O) => Cond | Cond[], then: (out: O, env: P & I) => Cond): Decision;
+    relate(name: string, given: (a: P & I, b: P & I) => Cond | Cond[], then: (outA: O, outB: O, a: P & I, b: P & I) => Cond): Decision;
+    compare(reference: (values: {
+        [k in keyof I]: Raw;
+    }, params: {
+        [k in keyof P]: Raw;
+    }) => Partial<Value<O>>, opts?: Draws<{
+        [k in keyof I]: Raw;
+    }> & {
+        params?: {
+            [k in keyof P]: Raw;
+        };
+    }): Agreement;
+    get rule(): Rule<P, I>;
+    private compiledRule?;
+    run(values: {
+        [k in keyof I]: Raw;
+    }, params?: {
+        [k in keyof P]?: Raw;
+    }): Value<O>;
+}
+export declare const fun: (name: string) => Fun;
+export type Agreement = {
+    checked: number;
+    failure?: string;
+};
+type Draws<T> = {
+    trials?: number;
+    bound?: number;
+    rand?: Rand;
+    edges?: T[];
+    draw?: (rand: Rand) => T;
+};
 export declare class LoopRule<P extends Obj = {}, I extends Obj = {}, S extends Obj = {}> {
     private readonly spec;
     constructor(spec: {
@@ -259,10 +503,21 @@ export type Verdict = {
     stuck?: string;
     goal?: string;
     witness?: Record<string, number>;
+    why?: string;
     trees?: Record<string, Tree>;
 };
 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 function crossCheckDecision(d: Decision, opts?: {
+    trials?: number;
+    bound?: number;
+    rand?: Rand;
+}): {
+    checked: number;
+    failure?: string;
+};
 export declare const proveLoop: (l: LoopRule<Obj, Obj, Obj>, laws: Law[]) => Verdict;