use crate::ar::TauError;
use crate::context::VerificationContext;
use crate::hom::{HomError, Morphism};
use crate::homspace::HomSpace;
use crate::iso::{IsoOutcome, is_isomorphic};
use crate::linalg::DenseMat;
use crate::module::Module;
use crate::profile::{Site, hit};
#[derive(Clone, Debug)]
pub enum TauRigidError {
Tau(TauError),
Hom(HomError),
}
display_error! { TauRigidError {
Self::Tau(error) => "the AR translate of a summand failed: {error}";
Self::Hom(error) => "a Hom space between summands failed: {error}";
} }
error_source!(TauRigidError {
Self::Tau(error) => Some(error),
Self::Hom(error) => Some(error),
});
from_variants!(TauRigidError {
TauError => Tau,
HomError => Hom,
});
#[derive(Clone, Debug)]
pub struct TauRigidModule {
pub(super) summands: Vec<(usize, Module)>,
pub(super) translates: Vec<Module>,
}
impl TauRigidModule {
accessor_methods! {
pub summands() -> &[(usize, Module)] = |this| &this.summands;
pub translates() -> &[Module] = |this| &this.translates;
}
pub fn vanishing_pairs(&self) -> Vec<(usize, usize)> {
let mut out = Vec::new();
for (source_index, _) in &self.summands {
for ((target_index, _), translate) in self.summands.iter().zip(&self.translates) {
if !translate.is_zero() {
out.push((*source_index, *target_index));
}
}
}
out
}
accessor_methods! {
pub is_zero_module() -> bool = |this| this.summands.is_empty();
}
verify_methods!(pub(crate), { hit(Site::TauRigidVerify); },
|self, context| {
verify_guard!(self.translates.len() == self.summands.len());
let mut fresh = Vec::with_capacity(self.summands.len());
for ((_, x), stored) in self.summands.iter().zip(&self.translates) {
let_or_false!(Ok(live) = context.tau_for(x));
verify_guard!(live.is_zero() == stored.is_zero());
verify_guard!(live.is_zero()
|| matches!(
is_isomorphic(live.as_ref(), stored),
Ok(IsoOutcome::Isomorphic(_))
));
fresh.push(live);
}
for (_, x) in &self.summands {
for live in &fresh {
if live.is_zero() {
continue;
}
verify_guard!(matches!(context.hom_dim_for(x, live), Ok(0)));
}
}
true
});
}
#[derive(Clone, Debug)]
pub struct NonTauRigidWitness {
pub(super) source_index: usize,
pub(super) target_index: usize,
pub(super) source: Module,
pub(super) target_summand: Module,
pub(super) translate: Module,
pub(super) morphism: Morphism,
}
impl NonTauRigidWitness {
accessor_methods! {
pub source_index() -> usize = |this| this.source_index;
pub target_index() -> usize = |this| this.target_index;
pub source() -> &Module = |this| &this.source;
pub target_summand() -> &Module = |this| &this.target_summand;
pub translate() -> &Module = |this| &this.translate;
pub morphism() -> &Morphism = |this| &this.morphism;
}
verify_methods!(pub(crate), {},
|self, context| {
verify_guard!(self.morphism.source().ptr_eq(&self.source)
&& self.morphism.target().ptr_eq(&self.translate));
let vertices = self.source.algebra().quiver().num_vertices();
let maps: Vec<DenseMat> = (0..vertices)
.map(|v| self.morphism.map_at(v).clone())
.collect();
let_or_false!(Ok(rebuilt) = Morphism::new(&self.source, &self.translate, maps));
verify_guard!(rebuilt == self.morphism);
let_or_false!(Ok(live) = context.tau_for(&self.target_summand));
verify_guard!(!live.is_zero());
verify_guard!(matches!(
is_isomorphic(live.as_ref(), &self.translate),
Ok(IsoOutcome::Isomorphic(_))
));
let_or_false!(Ok(space) = HomSpace::new(&self.source, &self.translate));
verify_guard!(matches!(
space.full_subspace().contains(&self.morphism),
Ok(true)
));
!self.morphism.is_zero()
});
}
#[derive(Clone, Debug)]
pub enum TauRigidityOutcome {
TauRigid(TauRigidModule),
NotTauRigid(NonTauRigidWitness),
}
impl TauRigidityOutcome {
accessor_methods! {
pub is_tau_rigid() -> bool = |this| matches!(this, Self::TauRigid(_));
}
}