use crate::decompose::inverse_morphism;
use crate::endo::EndoAlgebra;
use crate::field::Fp;
use crate::hom::Morphism;
use crate::homspace::{HomQuotient, HomSpace, HomSpaceError, HomSubspace};
use crate::indec::IndecomposableModule;
use crate::iso::indecomposable_iso;
use crate::linalg::DenseMat;
use crate::module::Module;
use super::{ArQuiverError, IndecomposableCatalog};
pub(crate) fn radical_against_iso(
space: &HomSpace,
endo: &EndoAlgebra,
u: &Morphism,
) -> Result<HomSubspace, ArQuiverError> {
let field = space.source().field();
let radical = endo.radical_basis();
let mut rows: Vec<Vec<Fp>> = Vec::with_capacity(space.dim() + radical.rows());
for f in space.basis() {
rows.push(endo.coords(&f.then(u)?));
}
for r in 0..radical.rows() {
rows.push(radical.row(r).to_vec());
}
let stacked = DenseMat::from_rows_with_cols(&rows, endo.dim());
let kernel = stacked.left_kernel_basis(&field);
let spanning: Vec<Morphism> = (0..kernel.rows())
.map(|k| space.morphism(&kernel.row(k)[..space.dim()]))
.collect();
Ok(space.subspace(&spanning)?)
}
pub fn category_radical(
x: &IndecomposableModule,
y: &IndecomposableModule,
) -> Result<HomSubspace, ArQuiverError> {
let space = HomSpace::new(x.module(), y.module())?;
let Some(h) = indecomposable_iso(x.module(), y.module(), x.endo()) else {
return Ok(space.full_subspace());
};
let u = inverse_morphism(&h).expect("the radical criterion returns an isomorphism");
radical_against_iso(&space, x.endo(), &u)
}
pub(crate) fn span_of_composites<'a>(
source: &Module,
target: &Module,
factorizations: impl Iterator<Item = (&'a HomSubspace, &'a HomSubspace)>,
) -> Result<HomSubspace, ArQuiverError> {
let mut composites = Vec::new();
for (left, right) in factorizations {
for i in 0..left.dim() {
let f = left.basis_morphism(i);
for j in 0..right.dim() {
composites.push(f.then(&right.basis_morphism(j))?);
}
}
}
Ok(HomSubspace::spanned_by(source, target, &composites)?)
}
pub fn radical_square_through_catalog(
catalog: &IndecomposableCatalog,
x: &IndecomposableModule,
y: &IndecomposableModule,
) -> Result<HomSubspace, ArQuiverError> {
let mut legs = Vec::with_capacity(catalog.len());
for z in catalog.entries() {
legs.push((category_radical(x, z)?, category_radical(z, y)?));
}
span_of_composites(
x.module(),
y.module(),
legs.iter().map(|(left, right)| (left, right)),
)
}
pub fn irreducible_quotient(
catalog: &IndecomposableCatalog,
x: &IndecomposableModule,
y: &IndecomposableModule,
) -> Result<HomQuotient, ArQuiverError> {
let radical = category_radical(x, y)?;
let square = radical_square_through_catalog(catalog, x, y)?;
quotient_or_defect(&radical, &square)
}
pub(crate) fn quotient_or_defect(
radical: &HomSubspace,
square: &HomSubspace,
) -> Result<HomQuotient, ArQuiverError> {
radical.quotient_by(square).map_err(|error| match error {
HomSpaceError::NotContained => ArQuiverError::RadicalSquareNotContained {
source: radical.source().dim_vector().to_vec(),
target: radical.target().dim_vector().to_vec(),
},
other => ArQuiverError::Space(other),
})
}