rilpqec 0.4.0

Experimental ILP decoding of quantum detector error models
Documentation
use crate::error::IlpDecodeError;

#[derive(Debug, Clone, PartialEq)]
pub struct ColumnTerm {
    pub detectors: Vec<usize>,
    pub observables: Vec<usize>,
    pub weight: f64,
}

#[derive(Debug, Clone, PartialEq)]
pub struct LoweredDemProblem {
    pub num_detectors: usize,
    pub num_observables: usize,
    pub columns: Vec<ColumnTerm>,
    pub forced_syndrome: Vec<bool>,
    pub baseline_observables: Vec<bool>,
}

impl LoweredDemProblem {
    pub fn to_binary_ilp_model(&self) -> Result<qec_ilp_core::BinaryIlpModel, IlpDecodeError> {
        let binary_vars = self
            .columns
            .iter()
            .enumerate()
            .map(|(index, column)| qec_ilp_core::ModelVar {
                name: format!("e_{index}"),
                objective: column.weight,
                lower: 0.0,
                upper: 1.0,
            })
            .collect::<Vec<_>>();

        let integer_vars = (0..self.num_detectors)
            .map(|row| qec_ilp_core::ModelVar {
                name: format!("a_{row}"),
                objective: 0.0,
                lower: 0.0,
                upper: f64::INFINITY,
            })
            .collect::<Vec<_>>();

        let mut row_binary_terms = vec![Vec::new(); self.num_detectors];
        for (index, column) in self.columns.iter().enumerate() {
            for &row in &column.detectors {
                let terms =
                    row_binary_terms
                        .get_mut(row)
                        .ok_or(IlpDecodeError::DetectorWidthMismatch {
                            expected: self.num_detectors,
                            actual: row + 1,
                        })?;
                terms.push((index, 1.0));
            }
        }

        let constraints = (0..self.num_detectors)
            .map(|row| qec_ilp_core::LinearConstraint {
                name: format!("det_{row}"),
                sense: qec_ilp_core::ConstraintSense::Eq,
                binary_terms: row_binary_terms[row].clone(),
                integer_terms: vec![(row, -2.0)],
                rhs: 0.0,
            })
            .collect::<Vec<_>>();

        Ok(qec_ilp_core::BinaryIlpModel {
            binary_vars,
            integer_vars,
            constraints,
            solution_binary_prefix_len: self.columns.len(),
        })
    }

    pub fn observables_from_correction(
        &self,
        correction: &[bool],
    ) -> Result<Vec<bool>, IlpDecodeError> {
        if correction.len() != self.columns.len() {
            return Err(IlpDecodeError::CorrectionWidthMismatch {
                expected: self.columns.len(),
                actual: correction.len(),
            });
        }

        let mut out = self.baseline_observables.clone();
        for (column, enabled) in self.columns.iter().zip(correction.iter().copied()) {
            if !enabled {
                continue;
            }
            for &obs in &column.observables {
                out[obs] ^= true;
            }
        }
        Ok(out)
    }
}