use crate::field::PrimeField;
use crate::linalg::DenseMat;
use crate::module::Module;
use crate::profile::{Site, hit};
use crate::quiver::ArrowId;
use super::core::Morphism;
use super::linear::{express_in_row_basis, solve_columns};
pub(crate) fn submodule_with_inclusion(
parent: &Module,
bases: Vec<DenseMat>,
) -> (Module, Morphism) {
hit(Site::Submodule);
let field = parent.field();
let quiver = parent.algebra().quiver();
debug_assert!(
bases.iter().all(|b| b.rank(&field) == b.rows()),
"submodule_with_inclusion: the spanning rows are not linearly independent"
);
let dims: Vec<usize> = bases.iter().map(DenseMat::rows).collect();
let maps = (0..quiver.num_arrows())
.map(|i| {
let a = ArrowId(i as u32);
let (u, v) = (quiver.source(a) as usize, quiver.target(a) as usize);
let image = bases[u].mul(parent.map(a), &field);
express_in_row_basis(&bases[v], &image, &field)
})
.collect();
let sub = Module::new(parent.algebra().clone(), dims, maps)
.expect("a submodule of a module is a module");
let inclusion = Morphism::new_unchecked(&sub, parent, bases);
(sub, inclusion)
}
pub(crate) fn quotient_with_projection(parent: &Module, bases: &[DenseMat]) -> (Module, Morphism) {
hit(Site::Quotient);
let field = parent.field();
let quiver = parent.algebra().quiver();
let projections: Vec<DenseMat> = bases
.iter()
.map(|b| b.kernel_basis(&field).transpose())
.collect();
debug_assert!(
projections.iter().all(|q| q.rank(&field) == q.cols()),
"quotient_with_projection: the projection columns are not linearly independent"
);
let dims: Vec<usize> = projections.iter().map(DenseMat::cols).collect();
let maps = (0..quiver.num_arrows())
.map(|i| {
let a = ArrowId(i as u32);
let (u, v) = (quiver.source(a) as usize, quiver.target(a) as usize);
let rhs = parent.map(a).mul(&projections[v], &field);
solve_columns(&projections[u], &rhs, &field)
})
.collect();
let quotient = Module::new(parent.algebra().clone(), dims, maps)
.expect("a quotient of a module is a module");
let projection = Morphism::new_unchecked(parent, "ient, projections);
(quotient, projection)
}
fn row_space_bases(f: &Morphism, field: &PrimeField, num_vertices: u32) -> Vec<DenseMat> {
(0..num_vertices)
.map(|v| f.map_at(v).row_space_basis(field))
.collect()
}
pub fn kernel(f: &Morphism) -> (Module, Morphism) {
hit(Site::HomKernel);
let m = f.source();
let field = m.field();
let bases: Vec<DenseMat> = (0..m.algebra().quiver().num_vertices())
.map(|v| f.map_at(v).transpose().kernel_basis(&field))
.collect();
submodule_with_inclusion(m, bases)
}
pub fn image(f: &Morphism) -> (Module, Morphism) {
hit(Site::HomImage);
let n = f.target();
let bases = row_space_bases(f, &n.field(), n.algebra().quiver().num_vertices());
submodule_with_inclusion(n, bases)
}
pub fn cokernel(f: &Morphism) -> (Module, Morphism) {
hit(Site::HomCokernel);
let n = f.target();
let bases = row_space_bases(f, &n.field(), n.algebra().quiver().num_vertices());
quotient_with_projection(n, &bases)
}
pub(crate) fn factor_through_monomorphism(mono: &Morphism, map: &Morphism) -> Morphism {
assert!(
mono.target().ptr_eq(map.target()),
"factor_through_monomorphism: targets differ"
);
let field = mono.source().field();
let maps = (0..mono.source().algebra().quiver().num_vertices())
.map(|vertex| {
let transposed_mono = mono.map_at(vertex).transpose();
let value = map.map_at(vertex);
if value.rows() == 0 {
return DenseMat::zero(0, transposed_mono.cols());
}
transposed_mono
.solve_many(&value.transpose(), &field)
.expect("factor_through_monomorphism: map does not land in the monomorphism")
.transpose()
})
.collect();
Morphism::new(map.source(), mono.source(), maps)
.expect("a factorization through a module monomorphism is A-linear")
}