gdp-wired 0.19.0 → 0.21.0

package/dist/core/data.d.ts

@@ -6,8 +6,14 @@ export declare const self: {
 };
 export declare const natural: "nat";
 export declare const boolean: "bool";
-type FieldSort = 'nat' | 'self';
-export type Sort = 'nat' | 'bool' | Data;
+export declare const integer: "int";
+export type FieldSort = 'nat' | 'int' | {
+    data: string;
+};
+export type Sort = 'nat' | 'bool' | 'int' | Data;
+export declare const isDataField: (s: FieldSort) => s is {
+    data: string;
+};
 export type Ctor = {
     name: string;
     fields: {
@@ -29,6 +35,35 @@ export type X = {
     op: 'mul';
     k: number;
     a: X;
+} | {
+    op: 'prod';
+    a: X;
+    b: X;
+} | {
+    op: 'mod' | 'div';
+    k: number;
+    a: X;
+} | {
+    op: 'int';
+    value: number;
+} | {
+    op: 'iadd' | 'isub';
+    a: X;
+    b: X;
+} | {
+    op: 'ineg';
+    a: X;
+} | {
+    op: 'imul';
+    k: number;
+    a: X;
+} | {
+    op: 'ofnat';
+    a: X;
+} | {
+    op: 'imod' | 'idiv';
+    k: number;
+    a: X;
 } | {
     op: 'if';
     c: Y;
@@ -51,6 +86,12 @@ export type X = {
         binds: string[];
         body: X;
     }[];
+} | {
+    op: 'natmatch';
+    of: X;
+    zero: X;
+    pred: string;
+    succ: X;
 } | {
     op: 'apply';
     param: string;
@@ -58,11 +99,19 @@ export type X = {
 } | {
     op: 'bool';
     c: Y;
+} | {
+    op: 'size';
+    data: string;
+    of: X;
 };
 export type Y = {
     op: '<' | '<=' | '=';
     a: X;
     b: X;
+} | {
+    op: 'i<' | 'i<=';
+    a: X;
+    b: X;
 } | {
     op: 'and' | 'or';
     xs: Y[];
@@ -78,20 +127,48 @@ export type Y = {
     op: 'holds';
     x: X;
 };
+export declare const bindName: (field: string) => string;
 export declare class Nat {
     readonly x: X;
     constructor(x: X);
     plus(b: NatLike): Nat;
     minus(b: NatLike): Nat;
     times(k: number): Nat;
+    mul(b: NatLike): Nat;
+    modBy(k: number): Nat;
+    divBy(k: number): Nat;
+    toInt(): Integer;
     lt(b: NatLike): Bool;
     atMost(b: NatLike): Bool;
     gt(b: NatLike): Bool;
     atLeast(b: NatLike): Bool;
     eq(b: NatLike): Bool;
     ne(b: NatLike): Bool;
+    match(cases: {
+        zero: () => Nat | Bool | Val | Integer | number;
+        succ: (f: {
+            pred: Nat;
+        }) => Nat | Bool | Val | Integer | number;
+    }): any;
 }
 export type NatLike = Nat | number;
+export declare class Integer {
+    readonly x: X;
+    constructor(x: X);
+    plus(b: IntegerLike): Integer;
+    minus(b: IntegerLike): Integer;
+    negate(): Integer;
+    times(k: number): Integer;
+    modBy(k: number): Integer;
+    divBy(k: number): Integer;
+    lt(b: IntegerLike): Bool;
+    atMost(b: IntegerLike): Bool;
+    gt(b: IntegerLike): Bool;
+    atLeast(b: IntegerLike): Bool;
+    eq(b: IntegerLike): Bool;
+    ne(b: IntegerLike): Bool;
+}
+export type IntegerLike = Integer | number;
 export declare class Bool {
     readonly y: Y;
     constructor(y: Y);
@@ -107,26 +184,40 @@ 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;
+    match(cases: Record<string, (fields: Record<string, any>) => Nat | Bool | Val | Integer | number>): any;
     is(ctor: string): Bool;
+    size(): Nat;
     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 const wrap: (s: Sort, x: X) => Nat | Bool | Val | Integer;
+export declare function when<T extends Nat | Val | Bool | Integer | number>(c: Bool, a: T, b: T): T extends number ? Nat : T;
+export declare const dataNamed: (name: string) => Data;
+export declare const fieldSort: (f: {
+    sort: FieldSort;
+}) => Sort;
+export declare const inGroup: (d: Data, f: {
+    sort: FieldSort;
+}) => boolean;
 export declare class Data {
     readonly name: string;
+    readonly group: string[];
     readonly ctors: Ctor[];
-    constructor(name: string, decl: Record<string, Record<string, typeof self | 'nat' | {
-        nat: true;
-    }>>);
+    readonly seq: number;
+    constructor(name: string, decl: Record<string, Record<string, FieldSort>>, group?: string[]);
     index(ctor: string): number;
     get nullary(): number;
-    make(ctor: string, ...args: (Val | NatLike)[]): Val;
+    make(ctor: string, ...args: (Val | NatLike | Integer)[]): Val;
+    ctorHeight(c: Ctor): number;
+    get height(): number;
 }
+export declare function weakOrder(ds: Data[]): Map<string, number>;
 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;
+    [c in keyof D]: keyof D[c] extends never ? Val : (...args: (Val | NatLike | Integer)[]) => Val;
+};
+export declare function mutual<const G extends Record<string, Decl>>(decls: G): {
+    [n in keyof G]: Data & Record<string, any>;
 };
 export type Fn = {
     name: string;
@@ -136,16 +227,44 @@ export type Fn = {
     }[];
     ret: Sort;
     body: () => X;
-    decreases?: number;
+    readonly decreases?: number;
+    readonly ring: string[];
     paramFns: string[];
+    readonly measure?: Measure;
+    readonly termination?: Termination;
+    stated?: Measure;
 };
-export type Callable = ((...args: (Val | NatLike | Bool)[]) => any) & {
+export type Callable = ((...args: (Val | NatLike | Bool | Integer)[]) => 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 function define(name: string, params: Record<string, Sort>, ret: Sort, body: (args: Record<string, any>) => Nat | Bool | Val | Integer | number, opts?: {
+    measure?: (string | string[])[];
+}): Callable;
 export declare const fnParam: (name: string) => ((x: NatLike) => Nat) & {
     param: string;
 };
+export type Measure = {
+    comps: {
+        coef: number[];
+        c: number;
+    }[];
+};
+export type Termination = {
+    measure: Measure;
+    text: string;
+    obligations: {
+        law: DataLaw;
+        proof?: CyclicVerdict;
+        scheme?: string;
+        lemmas: string[];
+    }[];
+    ms: number;
+};
+export declare const terminationMs: {
+    ms: number;
+};
+export declare const showMeasure: (f: Pick<Fn, "params">, m: Measure) => string;
+export declare function measureX(f: Pick<Fn, 'params'>, c: Measure['comps'][number], args: X[]): X;
 export type DataLaw = {
     name: string;
     vars: {
@@ -161,8 +280,16 @@ export type Value = 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 fnNamed: (name: string) => Fn | undefined;
+export declare class EvalLimit extends RangeError {
+}
+export declare const evalBounds: {
+    on: boolean;
+    depth: number;
+    calls: number;
+};
+export declare function evalX(x: X, env: Env, params: Record<string, (n: number) => number>, d?: number): Value;
+export declare function evalY(y: Y, env: Env, params: Record<string, (n: number) => number>, d?: number): boolean;
 export declare const showValue: (d: Sort, v: Value) => string;
 type Rand = () => number;
 export declare const rng: (seed: number) => Rand;
@@ -177,6 +304,7 @@ export declare function samples(vars: {
     sort: Sort;
 }[], paramNames: string[], n: number, seed?: number): Sample[];
 export declare const keyOf: (args: E[]) => E;
+export declare function argsOf(key: E, n: number): E[] | undefined;
 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;
@@ -184,8 +312,14 @@ export type Program = {
     datas: Data[];
     fns: Fn[];
     params: string[];
+    divisors: number[];
+    ints: boolean;
 };
 export declare function programOf(laws: DataLaw[], extra?: Fn[]): Program;
+export declare const divMap: (k: number) => string, modMap: (k: number) => string;
+export declare const zig: (z: number) => number;
+export declare const unzig: (c: number) => number;
+export declare const posMap = "int$pos", negMap = "int$neg";
 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 = {
@@ -236,6 +370,7 @@ export type DataVerdict = {
     tried: number;
     program?: Program;
     node?: number;
+    through?: string[];
 };
 export type Options = {
     samples?: number;
@@ -245,14 +380,60 @@ export type Options = {
     induction?: boolean;
     seed?: number;
     patience?: number;
+    transfer?: boolean;
 };
 export declare function refute(l: DataLaw, n?: number, seed?: number): Record<string, string> | undefined;
+type SchemeUse = {
+    subst: Record<string, E>;
+    guard: C;
+    member?: number;
+};
+type Scheme = {
+    name: string;
+    on?: {
+        v: string;
+        d: Data | 'nat';
+    };
+    uses: SchemeUse[];
+    companions?: Companion[];
+    rank?: E[];
+    shapes?: E[];
+};
+type Companion = {
+    law: DataLaw;
+    on: {
+        v: string;
+        d: Data;
+    };
+    uses: SchemeUse[];
+};
+export declare const schemesOf: (p: Program, l: DataLaw) => Scheme[];
+export type Proven = {
+    law: DataLaw;
+    spec: NodeSpec;
+    nodes: NodeSpec[];
+};
 export declare const attemptMs: {
     ms: number;
 };
+export declare const lemmaCaps: {
+    perLemma: number;
+    total: number;
+    perCase: 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 type SearchCtx = {
+    p: Program;
+    fs: Facts;
+    base: Proven[];
+    level: number;
+};
+export declare function searchIn(l: DataLaw, opts: Options, until: number, ctx?: SearchCtx, phase?: 'all' | 'first' | 'rest'): {
+    verdict: DataVerdict;
+    out?: Proven;
+};
 export declare const proveDataToday: (l: DataLaw) => DataVerdict;
 export {};