gdp-wired 0.16.0 → 0.18.0

package/dist/core/data.d.ts

@@ -0,0 +1,258 @@
+import type { C, E } from './machine.js';
+import { type Fact } from '../kernel/cyclic.js';
+import { type CyclicVerdict, type NodeSpec } from './cyclic.js';
+export declare const self: {
+    readonly self: true;
+};
+export declare const natural: "nat";
+export declare const boolean: "bool";
+type FieldSort = 'nat' | 'self';
+export type Sort = 'nat' | 'bool' | Data;
+export type Ctor = {
+    name: string;
+    fields: {
+        name: string;
+        sort: FieldSort;
+    }[];
+};
+export type X = {
+    op: 'var';
+    name: string;
+} | {
+    op: 'nat';
+    value: number;
+} | {
+    op: 'add' | 'sub' | 'min' | 'max';
+    a: X;
+    b: X;
+} | {
+    op: 'mul';
+    k: number;
+    a: X;
+} | {
+    op: 'if';
+    c: Y;
+    then: X;
+    else: X;
+} | {
+    op: 'call';
+    fn: string;
+    args: X[];
+} | {
+    op: 'ctor';
+    data: string;
+    ctor: number;
+    args: X[];
+} | {
+    op: 'match';
+    data: string;
+    of: X;
+    cases: {
+        binds: string[];
+        body: X;
+    }[];
+} | {
+    op: 'apply';
+    param: string;
+    arg: X;
+} | {
+    op: 'bool';
+    c: Y;
+};
+export type Y = {
+    op: '<' | '<=' | '=';
+    a: X;
+    b: X;
+} | {
+    op: 'and' | 'or';
+    xs: Y[];
+} | {
+    op: 'not';
+    x: Y;
+} | {
+    op: 'is';
+    data: string;
+    of: X;
+    ctor: number;
+} | {
+    op: 'holds';
+    x: X;
+};
+export declare class Nat {
+    readonly x: X;
+    constructor(x: X);
+    plus(b: NatLike): Nat;
+    minus(b: NatLike): Nat;
+    times(k: number): Nat;
+    lt(b: NatLike): Bool;
+    atMost(b: NatLike): Bool;
+    gt(b: NatLike): Bool;
+    atLeast(b: NatLike): Bool;
+    eq(b: NatLike): Bool;
+    ne(b: NatLike): Bool;
+}
+export type NatLike = Nat | number;
+export declare class Bool {
+    readonly y: Y;
+    constructor(y: Y);
+    and(...bs: Bool[]): Bool;
+    or(...bs: Bool[]): Bool;
+    not(): Bool;
+    implies(b: Bool): Bool;
+    iff(b: Bool): Bool;
+}
+export declare const yes: Bool;
+export declare const no: Bool;
+export declare class Val {
+    readonly data: Data;
+    readonly x: X;
+    constructor(data: Data, x: X);
+    match(cases: Record<string, (fields: Record<string, any>) => Nat | Bool | Val | number>): any;
+    is(ctor: string): Bool;
+    eq(b: Val): Bool;
+    ne(b: Val): Bool;
+}
+export declare const wrap: (s: Sort, x: X) => Nat | Bool | Val;
+export declare function when<T extends Nat | Val | Bool | number>(c: Bool, a: T, b: T): T extends number ? Nat : T;
+export declare class Data {
+    readonly name: string;
+    readonly ctors: Ctor[];
+    constructor(name: string, decl: Record<string, Record<string, typeof self | 'nat' | {
+        nat: true;
+    }>>);
+    index(ctor: string): number;
+    get nullary(): number;
+    make(ctor: string, ...args: (Val | NatLike)[]): Val;
+}
+type Decl = Record<string, Record<string, unknown>>;
+export declare function data<const D extends Decl>(name: string, decl: D): Data & {
+    [c in keyof D]: keyof D[c] extends never ? Val : (...args: (Val | NatLike)[]) => Val;
+};
+export type Fn = {
+    name: string;
+    params: {
+        name: string;
+        sort: Sort;
+    }[];
+    ret: Sort;
+    body: () => X;
+    decreases?: number;
+    paramFns: string[];
+};
+export type Callable = ((...args: (Val | NatLike | Bool)[]) => any) & {
+    fn: Fn;
+};
+export declare function define(name: string, params: Record<string, Sort>, ret: Sort, body: (args: Record<string, any>) => Nat | Bool | Val | number): Callable;
+export declare const fnParam: (name: string) => ((x: NatLike) => Nat) & {
+    param: string;
+};
+export type DataLaw = {
+    name: string;
+    vars: {
+        name: string;
+        sort: Sort;
+    }[];
+    holds: Y;
+    params: string[];
+};
+export declare function law(name: string, vars: Record<string, Sort>, holds: (vs: Record<string, any>) => Bool): DataLaw;
+export type Value = number | {
+    c: number;
+    f: Value[];
+};
+type Env = Map<string, Value>;
+export declare function evalX(x: X, env: Env, params: Record<string, (n: number) => number>): Value;
+export declare function evalY(y: Y, env: Env, params: Record<string, (n: number) => number>): boolean;
+export declare const showValue: (d: Sort, v: Value) => string;
+type Rand = () => number;
+export declare const rng: (seed: number) => Rand;
+export declare function randomValue(s: Sort, rand: Rand, size: number, natMax?: number): Value;
+export declare const randomFn: (rand: Rand, natMax?: number) => ((n: number) => number);
+export type Sample = {
+    env: Env;
+    params: Record<string, (n: number) => number>;
+};
+export declare function samples(vars: {
+    name: string;
+    sort: Sort;
+}[], paramNames: string[], n: number, seed?: number): Sample[];
+export declare const keyOf: (args: E[]) => E;
+export declare const tagMap: (d: string) => string, sizeMap: (d: string) => string;
+export declare const fieldMap: (d: Data, j: number, i: number) => string;
+export declare const ctorMap: (d: Data, j: number) => string;
+export type Program = {
+    datas: Data[];
+    fns: Fn[];
+    params: string[];
+};
+export declare function programOf(laws: DataLaw[], extra?: Fn[]): Program;
+export declare function encX(p: Program, x: X, env: Map<string, E>): E;
+export declare function encY(p: Program, y: Y, env: Map<string, E>): C;
+export type Facts = {
+    facts: Fact[];
+    at: Map<string, number>;
+    arity: Map<string, number>;
+};
+export declare function factsOf(p: Program): Facts;
+export declare function decode(d: Data, n: number): Value;
+export declare function encode(d: Data, v: Value): number;
+export declare function codeValues(p: Program): Record<string, (...xs: number[]) => number>;
+export declare const orderFacts: (p: Program) => Fact[];
+export declare class Model {
+    readonly p: Program;
+    readonly params: Record<string, (n: number) => number>;
+    private ids;
+    private vals;
+    constructor(p: Program, params: Record<string, (n: number) => number>);
+    id(d: Data, v: Value): number;
+    value(d: Data, id: number): Value;
+    code(s: Sort, v: Value): number;
+    decode(s: Sort, n: number): Value;
+    private memo;
+    read(map: string, key: number): number;
+    private terms;
+    private readNew;
+    evalE(e: E, env: Record<string, number>): number;
+    private evalNew;
+    evalC(c: C, env: Record<string, number>): boolean;
+}
+export declare const sizeOf: (d: Data, v: Value) => number;
+export declare function unkey(key: number, n: number): number[];
+export type Lemma = {
+    law: DataLaw;
+    spec?: NodeSpec;
+};
+export type DataVerdict = {
+    proven: boolean;
+    checked: boolean;
+    law: string;
+    counterexample?: Record<string, string>;
+    proof?: CyclicVerdict;
+    lemmas: string[];
+    scheme?: string;
+    ms: number;
+    goal?: string;
+    stuck?: string;
+    tried: number;
+    program?: Program;
+    node?: number;
+};
+export type Options = {
+    samples?: number;
+    depth?: number;
+    lemmas?: boolean | DataLaw[];
+    ms?: number;
+    induction?: boolean;
+    seed?: number;
+    patience?: number;
+};
+export declare function refute(l: DataLaw, n?: number, seed?: number): Record<string, string> | undefined;
+export declare const attemptMs: {
+    ms: number;
+};
+export declare function conjectures(p: Program, l: DataLaw, max?: number, maxSize?: number): DataLaw[];
+export declare const showX: (x: X) => string;
+export declare const showY: (y: Y) => string;
+export declare function proveData(l: DataLaw, opts?: Options): DataVerdict;
+export declare const proveDataToday: (l: DataLaw) => DataVerdict;
+export {};