rsinter 0.3.0

Experimental parallel sampling and decoder benchmark harness for RustQEC
Documentation
use std::str::FromStr;

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum FailureKind {
    Ok,
    LogicalFailure,
    Timeout,
    SolverFailure,
    Unsupported,
    SamplerError,
}

impl Default for FailureKind {
    fn default() -> Self {
        Self::Ok
    }
}

impl FailureKind {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::Ok => "ok",
            Self::LogicalFailure => "logical_failure",
            Self::Timeout => "timeout",
            Self::SolverFailure => "solver_failure",
            Self::Unsupported => "unsupported",
            Self::SamplerError => "sampler_error",
        }
    }

    pub fn status(self) -> &'static str {
        match self {
            Self::Ok | Self::LogicalFailure | Self::Timeout => "ok",
            Self::SolverFailure | Self::Unsupported | Self::SamplerError => "error",
        }
    }
}

impl std::fmt::Display for FailureKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl FromStr for FailureKind {
    type Err = String;

    fn from_str(value: &str) -> Result<Self, Self::Err> {
        match value {
            "ok" => Ok(Self::Ok),
            "logical_failure" => Ok(Self::LogicalFailure),
            "timeout" => Ok(Self::Timeout),
            "solver_failure" => Ok(Self::SolverFailure),
            "unsupported" => Ok(Self::Unsupported),
            "sampler_error" => Ok(Self::SamplerError),
            other => Err(format!("unknown failure_kind: {other}")),
        }
    }
}

pub fn classify_completed(logical_errors: u64, timed_out: bool) -> FailureKind {
    if timed_out {
        FailureKind::Timeout
    } else if logical_errors > 0 {
        FailureKind::LogicalFailure
    } else {
        FailureKind::Ok
    }
}

pub fn classify_error(message: &str, fallback: FailureKind) -> FailureKind {
    let lower = message.to_ascii_lowercase();
    if lower.contains("backendunavailable")
        || lower.contains("backend unavailable")
        || lower.contains("backend is unavailable")
        || lower.contains("no ilp backend is available")
        || lower.contains("unsupported")
    {
        FailureKind::Unsupported
    } else {
        fallback
    }
}

pub fn combine_failure_kind(a: FailureKind, b: FailureKind) -> FailureKind {
    if failure_priority(a) >= failure_priority(b) {
        a
    } else {
        b
    }
}

fn failure_priority(kind: FailureKind) -> u8 {
    match kind {
        FailureKind::Ok => 0,
        FailureKind::LogicalFailure => 1,
        FailureKind::Timeout => 2,
        FailureKind::SamplerError => 3,
        FailureKind::SolverFailure => 4,
        FailureKind::Unsupported => 5,
    }
}

#[cfg(test)]
mod tests {
    use std::str::FromStr;

    use super::*;

    #[test]
    fn failure_kind_status_groups_completed_and_error_kinds() {
        assert_eq!(FailureKind::Ok.status(), "ok");
        assert_eq!(FailureKind::LogicalFailure.status(), "ok");
        assert_eq!(FailureKind::Timeout.status(), "ok");
        assert_eq!(FailureKind::SolverFailure.status(), "error");
        assert_eq!(FailureKind::Unsupported.status(), "error");
        assert_eq!(FailureKind::SamplerError.status(), "error");
    }

    #[test]
    fn failure_kind_default_and_display_cover_all_variants() {
        assert_eq!(FailureKind::default(), FailureKind::Ok);
        assert_eq!(FailureKind::Ok.to_string(), "ok");
        assert_eq!(FailureKind::LogicalFailure.to_string(), "logical_failure");
        assert_eq!(FailureKind::Timeout.to_string(), "timeout");
        assert_eq!(FailureKind::SolverFailure.to_string(), "solver_failure");
        assert_eq!(FailureKind::Unsupported.to_string(), "unsupported");
        assert_eq!(FailureKind::SamplerError.to_string(), "sampler_error");
    }

    #[test]
    fn failure_kind_parses_snake_case_values() {
        assert_eq!(FailureKind::from_str("ok").unwrap(), FailureKind::Ok);
        assert_eq!(
            FailureKind::from_str("logical_failure").unwrap(),
            FailureKind::LogicalFailure
        );
        assert_eq!(
            FailureKind::from_str("solver_failure").unwrap(),
            FailureKind::SolverFailure
        );
        assert!(FailureKind::from_str("logical-failure").is_err());
    }

    #[test]
    fn classify_completed_prioritizes_timeout_then_logical_failure() {
        assert_eq!(classify_completed(0, false), FailureKind::Ok);
        assert_eq!(classify_completed(1, false), FailureKind::LogicalFailure);
        assert_eq!(classify_completed(0, true), FailureKind::Timeout);
        assert_eq!(classify_completed(1, true), FailureKind::Timeout);
    }

    #[test]
    fn combine_failure_kind_uses_failure_priority_order() {
        assert_eq!(
            combine_failure_kind(FailureKind::Ok, FailureKind::LogicalFailure),
            FailureKind::LogicalFailure
        );
        assert_eq!(
            combine_failure_kind(FailureKind::Timeout, FailureKind::SamplerError),
            FailureKind::SamplerError
        );
        assert_eq!(
            combine_failure_kind(FailureKind::SolverFailure, FailureKind::Unsupported),
            FailureKind::Unsupported
        );
    }
}