/**
 * 🛰 NOISE-ROBUST DISCOVERY — the engine that doesn't get fooled by luck.
 *
 * Every ordinary optimizer trusts the single highest reading it ever saw. In a deterministic lab that's fine.
 * But run Melete as a 24/7 service on a real system — a satellite link in a solar storm, a database under a
 * traffic spike, an assay with batch-to-batch drift — and the measurements are NOISY: the SAME setting can
 * read 99% one second and 40% the next. A naive optimizer locks onto a setting that got one lucky high
 * reading and then collapses in production. That is the single most expensive failure mode in real Bayesian
 * optimization.
 *
 * NOISE-ROBUST fixes it the honest way:
 *   1. REPLICATE — it re-measures each candidate several times to estimate not just the mean μ but the
 *      spread σ. Noise is HETEROSCEDASTIC (different in different regions), so σ is estimated PER POINT from
 *      that point's own replicates — never assumed global.
 *   2. RACE (LUCB) — it spends extra measurements where it matters: tightening the confidence interval of the
 *      current leader and its closest challenger, so the winner is decided by evidence, not by a single fluke.
 *   3. SELECT BY TRUST — the winner is the point with the highest LOWER confidence bound (μ − z·σ/√n): the
 *      value you can actually rely on. A lucky spike with huge σ has a low LCB and loses; a genuinely good,
 *      quiet setting wins. It also reports the "lucky max" (the naive answer) it rejected and a per-point risk
 *      band, so a human/dashboard can see the noise it filtered.
 *
 * Honest by construction (DIAKRISIS): σ is measured from real replicates, not modelled from a prior; the
 * guarantee is statistical (it needs a few replicates per point) and the gauntlet proves it on a deliberately
 * noisy landscape where a high-variance trap occasionally out-reads the true optimum — NOISE-ROBUST picks the
 * trustworthy optimum ≥97.5% of seeds while a naive max-picker is fooled most of the time. Distinct from
 * AEGIS (which is robust to INPUT wobble / landscape geometry); this is robust to OUTPUT measurement noise.
 */
import { type Space, type Experiment } from "./space.js";
import { type Observation, type Goal } from "./engine.js";
export interface RobustPoint {
    experiment: Experiment;
    mean: number;
    std: number;
    n: number;
    lcb: number;
    ucb: number;
}
export interface NoiseRobustResult {
    best: Observation;
    bestMean: number;
    bestStd: number;
    bestN: number;
    bestLcb: number;
    luckyMax: Observation;
    rejectedLucky: boolean;
    noiseFiltered: number;
    points: RobustPoint[];
    evaluations: number;
}
/**
 * Noise-robust discovery on a stochastic oracle. `replicates` = initial measurements per candidate (≥3);
 * `z` = confidence multiplier for the lower bound (higher = more conservative / trust-demanding).
 */
export declare function noiseRobustDiscover(opts: {
    space: Space;
    oracle: (e: Experiment) => number;
    budget: number;
    goal?: Goal;
    seed?: number;
    z?: number;
    replicates?: number;
}): NoiseRobustResult;
export declare function noiseRobustGauntlet(): {
    score: 0 | 100;
    checks: Array<{
        name: string;
        pass: boolean;
        detail: string;
    }>;
};
//# sourceMappingURL=noiserobust.d.ts.map