gdp-wired 0.0.0-stage → 0.2.0

package/dist/core/dsl.d.ts

@@ -0,0 +1,268 @@
+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';
+export type TermLike = Term | number;
+export declare const termOf: (t: TermLike) => E;
+export declare class Term {
+    readonly e: E;
+    constructor(e: E);
+    plus(b: TermLike): Term;
+    minus(b: TermLike): Term;
+    times(k: number): Term;
+    mul(b: TermLike): Term;
+    lt(b: TermLike): Cond;
+    atMost(b: TermLike): Cond;
+    gt(b: TermLike): Cond;
+    atLeast(b: TermLike): Cond;
+    eq(b: TermLike): Cond;
+    ne(b: TermLike): Cond;
+}
+export declare class Cond {
+    readonly c: C;
+    constructor(c: C);
+    and(...xs: Cond[]): Cond;
+    or(...xs: Cond[]): Cond;
+    not(): Cond;
+    implies(b: Cond): Cond;
+    iff(b: Cond): Cond;
+}
+export declare const lit: (v: number) => Term;
+export declare const yes: Cond;
+export declare const no: Cond;
+export declare const all: (...cs: Cond[]) => Cond;
+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 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;
+type Rand = (k: number) => number;
+type Raw = number | boolean | string | null | undefined;
+export declare abstract class Kind<V> {
+    readonly _value: V;
+    abstract vars(name: string): string[];
+    abstract assume(name: string): Cond[];
+    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>;
+}
+export declare const nat: Kind<Term>;
+export declare const upTo: (maxValue: number) => Kind<Term>;
+export declare class Bool extends Cond {
+    readonly n: Term;
+    constructor(n: Term);
+}
+export declare const bool: Kind<Bool>;
+export declare class Choice<K extends string> {
+    readonly n: Term;
+    readonly values: readonly K[];
+    constructor(n: Term, values: readonly K[]);
+    is(k: K): Cond;
+    match(cases: {
+        [k in K]: () => Cond;
+    }): Cond;
+    match(cases: {
+        [k in K]: () => TermLike;
+    }): Term;
+}
+export declare const oneOf: <const K extends string>(...values: K[]) => Kind<Choice<K>>;
+export declare class Maybe<V> {
+    private readonly present;
+    private readonly inner;
+    constructor(present: Term, inner: V);
+    get isSome(): Cond;
+    get isNone(): Cond;
+    match(cases: {
+        none: () => Cond;
+        some: (value: V) => Cond;
+    }): Cond;
+    match(cases: {
+        none: () => TermLike;
+        some: (value: V) => TermLike;
+    }): Term;
+}
+export declare const maybe: <V>(of: Kind<V>) => Kind<Maybe<V>>;
+export type MapWrite = {
+    readonly map: string;
+    readonly key: E;
+    readonly value: E;
+};
+export declare class MapRef {
+    readonly name: string;
+    readonly init: number;
+    constructor(name: string, init: number);
+    at(key: TermLike): Term;
+    set(key: TermLike, value: TermLike): MapWrite;
+    bump(key: TermLike, c?: Cond, by?: TermLike): MapWrite;
+}
+export type Forall = {
+    readonly forall: (key: Term) => Cond;
+};
+export declare const forall: (f: (key: Term) => Cond) => Forall;
+export type Relation = {
+    readonly when: Cond;
+    readonly holds: Cond;
+};
+export declare const relation: (holds: Cond, whenever?: Cond) => Relation;
+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 M]: MapWrite;
+}>;
+type Spec = {
+    name: string;
+    params: [string, Kind<unknown>][];
+    inputs: [string, Kind<unknown>][];
+    state: [string, number | ((p: never) => TermLike)][];
+    maps: [string, number][];
+    flags: ((env: never) => Record<string, Cond>)[];
+    step?: (env: never) => Record<string, TermLike | MapWrite | undefined>;
+    pre: ((p: never) => Cond)[];
+    assume: ((env: never) => Cond)[];
+    record?: string[];
+    sums: [string, (r: never, p: never) => TermLike][];
+    queries: [string, (r: never, v: never) => TermLike][];
+    keep?: (env: never) => Cond;
+    relations?: (env: never) => Relation[];
+    prune?: {
+        order: string;
+        after: (p: never) => TermLike;
+    };
+};
+export declare class Rule<P extends Obj = {}, I extends Obj = {}, S extends Obj = {}, M extends Obj = {}, F extends Obj = {}, R extends Obj = {}, Su extends Obj = {}, Q extends Obj = {}> {
+    private readonly spec;
+    constructor(spec: Spec);
+    private with;
+    get name(): string;
+    params<K extends Kinds>(kinds: K): Rule<P & ValuesOf<K>, I, S, M, F, R, Su, Q>;
+    inputs<K extends Kinds>(kinds: K): Rule<P, I & ValuesOf<K>, S, M, F, R, Su, Q>;
+    state<T extends Record<string, number | ((p: P) => TermLike)>>(init: T): Rule<P, I, S & {
+        [k in keyof T]: Term;
+    }, M, F, R, Su, Q>;
+    maps<T extends Record<string, number>>(init: T): Rule<P, I, S, M & {
+        [k in keyof T]: MapRef;
+    }, 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>;
+    step(f: (env: P & I & S & M & F & Su & Q) => Update<S, M>): Rule<P, I, S, M, F, R, Su, Q>;
+    pre(f: (p: P) => Cond): Rule<P, I, S, M, F, R, Su, Q>;
+    assume(f: (env: P & I & S & M & F & Su & Q) => Cond): Rule<P, I, S, M, F, R, Su, Q>;
+    log<const N extends keyof I & string>(...record: N[]): Rule<P, I, S, M, F, Pick<I, N>, Su, Q>;
+    sums<T extends Record<string, (r: R, p: P) => TermLike>>(sums: T): Rule<P, I, S, M, F, R, Su & {
+        [k in keyof T]: Term;
+    }, Q>;
+    queries<T extends Record<string, (r: R, v: P & I) => TermLike>>(queries: T): Rule<P, I, S, M, F, R, Su, Q & {
+        [k in keyof T]: Term;
+    }>;
+    keep(f: (env: P & I & S & M & F & Su & Q) => Cond): Rule<P, I, S, M, F, R, Su, Q>;
+    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;
+    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;
+    decide(name: string, given: (env: P & I) => Cond | Cond[], then: (env: P & I) => Cond): Decision;
+    private kindAssumptions;
+    private env;
+    get machine(): Machine;
+    encodeParams(values: {
+        [k in keyof P]: Raw;
+    }): Record<string, number>;
+    encodeInput(values: {
+        [k in keyof I]: Raw;
+    }): Record<string, number>;
+    randomParams(rand: Rand, bound: number): Record<string, number>;
+    randomInput(rand: Rand, bound: number): Record<string, number>;
+    get orderedBy(): string | undefined;
+    interpreter(): {
+        init: (params: {
+            [x: string]: number;
+        }) => State;
+        queries: (params: {
+            [x: string]: number;
+        }, st: State, input: {
+            [x: string]: number;
+        }) => {
+            [x: string]: number;
+        };
+        step: (params: {
+            [x: string]: number;
+        }, st: State, input: {
+            [x: string]: number;
+        }) => State;
+    };
+    compiled(): {
+        init: (params: object) => State & {
+            head?: number;
+        };
+        fork: (st: State) => State;
+        step: (params: object, st: State, input: object) => State & {
+            head?: number;
+        };
+    };
+}
+export declare const rule: (name: string) => Rule;
+type AnyOf<R, K extends 'decide' | 'step' | 'law'> = R extends Rule<infer P, infer I, infer S, infer M, infer F, any, infer Su, infer Q> ? K extends 'decide' ? P & I : K extends 'law' ? P & S & M & Su : P & I & S & M & F & Su & Q : never;
+export type DecisionEnv<R> = AnyOf<R, 'decide'>;
+export type StepEnv<R> = AnyOf<R, 'step'>;
+export type LawEnv<R> = AnyOf<R, 'law'>;
+export type Decision = {
+    name: string;
+    rule: Rule<Obj>;
+    given: C[];
+    then: C;
+    goal: Goal;
+};
+export declare class LoopRule<P extends Obj = {}, I extends Obj = {}, S extends Obj = {}> {
+    private readonly spec;
+    constructor(spec: {
+        name: string;
+        params: [string, Kind<unknown>][];
+        inputs: [string, Kind<unknown>][];
+        state: [string, number | ((p: never) => TermLike)][];
+        while?: (env: never) => Cond;
+        body?: (env: never) => Record<string, TermLike | undefined>;
+        pre: ((p: never) => Cond)[];
+        assume: ((env: never) => Cond)[];
+        rank?: (env: never) => TermLike | TermLike[];
+    });
+    private with;
+    params<K extends Kinds>(kinds: K): LoopRule<P & ValuesOf<K>, I, S>;
+    inputs<K extends Kinds>(kinds: K): LoopRule<P, I & ValuesOf<K>, S>;
+    state<T extends Record<string, number | ((p: P) => TermLike)>>(init: T): LoopRule<P, I, S & {
+        [k in keyof T]: Term;
+    }>;
+    while(f: (env: P & S) => Cond): LoopRule<P, I, S>;
+    body(f: (env: P & I & S) => Partial<{
+        [k in keyof S]: TermLike;
+    }>): LoopRule<P, I, S>;
+    pre(f: (p: P) => Cond): LoopRule<P, I, S>;
+    assume(f: (env: P & I & S) => Cond): LoopRule<P, I, S>;
+    rank(f: (env: P & S) => TermLike | TermLike[]): LoopRule<P, I, S>;
+    law(name: string, f: (env: P & S) => Cond): Law;
+    private env;
+    get loop(): Loop;
+    get rankTerms(): E[];
+    randomParams(rand: Rand, bound: number): Record<string, number>;
+    randomInput(rand: Rand, bound: number): Record<string, number>;
+}
+export declare const loop: (name: string) => LoopRule;
+export type Verdict = {
+    proven: boolean;
+    checked: boolean;
+    stuck?: string;
+    goal?: string;
+    witness?: Record<string, number>;
+    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 declare const proveDecision: (d: Decision) => Verdict;
+export declare const proveLoop: (l: LoopRule<Obj, Obj, Obj>, laws: Law[]) => Verdict;