/**
 * REPLICATION ATTESTATION — the gem that closes the replication crisis for machine discovery, and makes
 * discoveries trustworthy across a multiverse of agents.
 *
 * A signed discovery TRACE proves the PATH (who searched, in what order, unaltered). It does NOT, by
 * itself, prove the SCIENCE reproduces — that the claimed best really scores what it claims. In a world of
 * millions of agents each running expensive experiments, the load-bearing question is: can agent B TRUST
 * agent A's discovery without re-running A's entire 40-experiment search?
 *
 * Yes — cheaply. `replicate` takes a published discovery (its claimed best + a sample of its path), re-
 * evaluates just those few points against an oracle (B's own, or a fresh run of the same process), and
 * checks the measured scores match the claimed ones within tolerance. Re-running the BEST point alone (1
 * experiment) verifies a 40-experiment discovery — 40× cheaper trust. The verdict is wrapped in a SIGNED
 * REPLICATION CERTIFICATE anyone can verify offline.
 *
 * ★HONEST (DIAKRISIS): replication checks that the recorded points reproduce on re-evaluation — it catches
 * fabricated / drifted / p-hacked claims (the common failure). It does NOT prove global optimality, and
 * for a genuinely noisy oracle it certifies "within tolerance", not bit-exact. It is the strongest cheap,
 * portable trust signal between agents — not an omniscience claim.
 */
import { type Experiment } from "./space.js";
import { type Oracle } from "./oracle.js";
import { Tracer, type SignedTrace } from "./trace.js";
export interface Claim {
    best: {
        experiment: Experiment;
        value: number;
    };
    path: Array<{
        experiment: Experiment;
        value: number;
    }>;
}
export interface ReplicationCheck {
    experiment: Experiment;
    claimed: number;
    measured: number;
    absErr: number;
    relErr: number;
    match: boolean;
}
export interface ReplicationReport {
    replicates: boolean;
    goal: "maximize" | "minimize";
    best: ReplicationCheck;
    samples: ReplicationCheck[];
    reEvaluations: number;
    tolerance: number;
    matchRate: number;
    summary: string;
}
/** Pull the claimed best + the path (experiment→value) out of a signed discovery trace. */
export declare function extractClaim(trace: SignedTrace): Claim;
/** Re-evaluate a discovery's best + a sample of its path against an oracle; certify whether it replicates. */
export declare function replicate(opts: {
    claim: Claim;
    oracle: Oracle;
    samples?: number;
    tolerance?: number;
    goal?: "maximize" | "minimize";
}): Promise<ReplicationReport>;
/** Wrap a replication report in a signed certificate that any third party verifies offline. */
export declare function certifyReplication(report: ReplicationReport, tracer?: Tracer): SignedTrace;
export declare function replicateGauntlet(): Promise<{
    score: 0 | 100;
    checks: Array<{
        name: string;
        pass: boolean;
        detail: string;
    }>;
}>;
//# sourceMappingURL=replicate.d.ts.map