use super::*;
#[test]
fn the_regular_pair_is_a_support_tau_tilting_pair() {
for field in fields() {
for algebra in [
linear_an(2, field),
linear_an(3, field),
d4(field),
truncated_poly(3, field).unwrap(),
linear_nakayama(&[2, 2, 1], field).unwrap(),
radical_square_zero_cycle(3, field),
commutative_square(field),
kronecker(2, field),
semisimple(3, field),
] {
let n = algebra.quiver().num_vertices() as usize;
let pair = expect_pair(
SupportTauTiltingPair::classify(basic(®ular(&algebra)), support(&algebra, &[]))
.expect("the fixture translates"),
);
assert_eq!(pair.module().len(), n);
assert_eq!(pair.summand_count(), n);
assert!(pair.is_tau_tilting(), "the projective part is empty");
assert!(pair.projective().is_empty());
assert!(pair.rigid().vanishing_pairs().is_empty(), "tau A is zero");
assert!(pair.verify(), "over F_{}", field.modulus());
}
}
}
#[test]
fn the_zero_module_over_the_full_support_is_a_support_tau_tilting_pair() {
for field in fields() {
for algebra in [
linear_an(2, field),
d4(field),
truncated_poly(3, field).unwrap(),
kronecker(2, field),
] {
let n = algebra.quiver().num_vertices() as usize;
let pair = expect_pair(
SupportTauTiltingPair::classify(
basic(&Module::zero(&algebra)),
support(&algebra, &all_vertices(&algebra)),
)
.expect("the zero module needs no translate"),
);
assert!(pair.module().is_empty());
assert_eq!(pair.projective().len(), n);
assert_eq!(pair.summand_count(), n);
assert!(!pair.is_tau_tilting(), "the projective part is all of A");
assert!(pair.rigid().is_zero_module());
assert!(pair.verify(), "over F_{}", field.modulus());
}
}
}
#[test]
fn each_condition_has_its_own_rejection() {
for field in fields() {
let algebra = linear_an(2, field);
let other = linear_an(2, field);
let s0 = Module::simple(&algebra, 0);
let s1 = Module::simple(&algebra, 1);
let p0 = Module::projective(&algebra, 0);
let mismatched = expect_rejection(
SupportTauTiltingPair::classify(basic(&p0), support(&other, &[]))
.expect("the algebra check runs before any Hom space"),
);
assert_eq!(mismatched.condition(), 1);
assert!(matches!(mismatched, PairRejection::DifferentAlgebras));
let hom = expect_rejection(
SupportTauTiltingPair::classify(basic(&p0), support(&algebra, &[1]))
.expect("A_2 translates"),
);
assert_eq!(hom.condition(), 2);
assert!(matches!(
hom,
PairRejection::HomFromProjectiveNonzero { vertex: 1, dim: 1 }
));
let rigid = expect_rejection(
SupportTauTiltingPair::classify(
basic(&sum(&algebra, &[&s0, &s1])),
support(&algebra, &[]),
)
.expect("A_2 translates"),
);
assert_eq!(rigid.condition(), 3);
match &rigid {
PairRejection::NotTauRigid(witness) => {
assert_eq!(witness.translate().dim_vector(), &[0, 1]);
assert!(witness.verify());
}
other => panic!("expected a tau-rigidity failure, got {other}"),
}
let count = expect_rejection(
SupportTauTiltingPair::classify(basic(&Module::zero(&algebra)), support(&algebra, &[]))
.expect("the zero module needs no translate"),
);
assert_eq!(count.condition(), 4);
assert!(matches!(
count,
PairRejection::SummandCount {
module: 0,
projective: 0,
expected: 2
}
));
}
}
#[test]
fn the_a2_near_miss_is_rejected_by_the_right_module_hom_condition() {
for field in fields() {
let algebra = linear_an(2, field);
let p0 = Module::projective(&algebra, 0);
assert_eq!(basic(&p0).len() + support(&algebra, &[1]).len(), 2);
let alone = expect_pair(
SupportTauTiltingPair::classify(
basic(&sum(&algebra, &[&p0, &Module::simple(&algebra, 0)])),
support(&algebra, &[]),
)
.expect("A_2 translates"),
);
assert!(alone.verify());
let rejection = expect_rejection(
SupportTauTiltingPair::classify(basic(&p0), support(&algebra, &[1]))
.expect("A_2 translates"),
);
assert_eq!(rejection.condition(), 2);
match rejection {
PairRejection::HomFromProjectiveNonzero { vertex, dim } => {
assert_eq!((vertex, dim), (1, 1));
assert_eq!(
hom_dim(&Module::projective(&algebra, vertex), &p0).unwrap(),
dim,
"over F_{}",
field.modulus()
);
}
other => panic!("the right-module condition must fire here, got {other}"),
}
}
}
#[test]
fn the_a2_pentagon_lists_five_pairs_by_dimension_vector() {
for field in fields() {
let algebra = linear_an(2, field);
let catalog = IndecomposableCatalog::dynkin(&algebra).expect("A_2 is Dynkin");
let enumeration = enumerate_over_catalog(&catalog).expect("A_2 enumerates");
let mut listed: Vec<(Vec<Vec<usize>>, Vec<u32>)> = enumeration
.pairs()
.iter()
.map(|pair| {
(
pair.module().dim_vectors(),
pair.projective().vertices().to_vec(),
)
})
.collect();
listed.sort();
assert_eq!(
listed,
vec![
(vec![], vec![0, 1]),
(vec![vec![0, 1]], vec![0]),
(vec![vec![0, 1], vec![1, 1]], vec![]),
(vec![vec![1, 0]], vec![1]),
(vec![vec![1, 0], vec![1, 1]], vec![]),
],
"over F_{}",
field.modulus()
);
assert_eq!(enumeration.len(), 5);
assert_eq!(enumeration.histogram(), vec![1, 2, 2]);
assert_eq!(
enumeration
.pairs()
.iter()
.filter(|pair| pair.is_tau_tilting())
.count(),
2
);
assert!(enumeration.verify());
}
}