use super::*;
#[test]
fn the_radical_square_on_linear_a3_matches_the_hand_checked_factorizations() {
for field in [f2(), f5()] {
let algebra = linear_an(3, field);
let catalog = IndecomposableCatalog::dynkin(&algebra).unwrap();
let p0 = indec(&Module::projective(&algebra, 0));
let s0 = indec(&Module::simple(&algebra, 0));
let m01 = indec(&Module::injective(&algebra, 1));
assert_eq!(m01.module().dim_vector(), [1, 1, 0]);
assert_eq!(category_radical(&p0, &s0).unwrap().dim(), 1);
assert_eq!(
radical_square_through_catalog(&catalog, &p0, &s0)
.unwrap()
.dim(),
1
);
assert_eq!(irreducible_quotient(&catalog, &p0, &s0).unwrap().dim(), 0);
assert_eq!(category_radical(&p0, &m01).unwrap().dim(), 1);
assert_eq!(
radical_square_through_catalog(&catalog, &p0, &m01)
.unwrap()
.dim(),
0
);
assert_eq!(irreducible_quotient(&catalog, &p0, &m01).unwrap().dim(), 1);
}
}
#[test]
fn linear_a3_has_the_hand_derived_zigzag_ar_quiver() {
for field in [f2(), f5()] {
let algebra = linear_an(3, field);
let quiver = ar_quiver(&algebra).unwrap();
assert_eq!(
quiver.catalog().provenance(),
CatalogProvenance::DynkinZeroIdeal
);
assert_eq!(
dim_vectors(&quiver),
vec![
vec![0, 0, 1],
vec![0, 1, 0],
vec![1, 0, 0],
vec![0, 1, 1],
vec![1, 1, 0],
vec![1, 1, 1],
]
);
assert_eq!(
flags(&quiver),
vec![
(true, false),
(false, false),
(false, true),
(true, false),
(false, true),
(true, true),
]
);
assert_eq!(
arrow_triples(&quiver),
vec![
(0, 3, 1),
(1, 4, 1),
(3, 1, 1),
(3, 5, 1),
(4, 2, 1),
(5, 4, 1),
]
);
}
}
#[test]
fn truncated_poly_3_has_the_ar_quiver_of_k_x_mod_x_cubed() {
for field in [f2(), f5()] {
let algebra = truncated_poly(3, field).unwrap();
let quiver = ar_quiver(&algebra).unwrap();
assert_eq!(quiver.catalog().provenance(), CatalogProvenance::Nakayama);
assert_eq!(dim_vectors(&quiver), vec![vec![1], vec![2], vec![3]]);
assert_eq!(
flags(&quiver),
vec![(false, false), (false, false), (true, true)]
);
assert_eq!(
arrow_triples(&quiver),
vec![(0, 1, 1), (1, 0, 1), (1, 2, 1), (2, 1, 1)]
);
}
}
#[test]
fn the_radical_square_zero_3_cycle_has_a_hexagonal_ar_quiver() {
for field in [f2(), f5()] {
let algebra = radical_square_zero_cycle(3, field);
let quiver = ar_quiver(&algebra).unwrap();
assert_eq!(quiver.catalog().provenance(), CatalogProvenance::Nakayama);
assert_eq!(
dim_vectors(&quiver),
vec![
vec![1, 0, 0],
vec![1, 1, 0],
vec![0, 1, 0],
vec![0, 1, 1],
vec![0, 0, 1],
vec![1, 0, 1],
]
);
assert_eq!(
flags(&quiver),
vec![
(false, false),
(true, true),
(false, false),
(true, true),
(false, false),
(true, true),
]
);
assert_eq!(
arrow_triples(&quiver),
vec![
(0, 5, 1),
(1, 0, 1),
(2, 1, 1),
(3, 2, 1),
(4, 3, 1),
(5, 4, 1),
]
);
}
}
#[test]
fn d4_oriented_away_from_the_branch_vertex_has_15_arrows_and_two_stars() {
let algebra = d4(f2());
let quiver = ar_quiver(&algebra).unwrap();
assert_eq!(quiver.vertices().len(), 12);
assert_eq!(quiver.arrows().len(), 15);
assert_eq!(
dim_vectors(&quiver),
vec![
vec![0, 0, 0, 1],
vec![0, 0, 1, 0],
vec![0, 1, 0, 0],
vec![1, 0, 0, 0],
vec![1, 0, 0, 1],
vec![1, 0, 1, 0],
vec![1, 1, 0, 0],
vec![1, 0, 1, 1],
vec![1, 1, 0, 1],
vec![1, 1, 1, 0],
vec![1, 1, 1, 1],
vec![2, 1, 1, 1],
]
);
assert_eq!(
arrow_triples(&quiver),
vec![
(0, 10, 1),
(1, 10, 1),
(2, 10, 1),
(4, 3, 1),
(5, 3, 1),
(6, 3, 1),
(7, 11, 1),
(8, 11, 1),
(9, 11, 1),
(10, 7, 1),
(10, 8, 1),
(10, 9, 1),
(11, 4, 1),
(11, 5, 1),
(11, 6, 1),
]
);
let star_in = |id: usize| -> Vec<usize> {
quiver
.arrows()
.iter()
.filter(|a| a.target() == id)
.map(|a| a.source())
.collect()
};
let star_out = |id: usize| -> Vec<usize> {
quiver
.arrows()
.iter()
.filter(|a| a.source() == id)
.map(|a| a.target())
.collect()
};
assert_eq!(star_in(10), vec![0, 1, 2]);
assert_eq!(star_out(10), vec![7, 8, 9]);
assert_eq!(star_in(11), vec![7, 8, 9]);
assert_eq!(star_out(11), vec![4, 5, 6]);
assert!(quiver.vertices()[10].projective());
assert!(!quiver.vertices()[11].projective());
assert!(!quiver.vertices()[11].injective());
}
fn catalog_fixtures() -> Vec<Arc<Algebra>> {
vec![
linear_an(3, f5()),
linear_an(4, f2()),
truncated_poly(3, f2()).unwrap(),
truncated_poly(4, f5()).unwrap(),
radical_square_zero_cycle(3, f5()),
cyclic_nakayama(&[3, 3, 3], f2()).unwrap(),
d4(f2()),
]
}
#[test]
fn every_arrow_on_the_catalog_domains_is_plain() {
for algebra in catalog_fixtures() {
let quiver = ar_quiver(&algebra).unwrap();
for vertex in quiver.vertices() {
assert_eq!(
vertex.residue_degree(),
1,
"vertex {} of a catalog domain",
vertex.id()
);
}
for arrow in quiver.arrows() {
assert!(arrow.base_dim() > 0);
assert_eq!(arrow.over_source_residue(), arrow.base_dim());
assert_eq!(arrow.over_target_residue(), arrow.base_dim());
assert_eq!(arrow.valuation(), ArrowValuation::Plain(arrow.base_dim()));
assert_eq!(arrow.representatives().len(), arrow.base_dim());
}
}
}
#[test]
fn arrow_representatives_are_radical_maps_outside_the_radical_square() {
for algebra in [linear_an(3, f5()), truncated_poly(3, f2()).unwrap()] {
let quiver = ar_quiver(&algebra).unwrap();
let catalog = quiver.catalog();
for arrow in quiver.arrows() {
let x = &catalog.entries()[arrow.source()];
let y = &catalog.entries()[arrow.target()];
let radical = category_radical(x, y).unwrap();
let square = radical_square_through_catalog(catalog, x, y).unwrap();
for f in arrow.representatives() {
assert!(radical.contains(f).unwrap());
assert!(!square.contains(f).unwrap());
}
}
}
}
#[test]
fn every_catalog_has_at_least_one_entry_per_vertex() {
for algebra in catalog_fixtures() {
let quiver = ar_quiver(&algebra).unwrap();
let vertices = algebra.quiver().num_vertices() as usize;
assert!(quiver.catalog().len() >= vertices);
assert!(!quiver.catalog().is_empty());
assert_eq!(quiver.vertices().len(), quiver.catalog().len());
assert!(Arc::ptr_eq(quiver.catalog().algebra(), &algebra));
for (id, vertex) in quiver.vertices().iter().enumerate() {
assert_eq!(vertex.id(), id);
assert!(
vertex
.module()
.module()
.ptr_eq(quiver.catalog().entries()[id].module())
);
}
}
}
#[test]
fn the_catalog_constructors_reject_the_other_route() {
let nakayama = truncated_poly(3, f5()).unwrap();
assert_eq!(
IndecomposableCatalog::dynkin(&nakayama).unwrap_err(),
DynkinError::NonzeroIdeal { relations: 1 }
);
let dynkin = d4(f5());
assert_eq!(
IndecomposableCatalog::nakayama(&dynkin).unwrap_err(),
EnumerateError::NotNakayama {
vertex: 0,
incoming: 0,
outgoing: 3,
}
);
}
#[test]
fn an_unsupported_domain_carries_both_rejections() {
let algebra = commutative_square(f5());
assert_eq!(
ar_quiver(&algebra).unwrap_err(),
ArQuiverError::UnsupportedDomain {
dynkin: DynkinError::NonzeroIdeal { relations: 1 },
nakayama: EnumerateError::NotNakayama {
vertex: 0,
incoming: 0,
outgoing: 2,
},
}
);
}
#[test]
fn the_radical_needs_one_algebra() {
let first = linear_an(3, f5());
let second = linear_an(3, f5());
let x = indec(&Module::simple(&first, 0));
let y = indec(&Module::simple(&second, 0));
assert_eq!(
category_radical(&x, &y).unwrap_err(),
ArQuiverError::Hom(HomError::DifferentAlgebras)
);
}
#[test]
fn maps_outside_the_radical_are_isomorphisms() {
for algebra in [linear_an(3, f5()), truncated_poly(3, f2()).unwrap()] {
let catalog = ar_quiver(&algebra).unwrap();
let catalog = catalog.catalog();
for x in catalog.entries() {
for y in catalog.entries() {
let radical = category_radical(x, y).unwrap();
for f in hom(x.module(), y.module()).unwrap() {
if !radical.contains(&f).unwrap() {
assert!(f.is_isomorphism());
}
}
}
}
}
}
#[test]
fn the_ar_quiver_is_the_same_on_a_second_run() {
for algebra in [linear_an(3, f2()), radical_square_zero_cycle(3, f5())] {
let first = ar_quiver(&algebra).unwrap();
let second = ar_quiver(&algebra).unwrap();
assert_eq!(dim_vectors(&first), dim_vectors(&second));
assert_eq!(arrow_triples(&first), arrow_triples(&second));
for (a, b) in first.arrows().iter().zip(second.arrows()) {
for (f, g) in a.representatives().iter().zip(b.representatives()) {
assert_eq!(f.map_at(0).entries_u64(), g.map_at(0).entries_u64());
}
}
}
}