Struct ErrorEnvelope 

pub struct ErrorEnvelope {
    pub list_idx: u32,
    pub quantiles: HashMap<u32, f32>,
    pub mean_error: f32,
    pub std_error: f32,
    pub max_error: f32,
    pub min_error: f32,
    pub sample_count: u32,
}

Pre-computed error envelope for a list

Fields

list_idx: u32

List index

quantiles: HashMap<u32, f32>

Quantiles of error distribution Key: quantile (e.g., 0.95, 0.99, 0.999) Value: error bound at that quantile

mean_error: f32

Mean error

std_error: f32

Standard deviation of error

max_error: f32

Maximum observed error

min_error: f32

Minimum observed error

sample_count: u32

Number of samples used for calibration

Implementations

impl ErrorEnvelope

pub fn error_at_quantile(&self, quantile: f32) -> f32

Get error bound for a quantile

Returns ε such that P(error ≤ ε) ≥ quantile

pub fn safe_true_threshold(&self, proxy: f32, confidence: f32) -> f32

Convert proxy threshold to safe true-score threshold

For similarity (higher is better): true_score ≥ proxy - error_bound

Returns threshold such that P(true ≥ threshold | proxy = p) ≥ confidence

pub fn safe_proxy_threshold(&self, true_threshold: f32, confidence: f32) -> f32

Convert true threshold to safe proxy threshold

For filtering candidates before rerank: proxy ≥ true + error_bound (conservative)

pub fn definitely_beats(&self, proxy: f32, true_threshold: f32) -> bool

Check if proxy score definitely beats true threshold

pub fn might_beat( &self, proxy: f32, true_threshold: f32, confidence: f32, ) -> bool

Check if proxy score might beat true threshold

Trait Implementations

impl Clone for ErrorEnvelope

fn clone(&self) -> ErrorEnvelope

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ErrorEnvelope

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ErrorEnvelope

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ErrorEnvelope

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ErrorEnvelope

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.