/**
 * RELIABILITY — the falsifiable "97.5% on every landscape" bar.
 *
 * A single benchmark function proves nothing; an optimizer that wins on a smooth bowl can fail badly on a
 * deceptive, multi-trap, or high-dimensional surface. RELIABILITY runs the engine across a deliberately
 * adversarial BATTERY — smooth, many-trap (Rastrigin), deceptive (Ackley), curved-valley (Rosenbrock),
 * oscillatory (Griewank), high-dimensional, and a sharp needle — each NORMALISED so the true global
 * optimum is exactly 1.0. The score for a run is therefore literally "% of the true optimum reached".
 *
 * The bar: the engine must reach a high fraction of the true optimum on EVERY landscape, averaged over
 * several seeds — not just on average across the battery (which would let a smooth-surface win hide a
 * pathological failure). The gauntlet reports the worst landscape, so the claim is honest and falsifiable:
 * anyone can re-run it and check the per-landscape numbers.
 */
import { type Space, type Experiment } from "./space.js";
import { type Goal, type Observation } from "./engine.js";
export interface Landscape {
    name: string;
    space: Space;
    f: (e: Experiment) => number;
    budget: number;
    note: string;
}
/**
 * POLISH — a deterministic compass / pattern search (Hooke–Jeeves style) that follows a curved valley the
 * global explorer can only get near. From the incumbent best it probes ± a step along each axis; on an
 * improvement it keeps the move, otherwise it halves the step — so it converges into ridges (Rosenbrock)
 * that random/Bayesian sampling burns hundreds of experiments failing to nail. No randomness, no deps:
 * the local exploiter that turns "near the optimum" into "on the optimum".
 */
export declare function polish(space: Space, oracle: (e: Experiment) => number, start: Experiment, evals: number, goal?: Goal): {
    experiment: Experiment;
    value: number;
};
/**
 * RELIABLE DISCOVER — Melete's signature 3-paradigm memetic engine. Three fundamentally different searchers
 * compose into one run: (1) the self-allocating PORTFOLIO explores globally to find the right basin;
 * (2) an OPTIMISTIC LIPSCHITZ INFILL (DIRECT-style) turns Melete's own optimality certificate INTO an
 * acquisition — it samples the single point where the certified upper bound is highest, i.e. the most
 * promising unexplored region the data cannot yet rule out; (3) NELDER–MEAD polish exploits locally to nail
 * the optimum. Global basin → certificate-guided infill of the gaps → local precision. Fully deterministic
 * ⇒ reproducible + signable. The diamond (CERTIFY) is not just a report here — it steers the search.
 */
export declare function reliableDiscover(opts: {
    space: Space;
    oracle: (e: Experiment) => number;
    budget: number;
    seed?: number;
    goal?: Goal;
}): Promise<{
    best: Observation;
    armStats: import("./portfolio.js").ArmStat[];
    evaluations: number;
    goal: Goal;
}>;
/** All landscapes are maximise, normalised so the global optimum value == 1.0 (so best.value == % of optimum). */
export declare function landscapes(): Landscape[];
export interface LandscapeResult {
    name: string;
    meanPct: number;
    minPct: number;
    note: string;
    budget: number;
    seeds: number;
}
/** Run the portfolio engine over every landscape × `seeds` seeds; return % of true optimum reached. */
export declare function reliabilityBench(seeds?: number): Promise<{
    results: LandscapeResult[];
    worst: LandscapeResult;
}>;
export declare function reliabilityGauntlet(): Promise<{
    score: 0 | 100;
    checks: Array<{
        name: string;
        pass: boolean;
        detail: string;
    }>;
}>;
//# sourceMappingURL=reliability.d.ts.map