/**
 * SdfConjecture — the proof-carrying-SDF sub-class of the Conjecture Engine.
 *
 * A signed distance field is "well-formed" when it is 1-Lipschitz:
 * |f(a) - f(b)| <= |a - b| for all points a, b. True distance functions (sphere,
 * box, …) satisfy this exactly; many popular "SDFs" (gyroid, fractal estimators)
 * are only bounds and violate it — which is why ray-marchers need a per-shape
 * Lipschitz fudge factor. This sub-class carries the 1-Lipschitz invariant as
 * receipt evidence, computed by adversarially sampling the JS-side
 * `evaluateSDFNode` over a deterministic point-pair lattice.
 *
 * HONEST ASYMMETRY (W.511): empirical sampling is SOUND for falsification — a
 * sampled pair with ratio > 1 IS a genuine counterexample — but only EVIDENCE
 * for survival: "no violation found in the sample" is NOT a proof of global
 * 1-Lipschitzness (a violation could hide between sample points). A true proof
 * is Lean-tier / interval-arithmetic (out of receipt-tier scope). So `survived`
 * here means receipt-carrying evidence; `falsified` means a sound counterexample.
 *
 * Built on the shipped SDFPointEvaluator (commit b090bc4a5) and the generic
 * `buildConjectureStableKey` receipt primitive.
 */
import { type SDFNode, type SDFPoint } from './SDFPointEvaluator';
export declare const PROOF_CARRYING_SDF_V1: "conjecture.geometry.proof-carrying-sdf.v1";
export type ProofCarryingSdfSolverType = typeof PROOF_CARRYING_SDF_V1;
export type SdfConjectureStatus = 'survived' | 'falsified' | 'undecided';
export type SdfProbeStatus = 'pass' | 'fail';
/** Default Lipschitz tolerance: ratios up to 1 + this are treated as 1-Lipschitz. */
export declare const LIPSCHITZ_TOLERANCE = 0.001;
export interface SdfConjectureCandidate {
    id: string;
    family: string;
    node: SDFNode;
    parameters?: Readonly<Record<string, number | string>>;
}
export interface LipschitzWitness {
    a: SDFPoint;
    b: SDFPoint;
    fa: number;
    fb: number;
    distance: number;
    ratio: number;
}
export interface LipschitzResult {
    maxRatio: number;
    witness: LipschitzWitness | null;
    pairsSampled: number;
}
export interface SdfEvaluation {
    candidateId: string;
    family: string;
    status: SdfProbeStatus;
    maxRatio: number;
    witness: LipschitzWitness | null;
    message: string;
}
export interface SdfCounterexample {
    candidateId: string;
    family: string;
    witness: LipschitzWitness;
}
export interface SdfScenario {
    id: string;
    role: 'survivor' | 'falsifier';
    statement: string;
    evaluations: ReadonlyArray<SdfEvaluation>;
    status: SdfConjectureStatus;
    counterexamples: ReadonlyArray<SdfCounterexample>;
}
export interface ProofCarryingSdfReceipt {
    solverType: ProofCarryingSdfSolverType;
    specVersion: 1;
    tolerance: number;
    scenarios: ReadonlyArray<SdfScenario>;
    gate: {
        survivorScenarioId: string | null;
        falsifierScenarioId: string | null;
        passed: boolean;
    };
    receiptKey: string;
}
export interface ProofCarryingSdfOptions {
    tolerance?: number;
}
/**
 * Compute the maximum sampled Lipschitz ratio |f(a)-f(b)|/|a-b| for an SDF node,
 * returning the worst witnessing pair. Non-finite evaluations are skipped.
 */
export declare function empiricalLipschitzRatio(node: SDFNode): LipschitzResult;
/** A true-distance sphere of given radius — exact, 1-Lipschitz. */
export declare function sphereCandidate(radius: number): SdfConjectureCandidate;
/** A gyroid — an implicit-surface function, NOT a true distance; not 1-Lipschitz. */
export declare function gyroidCandidate(scale: number): SdfConjectureCandidate;
export declare function generateSphereFamily(radii?: ReadonlyArray<number>): ReadonlyArray<SdfConjectureCandidate>;
export declare function generateGyroidFamily(scales?: ReadonlyArray<number>): ReadonlyArray<SdfConjectureCandidate>;
/**
 * Run the proof-carrying-SDF conjecture sub-class end to end: a survivor family
 * (true-distance spheres — 1-Lipschitz) and a discovering falsifier family
 * (gyroids — implicit-surface functions whose sampled gradient exceeds 1). The
 * gate passes when the survivor family shows no violation AND the falsifier family
 * yields at least one sound counterexample pair. Deterministic receipt key.
 */
export declare function runProofCarryingSdfConjecture(options?: ProofCarryingSdfOptions): ProofCarryingSdfReceipt;
//# sourceMappingURL=SdfConjecture.d.ts.map