use std::sync::Arc;
use crate::arquiver::{ArQuiverError, IndecomposableCatalog, category_radical};
use crate::ext::ExtClass;
use crate::field::Fp;
use crate::hom::{HomError, Morphism, hom};
use crate::homspace::{HomSpace, HomSubspace};
use crate::indec::IndecomposableModule;
use crate::sequence::ShortExactSequence;
use super::errors::AlmostSplitError;
use super::stable::{ext_sequence_holds, subspace_combination};
#[derive(Clone, Debug)]
pub struct CatalogEntryCheck {
pub(in crate::almost_split) right_factorizations: Vec<Vec<Fp>>,
pub(in crate::almost_split) right_memberships: Vec<Vec<Fp>>,
pub(in crate::almost_split) left_factorizations: Vec<Vec<Fp>>,
pub(in crate::almost_split) left_memberships: Vec<Vec<Fp>>,
}
impl CatalogEntryCheck {
accessor_methods! {
pub right_factorizations() -> &[Vec<Fp>] = |this| &this.right_factorizations;
pub right_memberships() -> &[Vec<Fp>] = |this| &this.right_memberships;
pub left_factorizations() -> &[Vec<Fp>] = |this| &this.left_factorizations;
pub left_memberships() -> &[Vec<Fp>] = |this| &this.left_memberships;
}
}
#[derive(Clone, Debug)]
pub struct CatalogWitness {
pub(in crate::almost_split) entries: Vec<CatalogEntryCheck>,
}
pub(in crate::almost_split) struct EntryRecompute {
pub(in crate::almost_split) image: HomSubspace,
pub(in crate::almost_split) rad: HomSubspace,
pub(in crate::almost_split) composites: Vec<Morphism>,
pub(in crate::almost_split) left_image: HomSubspace,
pub(in crate::almost_split) left_rad: HomSubspace,
pub(in crate::almost_split) left_composites: Vec<Morphism>,
}
pub(in crate::almost_split) fn radical_maps(radical: &HomSubspace) -> Vec<Morphism> {
(0..radical.dim())
.map(|i| radical.basis_morphism(i))
.collect()
}
pub(in crate::almost_split) fn express(
over: &HomSubspace,
maps: &[Morphism],
) -> Result<Vec<Vec<Fp>>, AlmostSplitError> {
maps.iter()
.map(|map| {
Ok(over.witness_contains(map)?.expect(
"the subspaces were just proved equal, so every map solves; this is a bug in \
auslander",
))
})
.collect()
}
impl EntryRecompute {
pub(in crate::almost_split) fn verifies(&self, check: &CatalogEntryCheck) -> bool {
self.image == self.rad
&& self.left_image == self.left_rad
&& family_solves(
&check.right_factorizations,
&self.image,
&radical_maps(&self.rad),
)
&& family_solves(&check.right_memberships, &self.rad, &self.composites)
&& family_solves(
&check.left_factorizations,
&self.left_image,
&radical_maps(&self.left_rad),
)
&& family_solves(
&check.left_memberships,
&self.left_rad,
&self.left_composites,
)
}
pub(in crate::almost_split) fn into_check(self) -> Result<CatalogEntryCheck, AlmostSplitError> {
Ok(CatalogEntryCheck {
right_factorizations: express(&self.image, &radical_maps(&self.rad))?,
right_memberships: express(&self.rad, &self.composites)?,
left_factorizations: express(&self.left_image, &radical_maps(&self.left_rad))?,
left_memberships: express(&self.left_rad, &self.left_composites)?,
})
}
}
pub(in crate::almost_split) fn entry_data(
maps: &[Morphism],
compose: impl Fn(&Morphism) -> Result<Morphism, HomError>,
space: impl FnOnce() -> Result<HomSpace, HomError>,
radical: impl FnOnce() -> Result<HomSubspace, ArQuiverError>,
) -> Result<(HomSubspace, HomSubspace, Vec<Morphism>), AlmostSplitError> {
let composites = maps
.iter()
.map(compose)
.collect::<Result<Vec<Morphism>, _>>()
.map_err(AlmostSplitError::Hom)?;
let image = space()?.subspace(&composites)?;
Ok((image, radical()?, composites))
}
pub(in crate::almost_split) fn recompute_entry(
m: &IndecomposableModule,
tau_ind: &IndecomposableModule,
sequence: &ShortExactSequence,
x: &IndecomposableModule,
) -> Result<EntryRecompute, AlmostSplitError> {
let (image, rad, composites) = entry_data(
&hom(x.module(), sequence.middle())?,
|map| map.then(sequence.projection()),
|| HomSpace::new(x.module(), m.module()),
|| category_radical(x, m),
)?;
let (left_image, left_rad, left_composites) = entry_data(
&hom(sequence.middle(), x.module())?,
|map| sequence.inclusion().then(map),
|| HomSpace::new(sequence.sub(), x.module()),
|| category_radical(tau_ind, x),
)?;
Ok(EntryRecompute {
image,
rad,
composites,
left_image,
left_rad,
left_composites,
})
}
impl CatalogWitness {
accessor_methods! {
pub entry_checks() -> &[CatalogEntryCheck] = |this| &this.entries;
}
pub fn verify(
&self,
m: &IndecomposableModule,
catalog: &IndecomposableCatalog,
sequence: &ShortExactSequence,
class: &ExtClass,
) -> bool {
verify_guard!(
Arc::ptr_eq(m.module().algebra(), catalog.algebra())
&& self.entries.len() == catalog.len()
);
verify_guard!(!class.is_zero() && ext_sequence_holds(m, sequence, class));
let_or_false!(Ok(tau_ind) = IndecomposableModule::new(sequence.sub()));
for (check, x) in self.entries.iter().zip(catalog.entries()) {
let_or_false!(Ok(entry) = recompute_entry(m, &tau_ind, sequence, x));
verify_guard!(entry.verifies(check));
}
true
}
}
pub(in crate::almost_split) fn family_solves(
stored: &[Vec<Fp>],
over: &HomSubspace,
expected: &[Morphism],
) -> bool {
stored.len() == expected.len()
&& stored.iter().zip(expected).all(|(coords, target)| {
matches!(subspace_combination(over, coords), Some(rebuilt) if rebuilt == *target)
})
}