gdp-wired 0.17.0 → 0.19.0

package/dist/core/cyclic.d.ts

@@ -1,8 +1,15 @@
 import type { C, E, Law, Machine } from './machine.js';
-import type { Fold, Instances } from '../kernel/kernel.js';
+import type { Fold, Goal, Instances, StepLaw, Subst, Tree } from '../kernel/kernel.js';
 import { type CNode, type Cyclic, type Fact, type Use } from '../kernel/cyclic.js';
+import { type TStats } from './translate.js';
 export type NodeSpec = Omit<CNode, 'uses' | 'main'> & {
     uses: Omit<Use, 'premises' | 'descent'>[];
+    opaque?: E[];
+    variants?: NodeSpec[];
+    weak?: boolean;
+    slice?: boolean;
+    main?: Tree;
+    carry?: boolean;
 };
 export type CyclicVerdict = {
     proven: true;
@@ -17,7 +24,26 @@ export type CyclicVerdict = {
     stuck: string;
 };
 export declare const pair: (u: E, key: E) => E;
-export declare function proveCyclic(facts: Fact[], specs: NodeSpec[]): CyclicVerdict;
+export declare const cyclicProf: Record<string, {
+    ms: number;
+    n: number;
+    hyps: number;
+    solveMs: number;
+    rowsMs: number;
+}>;
+export declare function timedKind<T>(kind: string, hyps: number, f: () => T): T;
+export declare function reached(g: Goal, whole: (i: number) => boolean): Set<number>;
+export declare function slice(g: Goal, whole: (i: number) => boolean): (Goal & {
+    from: number[][];
+}) | undefined;
+export declare function slice(g: Goal, whole: (i: number) => boolean, hypsOnly: true): Set<number>;
+type Grown = Map<string, {
+    tree: Tree;
+    insts?: number[];
+    uses?: number[];
+}>;
+export declare const translatedCache: Grown;
+export declare function proveCyclic(facts: Fact[], specs: NodeSpec[], order0?: number[], grownBefore?: Grown, st?: TStats, made?: CNode[]): CyclicVerdict;
 export type RecurCase = {
     name: string;
     args: string[];
@@ -33,19 +59,93 @@ export type RecurCase = {
     }[];
     facts: Law[];
 };
-export declare function recurNodes(r: RecurCase): {
+export type UsualProof = {
+    m: Machine;
+    laws: Law[];
+    proof: {
+        instances: Record<string, Instances>;
+        trees: Record<string, Tree>;
+    };
+};
+export declare function recurNodes(r: RecurCase, usual?: {
+    lemmas?: UsualProof;
+    between?: UsualProof;
+}, st?: TStats): {
     facts: Fact[];
     specs: NodeSpec[];
+    why?: string;
 };
 export declare const cyclicMachine: (m: Machine, laws?: Law[]) => boolean;
-export declare function machineNodes(m: Machine, laws: Law[], instances: Record<string, Instances>): {
+export declare const uncoveredWhy: (m: Machine, laws?: Law[]) => string | undefined;
+export type UsualStep = {
+    sl: StepLaw;
+    inst: Instances;
+    goal: Goal;
+    tree: Tree;
+};
+export declare function machineNodes(m: Machine, laws: Law[], instances: Record<string, Instances>, usual?: {
+    trees: Record<string, Tree>;
+    steps?: UsualStep[];
+    lawsMade?: boolean;
+}, st?: TStats): {
     facts: Fact[];
     specs: NodeSpec[];
+    why?: string;
 };
-export declare function foldNodes(f: Fold, laws: Law[]): {
+export declare const tBack: (n: number) => E;
+export declare const tSub: (n: number) => E;
+export declare function kStepAt(m: Machine, k: number, time?: (n: number) => E): Subst;
+export declare const kWhens: (m: Machine, sl: StepLaw) => C[];
+export declare function stepLawNodes(m: Machine, laws: Law[], steps: {
+    law: StepLaw;
+    instances: Instances;
+}[], facts: Fact[], lawNodes: NodeSpec[], time?: (n: number) => E): NodeSpec[];
+export declare function allowNode(m: Machine, laws: Law[], inst: Instances, w: C, facts: Fact[], lawNodes: NodeSpec[], name: string, extra?: NodeSpec['insts']): NodeSpec;
+export declare const hasQuantified: (m: Machine) => boolean;
+export declare function skMachine(m: Machine): Machine;
+export declare function qflagFacts(m: Machine): Fact[];
+export declare function closingInsts(m: Machine, facts: Fact[], insts: Instances[], times: E[], laws?: Law[]): NodeSpec['insts'];
+export declare function qflagNodes(m: Machine, laws: Law[], instances: Record<string, Instances>): {
     facts: Fact[];
     specs: NodeSpec[];
+    why?: string;
+};
+export declare function foldNodes(f: Fold, laws: Law[], usual?: Record<string, Tree>, st?: TStats): {
+    facts: Fact[];
+    specs: NodeSpec[];
+    why?: string;
 };
 export declare const cyclicOn: () => boolean;
+export declare const cycLog: (o: object) => void;
 export declare const quietly: <T>(f: () => T) => T;
-export declare function crossCyclic(kind: string, name: string, usual: boolean, run: () => CyclicVerdict, usualMs?: number): void;
+export type Translated = (st: TStats) => {
+    verdict?: CyclicVerdict;
+    why?: string;
+};
+export declare function translatedProof(key: () => string, build: (reused: boolean) => {
+    facts: Fact[];
+    specs: NodeSpec[];
+    why?: string;
+}, st: TStats, base?: () => string): {
+    verdict?: CyclicVerdict;
+    why?: string;
+};
+export declare const routeOf: () => string;
+export declare function crossCyclic(kind: string, name: string, usual: boolean, run0: (() => CyclicVerdict) | undefined, usualMs?: number, translated?: Translated): void;
+export declare const certOn: () => boolean;
+export declare const certSearch: () => boolean;
+export declare const certMs: () => number;
+export declare function certCyclic(kind: string, name: string, translated: Translated | undefined, run0: (() => CyclicVerdict) | undefined, usualMs?: number): {
+    checked: boolean;
+    proof?: Cyclic;
+};
+export declare function searchedStepNodes(m: Machine, laws: Law[], steps: {
+    law: StepLaw;
+    instances: Instances;
+}[], facts: Fact[], lawNodes: NodeSpec[]): NodeSpec[];
+export declare const reqTS: (req: [string, E][]) => C;
+export declare function withWitness<R>(m: Machine, request: Record<string, E>, attempt: (wit: [string, E][]) => R | undefined): {
+    wit: [string, E][];
+    out: R;
+} | undefined;
+export {};