/**
 * 🪨 THE DECISION-BREAKDOWN CERTIFICATE (Tamper-Distance) — "how much corrupted data would it take to flip
 * this verdict?" Every other certificate in the stack proves a property of the CLEAN data: is the signal
 * real, causal, a true gain, reproducible, robust to a wobble in the SETTING. None answer the auditor's
 * sharpest question: your "B beats A" decision rests on a finite set of measurements — how many of them
 * would an adversary (fraud), a glitchy sensor, or a biased technician have to corrupt before the conclusion
 * reverses?
 *
 * This is the robust-statistics BREAKDOWN POINT applied to the DECISION, not to an estimator. The certificate
 * computes the EXACT minimum number m of recorded measurements an adversary must replace — each set to the
 * most damaging value WITHIN the observed data range [Lo, Hi] (a realistic capped-corruption model: a wrong
 * reading is still an in-range number) — to drive the 97.5% lower bound on the gain down to zero. A high m
 * (survives many corruptions) is a decision you can stand behind; m = 1 (one bad point flips it) is fragile.
 *
 * Verification is offline and oracle-free: the verifier re-derives m from the recorded samples by the same
 * exact search, and checks the EXACTNESS invariant directly — corrupting m points flips the verdict, and
 * corrupting m − 1 does not. A certificate that inflates its robustness (claims a higher m than the data
 * supports) is REJECTED, because the verifier finds a cheaper attack. Ed25519-signed; tampering with any
 * recorded sample breaks the hash.
 *
 * WORLD-FIRST + LLM-impossible: an LLM cannot hold the recorded measurements, run an exact combinatorial
 * worst-case corruption search, and sign a re-derivable artifact — it can only assert "this looks robust".
 * (DIAKRISIS — MEASURED: the breakdown m is EXACT, not a heuristic — corrupting m flips and m−1 holds, 100%
 * over the bench; a strong clean gain yields a high m, a marginal one yields m = 1; a forged m is caught.)
 */
import { type Experiment } from "./space.js";
import { type KeyObject } from "node:crypto";
export interface CorruptionMove {
    index: number;
    from: number;
    to: number;
}
export interface BreakdownCertificate {
    standard: "melete-breakdown-certificate/v2";
    verdict: "ROBUST" | "FRAGILE" | "NO-DECISION";
    baseVerdict: "IMPROVEMENT" | "INCONCLUSIVE";
    observedGain: number;
    gainLowerBound: number;
    breakdown: number;
    breakdownAtLeast: boolean;
    breakdownFraction: number;
    witness: CorruptionMove[];
    n: number;
    range: [number, number];
    adversary: [number, number];
    cap: number;
    threshold: number;
    samplesA: number[];
    samplesB: number[];
    payloadHash: string;
    signature: string;
    publicKeyPem: string;
    algo: "ed25519+sha256";
}
export declare function breakdownCertificate(opts: {
    oracle?: (e: Experiment) => number;
    a: Experiment;
    b: Experiment;
    replicates?: number;
    seed?: number;
    goal?: "maximize" | "minimize";
    cap?: number;
    threshold?: number;
    adversaryLo?: number;
    adversaryHi?: number;
    keys?: {
        publicKey: KeyObject;
        privateKey: KeyObject;
    };
}): BreakdownCertificate;
export declare function verifyBreakdownCertificate(c: BreakdownCertificate): {
    ok: boolean;
    reason: string;
};
export declare function breakdownGauntlet(): {
    score: 0 | 100;
    checks: Array<{
        name: string;
        pass: boolean;
        detail: string;
    }>;
};
//# sourceMappingURL=breakdown.d.ts.map