gdp-wired 0.8.0 → 0.10.0

package/README.md

@@ -67,6 +67,10 @@ All of these are proven automatically, and each proof is also a Lean theorem:
 - **Records and variants**: inputs, state, results, map cells and list items made of named fields, or one of several
   cases each with fields of its own (a payment by card or in cash, a seat free, held or sold), every case covered
   (`examples/datatypes.ts`).
+- **Lists a request carries, and trees**: an invoice's lines, with folds over them (the total, the taxable part) and
+  lemmas about the folds proven by induction over the lines (`examples/invoices.ts`); a fold over a tree as a value (a
+  spend roll-up over an org chart, sign-offs over a document's sections), its laws proven by induction over the tree
+  (`examples/folds.ts`).
 - **Pure functions and two-run laws**: laws about what a function returns, and laws comparing two calls, like "the
   secret never changes the answer". `examples/jev-fabric/` ports a Bend project's policy core and proves all 59 laws its
   Bend proofs state.
@@ -209,13 +213,28 @@ const soon = retry.law('the next try is at most 64 after the last request', ({ne
 - **Records and variants**: `record({limit: nat, blocked: bool})` hands out an object of its fields' values;
   `variant({card: {...}, cash: {...}})` a value with `is(case)` and `match({card: c => ..., cash: c => ...})`, the only
   place a case's fields are read. `Pay.make({tag: 'card', amount, verified})` builds a case to write or to pass to
-  `when`, and `same(a, b)` compares two values of one kind part by part. At runtime a record is an object of its fields
-  and a variant `{tag: 'card', ...fields}`; a field or case the kind doesn't declare is refused. Both are their fields'
+  `when`, and `same(a, b)` compares two values of one kind part by part; `optional(c, value)` is a value present where c
+  holds (a result that may be missing). At runtime a record is an object of its fields and a variant `{tag: 'card',
+  ...fields}` (or the key given, `variant({...}, {tag: 'kind'})`); a field or case the kind doesn't declare is refused.
+  What a kind keeps true of the values a step writes (a case in range, a flag 0 or 1) is a law of its own, `r.kindLaws()`,
+  which proveRule, proveSteps and proveLeadsTo prove beside the laws they are given. Both are their fields'
   variables underneath (`pay.card.amount`, and the case's index as `pay`), so the kernel, both runtimes and the Lean
   twin see nothing new. Maps and lists of them: `.maps({Acct: record({...}).from({...})})` (`Acct.at(k)`,
   `Acct.set(k, value)`, `Acct.each(k => value)`) and `.items({Queue: Job})` (`push`, `pop`, `set`, `insertAt`,
   `removeAt`, `apply`, `has`, `within`, `increasing(by)`), one map per variable of the kind; `rule.decode` reads them back
-  as objects and arrays. Not as values: recursive types (a tree).
+  as objects and arrays.
+- **Lists a request carries** (`.carriesList('Lines', Line, folds, lemmas)`): the items one carried map per variable of
+  the kind, the length `Lines.len`, each fold (`{total: {from: 0, step: (acc, line) => acc.plus(line.amount)}}`) a
+  carried map of its running values whose equations every request is assumed to meet (the encoding computes them from the
+  array, and a request that doesn't meet them isn't allowed), read as `Lines.fold.total`; `Lines.every`, `some`, `has`,
+  `increasing(by)`, `at(i)`. A lemma about the folds (`({taxed, total}) => taxed.atMost(total)`) is proven by induction
+  over the items when the rule is built, then assumed at every prefix (`examples/invoices.ts`).
+- **Folds over trees** (`fold(name).params(...).inputs(...).leaf(env => ({...})).node((env, left, right) => ({...}))`,
+  `proveFold`): a tree as a value (`{leaf: inputs}` or `{node: inputs, left, right}`), each leaf's values from its inputs
+  and each node's from its own and its children's; a law about the values is proven by induction over the tree (the
+  kernel's leaf and node goals, Lean's `fold_sound`), `f.run(tree, params)` evaluates the terms proven and `f.crossCheck`
+  holds the builders to them (`examples/folds.ts`). A tree in a rule's state, and claims that need a lemma about the
+  tree's shape nobody stated, stay Lean's.
 - **State of any kind**: `.state({open: bool.from(true), status: oneOf('new', 'done').from('new'), owner: str().from(''), note: maybe(nat).from(null)})`;
   a step writes each kind's own values, `when(c, a, b)` chooses between any two values of a kind, and `rule.decode(state)`
   reads them back as runtime values.
@@ -237,15 +256,17 @@ const soon = retry.law('the next try is at most 64 after the last request', ({ne
   own), and the Lean export takes them as the hypothesis they are, proving them where the function has a Lean
   definition. A function defined and proven in Lean is how a rule reaches past what the kernel decides: `examples/functions.ts`.
 - **Recurrences and their lemmas** (`recur(name, {args, fns, zero, next}, lemmas, between)`): f(0, a..) = zero and
-  f(x + 1, a..) = next(x, f(x, a..), a..), the further arguments `args` (up to three) fixed along the recursion, each term
-  the kernel's own or a read of a function in `fns` (`modBy(7)`, another recurrence). Each lemma is a law about every x
+  f(x + 1, a..) = next(x, f(x, a..), a..), the further arguments `args` (up to four) fixed along the recursion, each term
+  the kernel's own or a read of a function in `fns` (`modBy(7)`, another recurrence), the start's too. Each lemma is a law about every x
   and f(x), proven when the function is made, all of them together by induction (the recurrence run as a machine, each
   lemma a law of it, so one lemma may lean on another, and on the facts of the functions it reads); each law `between`
   is about every x <= y and f(x), f(y) ("never shrinks"), proven by induction on y from x, with the lemmas. One that
   isn't proven throws `Unproven` with the induction step it breaks at. The two equations, the lemmas and the laws
-  between are the function's facts. The runtimes compute f by the recurrence (x steps); the Lean export defines
-  `Recur.<name>` by it (a function of several arguments through an injective pairing, proven so in Lean) and proves
-  every fact there by induction (`examples/lemmas.ts`).
+  between are the function's facts. The runtimes compute f by the recurrence, continuing from the last value computed at
+  the same further arguments (a rule that reads f at a growing count takes one step a request); the Lean export defines
+  `Recur.<name>` by it (a function of several arguments through an injective pairing, proven so in Lean) and checks the
+  kernel's own proof of every lemma and law between: the machine it was proven by, with its trees, and the run of it that
+  reaches x and f(x), so a lemma with a product (squares: f(x) = x·x) needs no tactic of Lean's (`examples/lemmas.ts`).
 - **Liveness** (`rule.leadsTo(name, {from, to, rank, helpful})`, `proveLeadsTo`): whenever `from` holds, `to` holds later in
   every run that takes each helpful request infinitely often; proven by a rank no step raises while waiting and each
   helpful request lowers in its region. `rank` may return several terms (compared in order) and `helpful` may be a list
@@ -308,7 +329,7 @@ Lean, compiled natively, wins where the state stays small. Details in [`docs/com
 | `core/` | Machines, the interpreter and JS compiler, the builders, composition (`compose.ts`), the linear solver and its checker, Houdini invariants, models, the first Lean export |
 | `kernel/` | The trusted kernel and the untrusted prover, with soundness fuzz (`kernel.test.ts`, `history.test.ts`) |
 | `lean-kernel/` | The kernel's Lean twin, its soundness proofs, and the exported trees |
-| `examples/` | The builders at work: `domains/` (187 rules across 21 domains, each with laws and broken variants), `harness.ts` (the triple check), `readme.ts`, `budget.ts`, `gdp.ts` (gdp-ts's example, its checks proven), `datatypes.ts` (records and variants), `lemmas.ts` (recurrences and their lemmas), `composition.ts`, `sets.ts`, `quantifiers.ts`, `functions.ts`, `lists.ts`, `sizes.ts`, `liveness.ts`, `steps.ts` (laws over up to 16 steps), and `jev-fabric/` (a Bend project's 59 proven laws, ported) |
+| `examples/` | The builders at work: `domains/` (187 rules across 21 domains, each with laws and broken variants), `harness.ts` (the triple check), `readme.ts`, `budget.ts`, `gdp.ts` (gdp-ts's example, its checks proven), `datatypes.ts` (records and variants), `lemmas.ts` (recurrences and their lemmas), `invoices.ts` (lists a request carries), `folds.ts` (folds over trees), `composition.ts`, `sets.ts`, `quantifiers.ts`, `functions.ts`, `lists.ts`, `sizes.ts`, `liveness.ts`, `steps.ts` (laws over up to 16 steps), and `jev-fabric/` (a Bend project's 59 proven laws, ported) |
 | `docs/` | The comparison with Bend and Lean, and the full scope |
 | `compare/` | The same three rules in gdp-wired, Bend and plain Lean, checked and measured |
 | `research/` | Everything around the library ([`research/README.md`](research/README.md)): the GPU searches (`search/`, `hw/`, `modal-gpu/`), invariant and rank synthesis (`synth/`), relational laws and guard synthesis (`next/`), bit-vector laws (`sat/`), the enumeration and benchmarks (`enum/`, `gpu/`, `perf/`), the first Lean checker (`lean/`) and the first prototype, the audit path (`audit/`) |

package/dist/core/dsl.d.ts

@@ -1,5 +1,5 @@
 import { type C, type E, type Law, type Recurrence, type Machine, type Request, type State } from './machine.js';
-import { type Goal, type Liveness, type Loop, type StepLaw, type Tree } from '../kernel/kernel.js';
+import { type Fold, 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 {
@@ -43,7 +43,7 @@ export declare function when<K extends string>(c: Cond, then: Choice<K>, otherwi
 export declare function when(c: Cond, then: Str, otherwise: Str): Str;
 export declare function when<V>(c: Cond, then: Maybe<V>, otherwise: Maybe<V>): Maybe<V>;
 export declare function when(c: Cond, then: Cond, otherwise: Cond): Cond;
-export declare function when<C extends Cases>(c: Cond, then: Variant<C>, otherwise: Variant<C>): Variant<C>;
+export declare function when<C extends Cases, T extends string>(c: Cond, then: Variant<C, T>, otherwise: Variant<C, T>): Variant<C, T>;
 export declare function when<T extends Record<string, unknown>>(c: Cond, then: T, otherwise: T): T;
 export declare const choose: (c: Cond, then: Cond, otherwise: Cond) => Cond;
 export declare function same(a: unknown, b: unknown): Cond;
@@ -65,6 +65,7 @@ export declare abstract class Kind<V> {
     abstract assume(name: string): Cond[];
     abstract build(name: string, get: (part: string) => Term): V;
     value(name: string, at?: At): V;
+    invariant(_value: V): Cond[];
     abstract encode(name: string, raw: Raw): Record<string, number>;
     abstract random(name: string, rand: Rand, bound: number): Record<string, number>;
     abstract store(name: string, value: unknown): Record<string, TermLike>;
@@ -152,6 +153,7 @@ export declare class Maybe<V> {
     }): Term;
 }
 export declare const maybe: <V>(of: Kind<V>) => Kind<Maybe<V>>;
+export declare const optional: <V>(c: Cond, value: V) => Maybe<V>;
 type Fields = Record<string, Kind<unknown>>;
 export declare const record: <const K extends Fields>(fields: K) => Kind<ValuesOf<K>>;
 type Cases = Record<string, Fields>;
@@ -161,40 +163,41 @@ type CaseValues<C extends Cases> = {
 type MatchCases<C extends Cases, T> = {
     [k in keyof C]: (fields: ValuesOf<C[k]>) => T;
 };
-export declare class Variant<C extends Cases = Cases> {
+export declare class Variant<C extends Cases = Cases, T extends string = 'tag'> {
     readonly tag: Term;
     readonly cases: CaseValues<C>;
-    readonly kind: VariantKind<C>;
-    constructor(tag: Term, cases: CaseValues<C>, kind: VariantKind<C>);
+    readonly kind: VariantKind<C, T>;
+    constructor(tag: Term, cases: CaseValues<C>, kind: VariantKind<C, T>);
     is(k: keyof C & string): Cond;
     match(cases: MatchCases<C, Cond>): Cond;
     match(cases: MatchCases<C, TermLike>): Term;
     match<T>(cases: MatchCases<C, T>): T;
 }
-export type VariantWrite<C extends Cases> = {
+export type VariantWrite<C extends Cases, T extends string = 'tag'> = {
     [k in keyof C]: {
-        [f in 'tag' | keyof C[k]]: f extends 'tag' ? k : C[k][f] extends Kind<infer V> ? Writes<V> : never;
+        [f in T | keyof C[k]]: f extends T ? k : C[k][f] extends Kind<infer V> ? Writes<V> : never;
     };
 }[keyof C];
-export declare class VariantKind<C extends Cases> extends Kind<Variant<C>> {
+export declare class VariantKind<C extends Cases, T extends string = 'tag'> extends Kind<Variant<C, T>> {
     readonly cases: C;
+    readonly tagKey: T;
     readonly names: (keyof C & string)[];
-    readonly tagKey = "tag";
-    constructor(cases: C);
+    constructor(cases: C, tagKey: T);
     index(k: string): number;
     private payload;
     private filled;
     private at;
     vars(name: string): string[];
     assume(name: string): Cond[];
-    build(name: string, get: (part: string) => Term): Variant<C>;
-    make(write: VariantWrite<C>): Variant<C>;
+    build(name: string, get: (part: string) => Term): Variant<C, T>;
+    invariant(x: Variant<C, T>): Cond[];
+    make(write: VariantWrite<C, T>): Variant<C, T>;
     store(name: string, value: unknown): Record<string, TermLike>;
     decode(name: string, vars: Record<string, number>): {
-        tag: keyof C & string;
+        [x: string]: (keyof C & string) | Raw;
     };
     empty(): {
-        tag: keyof C & string;
+        [x: string]: (keyof C & string) | Raw;
     };
     encode(name: string, raw: Raw): {
         [x: string]: number;
@@ -203,10 +206,13 @@ export declare class VariantKind<C extends Cases> extends Kind<Variant<C>> {
         [x: string]: number;
     };
     sample(rand: Rand, bound: number): {
-        tag: keyof C & string;
+        [x: string]: (keyof C & string) | Raw;
     };
 }
-export declare const variant: <const C extends Cases>(cases: C) => VariantKind<C>;
+export declare function variant<const C extends Cases>(cases: C): VariantKind<C>;
+export declare function variant<const C extends Cases, const T extends string>(cases: C, opts: {
+    tag: T;
+}): VariantKind<C, T>;
 export declare const intern: ((text: string) => number) & {
     load(entries: [string, number][]): void;
 };
@@ -304,6 +310,35 @@ export type ItemsOp = {
     readonly parts: Record<string, ListOp>;
     readonly len: TermLike;
 };
+export type ListFold<V> = {
+    from: number;
+    step: (acc: Term, item: V) => TermLike;
+};
+export type ListLemma = (acc: Record<string, Term>, i: Term) => Cond;
+export declare class CarriedList<V, Fd extends string = never> {
+    readonly name: string;
+    readonly kind: Kind<V>;
+    readonly len: Term;
+    readonly folds: Record<Fd, ListFold<V>>;
+    private readonly map;
+    readonly lemmas: Record<string, ListLemma>;
+    readonly fold: Record<Fd, Term>;
+    constructor(name: string, kind: Kind<V>, len: Term, folds: Record<Fd, ListFold<V>>, map: (part: string) => MapRef, lemmas?: Record<string, ListLemma>);
+    at(i: TermLike): V;
+    after(fold: Fd, i: TermLike): Term;
+    every(f: (item: V, i: Term) => Cond): Cond;
+    some(f: (item: V, i: Term) => Cond): Cond;
+    has(x: V): Cond;
+    increasing(by: (item: V) => Term): Cond;
+    equations(): Cond[];
+    private running;
+    prove(): Verdict;
+    get maps(): string[];
+    encode(raw: Raw): {
+        maps: Record<string, Map<number, number>>;
+        len: number;
+    };
+}
 export declare class ItemsRef<V> {
     readonly name: string;
     readonly kind: Kind<V>;
@@ -326,7 +361,7 @@ export declare class ItemsRef<V> {
 export type Forall = {
     readonly forall: (key: Term, ...more: Term[]) => Cond;
 };
-export declare function forall(f: (key: Term, key2: Term, key3: Term, key4: Term) => Cond): Forall;
+export declare function forall(f: (key: Term, key2: Term, key3: Term, key4: Term, key5: Term, key6: Term) => Cond): Forall;
 export type Relation = {
     readonly when: Cond;
     readonly holds: Cond;
@@ -356,9 +391,7 @@ type RecurEnv<A extends string, U> = {
 export type RecurDef<A extends string, U extends Record<string, FnDef>> = {
     args?: readonly A[];
     fns?: U;
-    zero: TermLike | ((env: {
-        [a in A]: Term;
-    }) => TermLike);
+    zero: TermLike | ((env: RecurEnv<A, U>) => TermLike);
     next: (x: Term, prev: Term, env: RecurEnv<A, U>) => TermLike;
 };
 export declare const recur: <const A extends string = never, U extends Record<string, FnDef> = {}>(name: string, def: RecurDef<A, U>, lemmas?: Record<string, (x: Term, fx: Term, env: RecurEnv<A, U>) => Cond>, between?: Record<string, (x: Term, fx: Term, y: Term, fy: Term, env: RecurEnv<A, U>) => Cond>) => FnDef & {
@@ -369,7 +402,7 @@ type ValuesOf<K extends Kinds> = {
     [n in keyof K]: K[n] extends Kind<infer V> ? V : never;
 };
 type Obj = object;
-type Writes<V> = V extends Decimal ? DecimalLike | string : V extends Int ? IntLike : V extends Cond ? Cond | boolean : V extends Choice<infer K> ? Choice<K> | K : V extends Maybe<infer W> ? Maybe<W> | Writes<W> | null : V extends Str ? Str | string : V extends Variant<infer C> ? Variant<C> | VariantWrite<C> : V extends Term ? TermLike : V extends Record<string, unknown> ? {
+type Writes<V> = V extends Decimal ? DecimalLike | string : V extends Int ? IntLike : V extends Cond ? Cond | boolean : V extends Choice<infer K> ? Choice<K> | K : V extends Maybe<infer W> ? Maybe<W> | Writes<W> | null : V extends Str ? Str | string : V extends Variant<infer C, infer T> ? Variant<C, T> | VariantWrite<C, T> : V extends Term ? TermLike : V extends Record<string, unknown> ? {
     [k in keyof V]: Writes<V[k]>;
 } : TermLike;
 type Update<S extends Obj, M extends Obj> = Partial<{
@@ -388,6 +421,7 @@ type Spec = {
     items?: [string, Kind<unknown>][];
     kinded?: [string, Kind<unknown>][];
     carried?: string[];
+    lists2?: [string, Kind<unknown>, Record<string, ListFold<unknown>>, Record<string, ListLemma>][];
     fns?: [string, FnDef][];
     facts?: ((env: never) => Record<string, Cond | Forall>)[];
     flags: ((env: never) => Record<string, Cond>)[];
@@ -440,6 +474,9 @@ export declare class Rule<P extends Obj = {}, I extends Obj = {}, S extends Obj
     carries<const N extends string>(...names: N[]): Rule<P, I & {
         [k in N]: MapRef;
     }, S, M, F, R, Su, Q>;
+    carriesList<const N extends string, V, Fd extends string = never>(name: N, of: Kind<V>, folds?: Record<Fd, ListFold<V>>, lemmas?: Record<string, (acc: Record<Fd, Term>, i: Term) => Cond>): Rule<P, I & {
+        [k in N]: CarriedList<V, Fd>;
+    }, 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>;
@@ -458,6 +495,7 @@ export declare class Rule<P extends Obj = {}, I extends Obj = {}, S extends Obj
     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;
+    kindLaws(): 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;
     leadsTo(name: string, spec: {
@@ -511,7 +549,7 @@ 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]: I[k] extends MapRef ? ReadonlySet<number> | readonly number[] | ReadonlyMap<number, number> : Raw;
+        [k in keyof I]: I[k] extends MapRef ? ReadonlySet<number> | readonly number[] | ReadonlyMap<number, number> : I[k] extends CarriedList<any, any> ? readonly Raw[] : Raw;
     }): Request;
     randomParams(rand: Rand, bound: number): Record<string, number>;
     randomInput(rand: Rand, bound: number): Request;
@@ -552,18 +590,18 @@ export type Decision = {
     then: C;
     goal: Goal;
 };
-type ResultOf<V> = 0 extends 1 & V ? Term : [V] extends [Cond] ? Cond : [V] extends [Decimal] ? Decimal : [V] extends [Int] ? Int : [V] extends [Choice<infer K>] ? Choice<K> : [V] extends [Str] ? Str : [V] extends [Variant<infer C>] ? Variant<C> : [V] extends [Term | number] ? Term : [V] extends [Record<string, unknown>] ? {
+type ResultOf<V> = 0 extends 1 & V ? Term : [V] extends [Cond] ? Cond : [V] extends [Decimal] ? Decimal : [V] extends [Int] ? Int : [V] extends [Choice<infer K>] ? Choice<K> : [V] extends [Str] ? Str : [V] extends [Variant<infer C, infer T>] ? Variant<C, T> : [V] extends [Maybe<infer W>] ? Maybe<ResultOf<W>> : [V] extends [Term | number] ? Term : [V] extends [Record<string, unknown>] ? {
     [f in keyof V]: ResultOf<V[f]>;
 } : Term;
 type Result<T> = {
     [k in keyof T]: ResultOf<T[k]>;
 };
-type ValueOf<V> = 0 extends 1 & V ? number : [V] extends [Cond] ? boolean : [V] extends [Choice<infer K>] ? K : [V] extends [Str] ? string : [V] extends [Variant<infer C>] ? CaseRaw<C> : [V] extends [Term | number | Int | Decimal] ? number : [V] extends [Record<string, unknown>] ? {
+type ValueOf<V> = 0 extends 1 & V ? number : [V] extends [Cond] ? boolean : [V] extends [Choice<infer K>] ? K : [V] extends [Str] ? string : [V] extends [Variant<infer C, infer T>] ? CaseRaw<C, T> : [V] extends [Maybe<infer W>] ? ValueOf<W> | null : [V] extends [Term | number | Int | Decimal] ? number : [V] extends [Record<string, unknown>] ? {
     [f in keyof V]: ValueOf<V[f]>;
 } : number;
-type CaseRaw<C extends Cases> = {
+type CaseRaw<C extends Cases, T extends string = 'tag'> = {
     [k in keyof C]: {
-        tag: k;
+        [t in T]: k;
     } & {
         [f in keyof C[k]]: C[k][f] extends Kind<infer V> ? ValueOf<V> : never;
     };
@@ -571,7 +609,7 @@ type CaseRaw<C extends Cases> = {
 type Value<T> = {
     [k in keyof T]: ValueOf<T[k]>;
 };
-type Field = Term | Cond | Int | Decimal | Choice<string> | Str | Variant<any> | {
+type Field = Term | Cond | Int | Decimal | Choice<string> | Str | Variant<any, any> | Maybe<any> | {
     [f: string]: Field | number;
 };
 export declare class Fun<P extends Obj = {}, I extends Obj = {}, O extends Obj = {}> {
@@ -685,3 +723,55 @@ export declare function crossCheckDecision(d: Decision, opts?: {
     failure?: string;
 };
 export declare const proveLoop: (l: LoopRule<Obj, Obj, Obj>, laws: Law[]) => Verdict;
+export type TreeValue<I> = {
+    leaf: I;
+} | {
+    node: I;
+    left: TreeValue<I>;
+    right: TreeValue<I>;
+};
+type FoldSpec = {
+    name: string;
+    params: [string, Kind<unknown>][];
+    inputs: [string, Kind<unknown>][];
+    pre: ((p: never) => Cond)[];
+    assume: ((env: never) => Cond)[];
+    leaf?: (env: never) => Record<string, TermLike>;
+    node?: (env: never, left: never, right: never) => Record<string, TermLike>;
+};
+export declare class FoldRule<P extends Obj = {}, I extends Obj = {}, S extends Obj = {}> {
+    private readonly spec;
+    constructor(spec: FoldSpec);
+    private with;
+    get name(): string;
+    params<K extends Kinds>(kinds: K): FoldRule<P & ValuesOf<K>, I, S>;
+    inputs<K extends Kinds>(kinds: K): FoldRule<P, I & ValuesOf<K>, S>;
+    pre(f: (p: P) => Cond): FoldRule<P, I, S>;
+    assume(f: (env: P & I) => Cond): FoldRule<P, I, S>;
+    leaf<T extends Record<string, TermLike>>(f: (env: P & I) => T): FoldRule<P, I, {
+        [k in keyof T]: Term;
+    }>;
+    node(f: (env: P & I, left: S, right: S) => {
+        [k in keyof S]: TermLike;
+    }): FoldRule<P, I, S>;
+    private env;
+    private names;
+    private side;
+    law(name: string, f: (env: P & S) => Cond): Law;
+    get fold(): Fold;
+    run(tree: TreeValue<{
+        [k in keyof I]: Raw;
+    }>, params?: {
+        [k in keyof P]?: Raw;
+    }): {
+        [k in keyof S]: number;
+    };
+    crossCheck(laws?: Law[], opts?: {
+        trials?: number;
+        depth?: number;
+        bound?: number;
+        rand?: Rand;
+    }): Agreement;
+}
+export declare const fold: (name: string) => FoldRule;
+export declare const proveFold: (f: FoldRule<Obj, Obj, Obj>, laws: Law[]) => Verdict;