use crate::context::VerificationContext;
use crate::decompose::decompose;
use crate::hom::hom_dim;
use crate::homspace::HomSpace;
use crate::module::Module;
use super::cache::TauCache;
use super::types::{NonTauRigidWitness, TauRigidError, TauRigidModule, TauRigidityOutcome};
pub fn is_tau_rigid_summandwise(
summands: &[(usize, Module)],
cache: &mut TauCache,
) -> Result<TauRigidityOutcome, TauRigidError> {
is_tau_rigid_summandwise_with(
summands,
|module| cache.tau_of(module).cloned().map_err(Into::into),
|source, target| hom_dim(source, target).map_err(Into::into),
)
}
pub(crate) fn is_tau_rigid_summandwise_with_context(
summands: &[(usize, Module)],
context: &VerificationContext,
) -> Result<TauRigidityOutcome, TauRigidError> {
is_tau_rigid_summandwise_with(
summands,
|module| {
context
.tau_for(module)
.map(|translate| translate.as_ref().clone())
.map_err(Into::into)
},
|source, target| context.hom_dim_for(source, target).map_err(Into::into),
)
}
fn is_tau_rigid_summandwise_with(
summands: &[(usize, Module)],
mut tau_of: impl FnMut(&Module) -> Result<Module, TauRigidError>,
mut hom_dimension: impl FnMut(&Module, &Module) -> Result<usize, TauRigidError>,
) -> Result<TauRigidityOutcome, TauRigidError> {
let mut translates = Vec::with_capacity(summands.len());
for (_, x) in summands {
translates.push(tau_of(x)?);
}
for (source_index, x) in summands {
for (j, (target_index, y)) in summands.iter().enumerate() {
let translate = &translates[j];
if translate.is_zero() {
continue;
}
if hom_dimension(x, translate)? == 0 {
continue;
}
let space = HomSpace::new(x, translate)?;
return Ok(TauRigidityOutcome::NotTauRigid(NonTauRigidWitness {
source_index: *source_index,
target_index: *target_index,
source: x.clone(),
target_summand: y.clone(),
translate: translate.clone(),
morphism: space.basis()[0].clone(),
}));
}
}
Ok(TauRigidityOutcome::TauRigid(TauRigidModule {
summands: summands.to_vec(),
translates,
}))
}
pub fn is_tau_rigid(m: &Module) -> Result<TauRigidityOutcome, TauRigidError> {
let summands: Vec<_> = if m.is_zero() {
Vec::new()
} else {
decompose(m)
.summands()
.iter()
.cloned()
.enumerate()
.collect()
};
is_tau_rigid_summandwise(&summands, &mut TauCache::new())
}