use crate::field::PrimeField;
use crate::homspace::HomSpace;
use crate::linalg::{DenseMat, SparseMat, SparseRow};
use crate::module::Module;
use crate::profile::{Site, hit};
use crate::quiver::ArrowId;
use super::core::{HomError, Morphism, check_parallel};
pub(crate) fn hom_rows(m: &Module, n: &Module) -> Result<DenseMat, HomError> {
hit(Site::Hom);
check_parallel(m, n)?;
let field = m.field();
Ok(square_constraints(m, n).kernel_basis(&field).to_dense())
}
pub fn hom(m: &Module, n: &Module) -> Result<Vec<Morphism>, HomError> {
Ok(HomSpace::new(m, n)?.into_basis())
}
fn square_constraints(m: &Module, n: &Module) -> SparseMat {
let field = m.field();
let quiver = m.algebra().quiver();
let mut total = 0usize;
let mut offsets = Vec::with_capacity(m.dim_vector().len());
for (&m_dim, &n_dim) in m.dim_vector().iter().zip(n.dim_vector()) {
offsets.push(total);
total += m_dim * n_dim;
}
let mut rows = Vec::new();
for idx in 0..quiver.num_arrows() {
let arrow = ArrowId(idx as u32);
let (u, v) = (quiver.source(arrow) as usize, quiver.target(arrow) as usize);
let ma = m.map(arrow);
let na = n.map(arrow);
for i in 0..m.dim_vector()[u] {
for j in 0..n.dim_vector()[v] {
let mut entries = Vec::new();
for c in 0..n.dim_vector()[u] {
let val = na.get(c, j);
if !val.is_zero() {
entries.push((offsets[u] + i * n.dim_vector()[u] + c, val));
}
}
for r in 0..m.dim_vector()[v] {
let val = ma.get(i, r);
if !val.is_zero() {
entries.push((offsets[v] + r * n.dim_vector()[v] + j, field.neg(val)));
}
}
let row = SparseRow::from_entries(entries, &field);
if !row.is_zero() {
rows.push(row);
}
}
}
}
SparseMat::from_rows(rows, total)
}
pub fn hom_dim(m: &Module, n: &Module) -> Result<usize, HomError> {
hit(Site::HomDim);
check_parallel(m, n)?;
let constraints = square_constraints(m, n);
Ok(constraints.cols() - constraints.rank(&m.field()))
}
pub(crate) fn express_in_row_basis(
basis: &DenseMat,
vectors: &DenseMat,
field: &PrimeField,
) -> DenseMat {
hit(Site::ExpressInRowBasis);
basis
.transpose()
.solve_many(&vectors.transpose(), field)
.expect("vectors lie in the row span of the basis")
.transpose()
}
pub(super) fn solve_columns(a: &DenseMat, rhs: &DenseMat, field: &PrimeField) -> DenseMat {
hit(Site::SolveColumns);
a.solve_many(rhs, field)
.expect("columns lie in the column space")
}