use crate::field::{Fp, PrimeField};
use crate::hom::Morphism;
use crate::linalg::{DenseMat, RowReducer};
use crate::module::Module;
use super::HomSpaceError;
pub(crate) fn flat_row(f: &Morphism) -> Vec<Fp> {
let mut row = Vec::with_capacity(flat_width(f.source(), f.target()));
for v in 0..f.source().algebra().quiver().num_vertices() {
let map = f.map_at(v);
for r in 0..map.rows() {
row.extend_from_slice(map.row(r));
}
}
row
}
pub(super) fn flat_width(m: &Module, n: &Module) -> usize {
m.dim_vector()
.iter()
.zip(n.dim_vector())
.map(|(&a, &b)| a * b)
.sum()
}
pub(super) fn morphism_from_flat(source: &Module, target: &Module, row: &[Fp]) -> Morphism {
let num_vertices = source.algebra().quiver().num_vertices();
let mut maps = Vec::with_capacity(num_vertices as usize);
let mut offset = 0;
for v in 0..num_vertices {
let (dm, dn) = (source.dim_at(v), target.dim_at(v));
let block = DenseMat::from_flat(dm, dn, &row[offset..offset + dm * dn]);
offset += dm * dn;
maps.push(block);
}
Morphism::new_unchecked(source, target, maps)
}
pub(crate) fn row_times(row: &[Fp], m: &DenseMat, field: &PrimeField) -> Vec<Fp> {
let mut out = vec![Fp::ZERO; m.cols()];
for (k, &c) in row.iter().enumerate() {
if c.is_zero() {
continue;
}
for (j, out_j) in out.iter_mut().enumerate() {
*out_j = field.add(*out_j, field.mul(c, m.get(k, j)));
}
}
out
}
pub(crate) fn rref_coords(rref: &DenseMat, v: &[Fp], field: &PrimeField) -> Option<Vec<Fp>> {
if rref.cols() != v.len() {
return None;
}
let coords: Vec<Fp> = rref_pivots(rref).map(|pivot| v[pivot]).collect();
(row_times(&coords, rref, field) == v).then_some(coords)
}
fn rref_pivots(rref: &DenseMat) -> impl Iterator<Item = usize> + '_ {
(0..rref.rows()).map(|r| {
rref.row(r)
.iter()
.position(|e| !e.is_zero())
.expect("a reduced row echelon basis has no zero row")
})
}
pub(crate) fn rref_coords_many(
rref: &DenseMat,
rows: &DenseMat,
field: &PrimeField,
) -> Option<DenseMat> {
if rref.cols() != rows.cols() {
return None;
}
if rows.rows() == 0 {
return Some(DenseMat::zero(0, rref.rows()));
}
let pivots: Vec<usize> = rref_pivots(rref).collect();
let mut coords = DenseMat::zero(rows.rows(), rref.rows());
for r in 0..rows.rows() {
for (c, &pivot) in pivots.iter().enumerate() {
coords.set(r, c, rows.get(r, pivot));
}
}
(coords.mul(rref, field) == *rows).then_some(coords)
}
pub(crate) fn scale_morphism(f: &Morphism, c: Fp) -> Morphism {
let field = f.source().field();
let maps = (0..f.source().algebra().quiver().num_vertices())
.map(|v| {
let mut block = f.map_at(v).clone();
block.scale(c, &field);
block
})
.collect();
Morphism::new_unchecked(f.source(), f.target(), maps)
}
pub(super) fn check_endpoints(
source: &Module,
target: &Module,
f: &Morphism,
) -> Result<(), HomSpaceError> {
if f.source().ptr_eq(source) {
f.target()
.ptr_eq(target)
.then_some(())
.ok_or(HomSpaceError::TargetMismatch)
} else {
Err(HomSpaceError::SourceMismatch)
}
}
pub(crate) fn stack_rows(matrices: &[&DenseMat], cols: usize) -> DenseMat {
DenseMat::stack(matrices, cols)
}
pub(crate) fn deterministic_complement(
ambient: &DenseMat,
inner: &DenseMat,
field: &PrimeField,
) -> DenseMat {
let empty = DenseMat::zero(0, ambient.cols());
let mut reducer = RowReducer::new(ambient.cols());
for r in 0..inner.rows() {
if !reducer.push(inner.row(r), field) {
return empty;
}
}
let kept: Vec<Vec<Fp>> = (0..ambient.rows())
.filter(|&r| reducer.push(ambient.row(r), field))
.map(|r| ambient.row(r).to_vec())
.collect();
DenseMat::from_rows_with_cols(&kept, ambient.cols())
}