use std::sync::Arc;
use crate::algebra::Algebra;
use crate::decompose::{Certificate, decompose};
use crate::hom::cokernel;
use crate::module::Module;
use crate::radical::radical;
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum EnumerateError {
NotNakayama {
vertex: u32,
incoming: usize,
outgoing: usize,
},
}
display_error! { error EnumerateError {
Self::NotNakayama { vertex, incoming, outgoing } => "vertex {vertex} has {incoming} incoming and {outgoing} outgoing arrows; a Nakayama quiver allows at most one of each";
} }
pub fn nakayama_indecomposables(
algebra: &Arc<Algebra>,
) -> Result<Vec<(Module, Certificate)>, EnumerateError> {
let quiver = algebra.quiver();
for v in 0..quiver.num_vertices() {
let incoming = quiver.arrows_to(v).len();
let outgoing = quiver.arrows_from(v).len();
if incoming > 1 || outgoing > 1 {
return Err(EnumerateError::NotNakayama {
vertex: v,
incoming,
outgoing,
});
}
}
let mut modules = Vec::with_capacity(algebra.dim());
for v in 0..quiver.num_vertices() {
let p = Module::projective(algebra, v);
let (mut rad_power, mut inclusion) = radical(&p);
loop {
modules.push(certified(cokernel(&inclusion).0));
if rad_power.is_zero() {
break;
}
let (next, next_inclusion) = radical(&rad_power);
inclusion = next_inclusion
.then(&inclusion)
.expect("radical inclusions chain into the projective");
rad_power = next;
}
}
Ok(modules)
}
fn certified(m: Module) -> (Module, Certificate) {
let d = decompose(&m);
assert_eq!(
d.summands().len(),
1,
"uniserial quotient split into {} summands; library bug",
d.summands().len()
);
assert_eq!(
d.certificates(),
[Certificate::Indecomposable],
"uniserial quotient not certified indecomposable; library bug"
);
(m, Certificate::Indecomposable)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::algebra::{
cyclic_nakayama, dual_numbers, kronecker, linear_nakayama, radical_square_zero_cycle,
truncated_poly,
};
use crate::field::PrimeField;
fn fields() -> [PrimeField; 2] {
[PrimeField::new(2).unwrap(), PrimeField::new(5).unwrap()]
}
#[test]
fn count_equals_the_sum_of_the_kupisch_series() {
for field in fields() {
for algebra in [
linear_nakayama(&[3, 2, 1], field).unwrap(),
linear_nakayama(&[2, 2, 1], field).unwrap(),
cyclic_nakayama(&[3, 3, 3], field).unwrap(),
radical_square_zero_cycle(3, field),
dual_numbers(field),
truncated_poly(4, field).unwrap(),
] {
let modules = nakayama_indecomposables(&algebra).unwrap();
assert_eq!(modules.len(), algebra.dim());
assert!(
modules
.iter()
.all(|(_, c)| *c == Certificate::Indecomposable)
);
}
}
}
#[test]
fn linear_3_2_1_lists_the_six_uniserial_dimension_vectors() {
for field in fields() {
let algebra = linear_nakayama(&[3, 2, 1], field).unwrap();
let dims: Vec<Vec<usize>> = nakayama_indecomposables(&algebra)
.unwrap()
.iter()
.map(|(m, _)| m.dim_vector().to_vec())
.collect();
assert_eq!(
dims,
vec![
vec![1, 0, 0],
vec![1, 1, 0],
vec![1, 1, 1],
vec![0, 1, 0],
vec![0, 1, 1],
vec![0, 0, 1],
]
);
}
}
#[test]
fn truncated_poly_lists_every_jordan_block_dimension() {
for field in fields() {
let algebra = truncated_poly(4, field).unwrap();
let dims: Vec<usize> = nakayama_indecomposables(&algebra)
.unwrap()
.iter()
.map(|(m, _)| m.total_dim())
.collect();
assert_eq!(dims, vec![1, 2, 3, 4]);
}
}
#[test]
fn a_vertex_with_two_outgoing_arrows_is_rejected() {
let algebra = kronecker(2, PrimeField::new(5).unwrap());
assert_eq!(
nakayama_indecomposables(&algebra).unwrap_err(),
EnumerateError::NotNakayama {
vertex: 0,
incoming: 0,
outgoing: 2,
}
);
}
}