/**
 * NumberTheoryConjecture — the first NON-geometry Conjecture Engine sub-class.
 *
 * The shipped ConjectureEngine candidate type is mesh-only (vertices/elements),
 * so number theory does not fit it. Rather than hack integers into a geometry
 * mesh, this module models Diophantine conjectures directly and reuses the
 * GENERIC receipt-key primitive (`buildConjectureStableKey`) so the engine's
 * receipt spine — not its geometry candidate type — is what generalizes.
 *
 * Target: the Erdős–Straus conjecture, 4/n = 1/x + 1/y + 1/z (n >= 2, x,y,z > 0
 * integers). Verified for all n < 1e17; OPEN in general. We therefore make a
 * BOUNDED, honest claim: every n in a finite range admits a decomposition our
 * bounded search finds — survivors are receipt-carrying evidence, an unfound n
 * is `undecided` (NOT falsified — absence within a bound is not a counterexample),
 * and we NEVER claim "solved Erdős–Straus".
 *
 * All arithmetic is exact integer arithmetic — deterministic and hashable.
 * Receipt-carrying evidence, NOT a Lean proof (W.511).
 */
export declare const ERDOS_STRAUS_V1: "conjecture.numbertheory.erdos-straus.v1";
export type ErdosStrausSolverType = typeof ERDOS_STRAUS_V1;
export type NumberConjectureStatus = 'survived' | 'falsified' | 'undecided';
export type NumberProbeStatus = 'pass' | 'fail' | 'inconclusive';
export interface UnitFractionDecomposition {
    n: number;
    x: number;
    y: number;
    z: number;
}
export interface NumberConjectureEvaluation {
    n: number;
    status: NumberProbeStatus;
    witness: UnitFractionDecomposition | null;
    message: string;
}
export interface NumberConjectureCounterexample {
    n: number;
    reason: string;
}
export interface NumberConjectureScenario {
    id: string;
    role: 'survivor' | 'falsifier';
    statement: string;
    evaluations: ReadonlyArray<NumberConjectureEvaluation>;
    status: NumberConjectureStatus;
    counterexamples: ReadonlyArray<NumberConjectureCounterexample>;
}
export interface ErdosStrausReceipt {
    solverType: ErdosStrausSolverType;
    specVersion: 1;
    minN: number;
    maxN: number;
    searchBound: number;
    scenarios: ReadonlyArray<NumberConjectureScenario>;
    gate: {
        survivorScenarioId: string | null;
        falsifierScenarioId: string | null;
        undecidedCount: number;
        passed: boolean;
    };
    receiptKey: string;
}
export interface ErdosStrausOptions {
    /** Smallest n (inclusive). Must be >= 2. Default 2. */
    minN?: number;
    /** Largest n (inclusive). Default 50. */
    maxN?: number;
    /** Maximum denominator searched before declaring a case `undecided`. Default 4000. */
    searchBound?: number;
}
/**
 * Exact integer check of 4/n = 1/x + 1/y + 1/z.
 * Cross-multiplied: 4·x·y·z == n·(y·z + x·z + x·y), with x,y,z > 0.
 */
export declare function verifyErdosStraus(n: number, x: number, y: number, z: number): boolean;
/**
 * Bounded exact-integer search for a decomposition of 4/n. Returns the
 * lexicographically-first ordered triple (x <= y <= z) found, or null if none
 * exists with denominators <= searchBound. Uses only integer arithmetic.
 *
 * 1/x is the largest term, so x ∈ [ceil(n/4), floor(3n/4)].
 * Given x, the remainder is r = (4x - n)/(n·x); then 1/y + 1/z = r with
 * y ∈ (1/r, 2/r], and z = (n·x·y)/((4x - n)·y - n·x) when that is a positive integer.
 */
export declare function findErdosStrausDecomposition(n: number, searchBound?: number): UnitFractionDecomposition | null;
/**
 * The deliberately-FALSE companion claim used as the falsifier scenario:
 * "4/n has an equal-denominator decomposition 4/n = 3/x with integer x."
 * x = 3n/4 is an integer only when 4 | n, so every n not divisible by 4 is a
 * discovered counterexample. This proves the engine refutes a false number-theory
 * claim by construction, mirroring the geometry suite's discovering falsifier.
 */
export declare function findEqualUnitFraction(n: number): number | null;
/**
 * Run the Erdős–Straus conjecture sub-class end to end: a survivor scenario
 * (decomposition exists — bounded, honest `undecided` on misses) and a
 * discovering falsifier (the false equal-denominator claim). Deterministic
 * receipt key via the shared `buildConjectureStableKey` primitive.
 *
 * The gate passes when the survivor is fully survived AND the falsifier is
 * refuted by at least one discovered counterexample.
 */
export declare function runErdosStrausConjecture(options?: ErdosStrausOptions): ErdosStrausReceipt;
//# sourceMappingURL=NumberTheoryConjecture.d.ts.map