/**
 * `conjecture.v1` turns mathematical or geometric claims into executable
 * witnesses: candidate geometry, invariant probes, counterexamples, and a
 * deterministic receipt. It is intentionally small; the value is the loop:
 * propose -> test -> preserve survivors and failures as evidence.
 */
import { type HashMode } from './hashes';
export declare const CONJECTURE_V1: "conjecture.v1";
export type ConjectureV1SolverType = typeof CONJECTURE_V1;
export type ConjectureKind = 'geometry.invariant' | 'algebraic.trait' | 'impossibility.boundary';
export type ConjectureStatus = 'out-of-scope' | 'undecided' | 'survived' | 'falsified' | 'rediscovered';
export type ProbeStatus = 'pass' | 'fail' | 'inconclusive';
export type ConjectureParameterValue = string | number | boolean | null;
export declare const CONJECTURE_NOVELTY_THRESHOLD = 0.995;
export interface ConjecturePriorArtEntry {
    id: string;
    statement: string;
    source: string;
    title?: string;
}
export interface ConjectureNoveltyMatch {
    priorArtId: string;
    source: string;
    title?: string;
    statement: string;
    similarity: number;
    threshold: number;
}
export interface ConjectureNoveltyAssessment {
    provider: 'holoembed';
    status: 'novel' | 'near-duplicate' | 'not-checked';
    threshold: number;
    corpusSize: number;
    query: string;
    nearest: ConjectureNoveltyMatch | null;
}
export declare const DEFAULT_CONJECTURE_PRIOR_ART_CORPUS: ReadonlyArray<ConjecturePriorArtEntry>;
export interface ConjectureClaim {
    id: string;
    kind: ConjectureKind;
    statement: string;
    assumptions: ReadonlyArray<string>;
    evidenceRefs: ReadonlyArray<string>;
    proposedBy: string;
    falsifiability?: ConjectureFalsifiabilityGate;
}
export type ConjectureFalsifiabilityStatus = 'falsifiable-in-principle' | 'out-of-scope';
export interface ConjectureFalsifiabilityGate {
    status: ConjectureFalsifiabilityStatus;
    reason: string;
    accessiblePredictions?: ReadonlyArray<string>;
    evidenceRefs?: ReadonlyArray<string>;
}
export interface ConjectureIntakeAssessment extends ConjectureFalsifiabilityGate {
    stage: 'INTAKE';
}
export interface GeometryConjectureCandidate {
    id: string;
    family: string;
    vertices: Float32Array | Float64Array;
    elements: Uint32Array;
    elementArity?: 3 | 4;
    semanticTags?: ReadonlyArray<string>;
    parameters?: Readonly<Record<string, ConjectureParameterValue>>;
}
export interface MeshFacts {
    geometryHash: string;
    vertexCount: number;
    elementCount: number;
    elementArity: 3 | 4 | null;
    hasNonFiniteVertex: boolean;
    minEdgeLength: number | null;
    maxEdgeLength: number | null;
    minTriangleArea: number | null;
    totalTriangleArea: number | null;
    minTetVolume: number | null;
    eulerCharacteristic: number | null;
}
export interface ConjectureProbePredicate {
    id: string;
    statement: string;
    passCriteria: string;
    failMeaning: string;
    measurementKeys: ReadonlyArray<string>;
}
export interface ConjectureProbeEvaluationResult {
    probeId: string;
    status: ProbeStatus;
    message: string;
    measurements?: Readonly<Record<string, ConjectureParameterValue>>;
}
export interface ProbeResult extends ConjectureProbeEvaluationResult {
    predicate: ConjectureProbePredicate;
}
export interface ConjectureProbe {
    id: string;
    description: string;
    predicate: ConjectureProbePredicate;
    evaluate(candidate: GeometryConjectureCandidate, facts: MeshFacts): ConjectureProbeEvaluationResult;
}
export interface CandidateEvaluation {
    candidateId: string;
    family: string;
    semanticTags: ReadonlyArray<string>;
    parameters: Readonly<Record<string, ConjectureParameterValue>>;
    facts: MeshFacts;
    probeResults: ReadonlyArray<ProbeResult>;
    novelty: ConjectureNoveltyAssessment;
    status: ConjectureStatus;
}
export interface ConjectureCounterexample {
    candidateId: string;
    family: string;
    failedProbes: ReadonlyArray<ProbeResult>;
    geometryHash: string;
}
export interface ConjectureReceipt {
    solverType: ConjectureV1SolverType;
    specVersion: 1;
    claim: ConjectureClaim;
    intake: ConjectureIntakeAssessment;
    status: ConjectureStatus;
    receiptKey: string;
    hashMode: HashMode;
    evaluations: ReadonlyArray<CandidateEvaluation>;
    counterexamples: ReadonlyArray<ConjectureCounterexample>;
}
export declare function buildConjectureStableKey(prefix: string, snapshot: unknown): string;
export declare function assessConjectureNovelty(query: string, corpus?: ReadonlyArray<ConjecturePriorArtEntry>, threshold?: number): ConjectureNoveltyAssessment;
export declare function computeMeshFacts(candidate: GeometryConjectureCandidate, hashMode?: HashMode): MeshFacts;
export declare function nonDegenerateGeometryProbe(options?: {
    minArea?: number;
    minVolume?: number;
}): ConjectureProbe;
export declare function geometryHashOrderInvariantProbe(hashMode?: HashMode): ConjectureProbe;
export declare function eulerCharacteristicProbe(expected: number): ConjectureProbe;
/**
 * Collision-equivalence probe: compare a candidate's exact convex-hull proxy
 * with its axis-aligned bounding box over a deterministic point sweep. It is
 * receipt-carrying collision evidence: aligned boxes survive; transforms that
 * make the AABB over-approximate the hull preserve a concrete counterexample.
 */
export declare function collisionEquivalenceProbe(options?: {
    sampleCountPerAxis?: number;
    epsilon?: number;
}): ConjectureProbe;
/**
 * Curvature-bound probe: discrete Gaussian curvature is represented as vertex
 * angle deficit (`2*pi - sum(incident face angles)`). The probe preserves the
 * first vertex whose positive curvature exceeds the supplied receipt-tier bound.
 */
export declare function curvatureBoundProbe(maxAngleDeficit: number): ConjectureProbe;
/**
 * Edge-manifoldness probe: a triangle surface is edge-manifold when no edge is
 * shared by three or more triangles (interior edges have incidence 2, boundary
 * edges incidence 1). Manifoldness is a named proof-carrying-geometry invariant;
 * this carries it as deterministic receipt evidence (not a Lean proof, W.511).
 */
export declare function manifoldEdgeProbe(): ConjectureProbe;
export declare function buildConjectureV1Receipt(input: {
    claim: ConjectureClaim;
    candidates: ReadonlyArray<GeometryConjectureCandidate>;
    probes: ReadonlyArray<ConjectureProbe>;
    hashMode?: HashMode;
    priorArtCorpus?: ReadonlyArray<ConjecturePriorArtEntry>;
    noveltyThreshold?: number;
}): ConjectureReceipt;
export declare function createTetrahedronSurfaceCandidate(id?: string): GeometryConjectureCandidate;
export declare function createSquareSheetCandidate(id?: string): GeometryConjectureCandidate;
export declare function createDegenerateTriangleCandidate(id?: string): GeometryConjectureCandidate;
//# sourceMappingURL=ConjectureEngine.d.ts.map