auslander 0.10.0

Computational representation theory of finite-dimensional bound quiver algebras
Documentation
use crate::atlas::{CatalogAtlas, MultiplicityCut, MultiplicityCutReason, MultiplicityOutcome};

use super::super::errors::CatalogAtlasArtifactError;
use super::super::model::{
    CatalogAtlasArtifact, CatalogAtlasArtifactResultRow, CatalogAtlasArtifactStatus,
    CatalogAtlasArtifactVerifyLimits,
};
use super::check_limit;

pub(super) fn check_multiplicity_results(
    artifact: &CatalogAtlasArtifact,
    atlas: &CatalogAtlas,
    limits: CatalogAtlasArtifactVerifyLimits,
) -> Result<(), CatalogAtlasArtifactError> {
    let outcome = atlas
        .enumerate_multiplicities(&artifact.target_dimensions, artifact.multiplicity_limits)?;
    match (&artifact.status, &outcome) {
        (CatalogAtlasArtifactStatus::Complete, MultiplicityOutcome::Cut(_)) => {
            Err(CatalogAtlasArtifactError::ReplayMismatch {
                field: "status upgraded to complete".to_string(),
            })
        }
        (CatalogAtlasArtifactStatus::Cut { .. }, MultiplicityOutcome::Complete(_)) => {
            Err(CatalogAtlasArtifactError::ReplayMismatch {
                field: "status cut coverage".to_string(),
            })
        }
        (CatalogAtlasArtifactStatus::Complete, MultiplicityOutcome::Complete(rows)) => {
            compare_result_rows(artifact, atlas, rows.solutions(), limits)
        }
        (
            CatalogAtlasArtifactStatus::Cut {
                reason,
                coverage,
                nodes_visited,
            },
            MultiplicityOutcome::Cut(cut),
        ) => check_cut_outcome(
            artifact,
            atlas,
            *reason,
            *coverage,
            *nodes_visited,
            cut,
            limits,
        ),
    }
}

fn check_cut_outcome(
    artifact: &CatalogAtlasArtifact,
    atlas: &CatalogAtlas,
    reason: MultiplicityCutReason,
    coverage: usize,
    nodes_visited: u64,
    cut: &MultiplicityCut,
    limits: CatalogAtlasArtifactVerifyLimits,
) -> Result<(), CatalogAtlasArtifactError> {
    if cut.reason() != reason
        || cut.nodes_visited() != nodes_visited
        || cut.solutions().len() != coverage
    {
        return Err(CatalogAtlasArtifactError::ReplayMismatch {
            field: "cut status".to_string(),
        });
    }
    compare_result_rows(artifact, atlas, cut.solutions(), limits)
}

fn compare_result_rows(
    artifact: &CatalogAtlasArtifact,
    atlas: &CatalogAtlas,
    expected: &[Vec<usize>],
    limits: CatalogAtlasArtifactVerifyLimits,
) -> Result<(), CatalogAtlasArtifactError> {
    if artifact.result_rows.len() != expected.len() {
        return Err(CatalogAtlasArtifactError::ReplayMismatch {
            field: "result row coverage".to_string(),
        });
    }
    for (index, (stored, multiplicities)) in artifact.result_rows.iter().zip(expected).enumerate() {
        check_result_row(artifact, atlas, index, stored, multiplicities, limits)?;
    }
    Ok(())
}

fn check_result_row(
    artifact: &CatalogAtlasArtifact,
    atlas: &CatalogAtlas,
    index: usize,
    stored: &CatalogAtlasArtifactResultRow,
    multiplicities: &[usize],
    limits: CatalogAtlasArtifactVerifyLimits,
) -> Result<(), CatalogAtlasArtifactError> {
    if stored.multiplicities() != multiplicities {
        return Err(CatalogAtlasArtifactError::ReplayMismatch {
            field: "multiplicity rows".to_string(),
        });
    }
    check_vector_dimension(atlas, multiplicities, &artifact.target_dimensions)?;
    let scores = atlas.self_ext_scores(multiplicities, 0, artifact.max_degree())?;
    if stored.self_ext() != scores {
        return Err(CatalogAtlasArtifactError::ReplayMismatch {
            field: "self-Ext result rows".to_string(),
        });
    }
    check_limit("result row", index, limits.max_result_rows)
}

fn check_vector_dimension(
    atlas: &CatalogAtlas,
    multiplicities: &[usize],
    target: &[usize],
) -> Result<(), CatalogAtlasArtifactError> {
    if multiplicities.len() != atlas.catalog().len() {
        return Err(CatalogAtlasArtifactError::CountMismatch {
            field: "multiplicity vector".to_string(),
        });
    }
    let mut dimensions = vec![0usize; target.len()];
    for (&multiplicity, entry) in multiplicities.iter().zip(atlas.catalog().entries()) {
        accumulate_entry_dimension(&mut dimensions, multiplicity, entry.module().dim_vector())?;
    }
    if dimensions != target {
        return Err(CatalogAtlasArtifactError::ReplayMismatch {
            field: "target dimensions".to_string(),
        });
    }
    Ok(())
}

fn accumulate_entry_dimension(
    dimensions: &mut [usize],
    multiplicity: usize,
    entry_dimensions: &[usize],
) -> Result<(), CatalogAtlasArtifactError> {
    for (vertex, &dimension) in entry_dimensions.iter().enumerate() {
        let product =
            multiplicity
                .checked_mul(dimension)
                .ok_or(CatalogAtlasArtifactError::Overflow {
                    field: "multiplicity dimension",
                })?;
        dimensions[vertex] =
            dimensions[vertex]
                .checked_add(product)
                .ok_or(CatalogAtlasArtifactError::Overflow {
                    field: "target dimension",
                })?;
    }
    Ok(())
}