use crate::algebra::{commutative_square, linear_an, truncated_poly};
use crate::arquiver::IndecomposableCatalog;
use crate::homspace::HomSpace;
use crate::module::Module;
use crate::radical::radical;
use super::super::{AlmostSplitOutcome, projectively_trivial, stable_end};
use super::support::*;
#[test]
fn truncated_poly_3_simple_has_the_uniserial_almost_split_sequence() {
for field in [f5(), f2()] {
let algebra = truncated_poly(3, field).unwrap();
let s = indec(&Module::simple(&algebra, 0));
let sequence = sequence_of(&s);
assert_eq!(sequence.sequence().sub().dim_vector(), &[1]);
assert_eq!(sequence.sequence().middle().dim_vector(), &[2]);
assert_eq!(sequence.sequence().quotient().dim_vector(), &[1]);
assert_eq!(
middle_classes(sequence.sequence().middle()),
vec![(vec![2], 1)]
);
let witness = duality_witness(&sequence);
assert_eq!(witness.ext_dim(), 1);
assert_eq!(witness.stable_end_dim(), 1);
assert_eq!(witness.socle_dim(), 1);
assert_eq!(witness.residue_degree(), 1);
assert_eq!(witness.chosen_row(), 0);
assert!(witness.action_traces().is_empty(), "rad End(S) = 0");
assert!(witness.verify(&s, sequence.sequence(), sequence.chosen_ar_class()));
}
}
#[test]
fn truncated_poly_3_rad_p_has_middle_simple_plus_projective() {
for field in [f5(), f2()] {
let algebra = truncated_poly(3, field).unwrap();
let p = Module::projective(&algebra, 0);
let r = indec(&radical(&p).0);
let sequence = sequence_of(&r);
assert_eq!(sequence.sequence().sub().dim_vector(), &[2]);
assert_eq!(sequence.sequence().middle().dim_vector(), &[4]);
assert_eq!(sequence.sequence().quotient().dim_vector(), &[2]);
assert_eq!(
middle_classes(sequence.sequence().middle()),
vec![(vec![1], 1), (vec![3], 1)]
);
let witness = duality_witness(&sequence);
assert_eq!(witness.ext_dim(), 1);
assert_eq!(witness.stable_end_dim(), 1);
assert_eq!(witness.socle_dim(), 1);
assert_eq!(
witness.action_traces().len(),
1,
"rad End(R) has dimension 1"
);
assert!(
witness
.action_traces()
.iter()
.all(|trace| trace.iter().all(|v| v.is_zero()))
);
assert!(witness.verify(&r, sequence.sequence(), sequence.chosen_ar_class()));
}
}
#[test]
fn linear_a3_sequence_ending_at_s1_has_middle_p1() {
let algebra = linear_an(3, f5());
let s1 = indec(&Module::simple(&algebra, 1));
let sequence = sequence_of(&s1);
assert_eq!(sequence.sequence().sub().dim_vector(), &[0, 0, 1]);
assert_eq!(sequence.sequence().middle().dim_vector(), &[0, 1, 1]);
assert_eq!(sequence.sequence().quotient().dim_vector(), &[0, 1, 0]);
assert_eq!(
middle_classes(sequence.sequence().middle()),
vec![(vec![0, 1, 1], 1)]
);
let witness = duality_witness(&sequence);
assert_eq!(witness.socle_dim(), 1);
assert_eq!(witness.residue_degree(), 1);
assert!(witness.verify(&s1, sequence.sequence(), sequence.chosen_ar_class()));
}
#[test]
fn linear_a3_sequence_ending_at_i1_matches_the_mesh() {
let algebra = linear_an(3, f5());
let i1 = indec(&Module::injective(&algebra, 1));
assert_eq!(i1.module().dim_vector(), &[1, 1, 0]);
let sequence = sequence_of(&i1);
assert_eq!(sequence.sequence().sub().dim_vector(), &[0, 1, 1]);
assert_eq!(sequence.sequence().middle().dim_vector(), &[1, 2, 1]);
assert_eq!(
middle_classes(sequence.sequence().middle()),
vec![(vec![0, 1, 0], 1), (vec![1, 1, 1], 1)]
);
let witness = duality_witness(&sequence);
assert_eq!(witness.socle_dim(), 1);
assert!(witness.verify(&i1, sequence.sequence(), sequence.chosen_ar_class()));
}
#[test]
fn commutative_square_s1_sequence_invariants_hold() {
let algebra = commutative_square(f5());
let s1 = indec(&Module::simple(&algebra, 1));
let sequence = sequence_of(&s1);
assert_eq!(sequence.sequence().quotient().dim_vector(), &[0, 1, 0, 0]);
assert_eq!(
sequence.sequence().sub().total_dim() + sequence.sequence().quotient().total_dim(),
sequence.sequence().middle().total_dim()
);
let witness = duality_witness(&sequence);
assert_eq!(witness.ext_dim(), witness.stable_end_dim());
assert_eq!(witness.socle_dim(), 1);
assert_eq!(witness.residue_degree(), 1);
assert!(witness.verify(&s1, sequence.sequence(), sequence.chosen_ar_class()));
}
#[test]
fn preprojective_a3_simple_sequence_invariants_hold() {
let algebra = preprojective_a3();
let s0 = indec(&Module::simple(&algebra, 0));
assert!(!s0.is_projective());
let sequence = sequence_of(&s0);
assert_eq!(
sequence.sequence().sub().total_dim() + sequence.sequence().quotient().total_dim(),
sequence.sequence().middle().total_dim()
);
let witness = duality_witness(&sequence);
assert_eq!(witness.ext_dim(), witness.stable_end_dim());
assert_eq!(witness.socle_dim(), 1);
assert_eq!(witness.residue_degree(), 1);
assert!(witness.verify(&s0, sequence.sequence(), sequence.chosen_ar_class()));
}
#[test]
fn truncated_poly_4_interval_module_has_a_proper_socle() {
let field = f5();
let algebra = truncated_poly(4, field).unwrap();
let p = Module::projective(&algebra, 0);
let m = indec(&radical(&radical(&p).0).0);
assert_eq!(m.module().dim_vector(), &[2]);
let sequence = sequence_of(&m);
assert_eq!(sequence.sequence().sub().dim_vector(), &[2]);
assert_eq!(sequence.sequence().middle().dim_vector(), &[4]);
assert_eq!(
middle_classes(sequence.sequence().middle()),
vec![(vec![1], 1), (vec![3], 1)]
);
let witness = duality_witness(&sequence);
assert_eq!(witness.ext_dim(), 2);
assert_eq!(witness.stable_end_dim(), 2);
assert_eq!(witness.socle_dim(), 1);
assert_eq!(witness.residue_degree(), 1);
assert_eq!(witness.action_traces().len(), 1);
assert_eq!(witness.action_traces()[0].len(), 2);
assert!(witness.action_traces()[0].iter().all(|v| v.is_zero()));
assert!(witness.verify(&m, sequence.sequence(), sequence.chosen_ar_class()));
}
#[test]
fn stable_hom_dimensions_match_hand_counts() {
let a3 = linear_an(3, f5());
let s2 = Module::simple(&a3, 2);
assert_eq!(stable_end(&s2).unwrap().dim(), 0);
let s1 = Module::simple(&a3, 1);
assert_eq!(stable_end(&s1).unwrap().dim(), 1);
for field in [f5(), f2()] {
let algebra = truncated_poly(3, field).unwrap();
let p = Module::projective(&algebra, 0);
let r = radical(&p).0;
let space = HomSpace::new(&r, &r).unwrap();
assert_eq!(space.dim(), 2);
assert_eq!(projectively_trivial(&space).unwrap().dim(), 1);
assert_eq!(stable_end(&r).unwrap().dim(), 1);
}
}
#[test]
fn projective_inputs_return_the_projective_outcome() {
let a3 = linear_an(3, f5());
for v in 0..3 {
let p = indec(&Module::projective(&a3, v));
assert!(matches!(
super::super::almost_split(&p).unwrap(),
AlmostSplitOutcome::Projective
));
}
let algebra = truncated_poly(3, f2()).unwrap();
let p = indec(&Module::projective(&algebra, 0));
assert!(matches!(
super::super::almost_split(&p).unwrap(),
AlmostSplitOutcome::Projective
));
let catalog = IndecomposableCatalog::nakayama(&algebra).unwrap();
assert!(matches!(
super::super::almost_split_via_catalog(&p, &catalog).unwrap(),
AlmostSplitOutcome::Projective
));
}