use super::*;
#[test]
fn a_duplicated_pair_fails_verification() {
let field = f5();
let algebra = linear_an(2, field);
let catalog = IndecomposableCatalog::dynkin(&algebra).expect("A_2 is Dynkin");
for (index, dim_vectors, vertices) in [
(0usize, Vec::new(), vec![0u32, 1]),
(4, vec![vec![1, 0], vec![1, 1]], Vec::new()),
] {
let mut enumeration = enumerate_over_catalog(&catalog).expect("A_2 enumerates");
assert_eq!(enumeration.len(), 5);
assert!(enumeration.verify());
let duplicate = {
let pair = &enumeration.pairs()[index];
assert_eq!(pair.module().dim_vectors(), dim_vectors);
assert_eq!(pair.projective().vertices(), vertices);
let module = BasicDecomposition::new(pair.module().module())
.expect("the module part of a pair is basic");
let projective = ProjectiveSupport::new(&algebra, pair.projective().vertices())
.expect("the support of a pair is in range");
SupportTauTiltingPair::new(module, projective)
.expect("A_2 translates")
.expect("a rebuilt pair is a pair")
};
assert!(duplicate.verify(), "the duplicate is honest on its own");
enumeration.pairs.push(duplicate);
assert_eq!(enumeration.len(), 6);
assert!(!enumeration.verify(), "a duplicate of pair {index} passed");
}
}
#[test]
fn a_tampered_almost_complete_pair_fails_verification() {
for field in fields() {
let algebra = linear_an(3, field);
let p0 = Module::projective(&algebra, 0);
let p1 = Module::projective(&algebra, 1);
let p2 = Module::projective(&algebra, 2);
let two = sum(&algebra, &[&p0, &p1]);
let almost = |m: &Module| {
AlmostCompletePair::new(basic(m), support(&algebra, &[]))
.expect("A_3 translates")
.expect("a sum of two projectives is almost complete")
};
let pair = almost(&two);
assert!(pair.verify());
assert_eq!(pair.module().module().dim_vector(), &[1, 2, 2]);
assert_eq!(pair.omitted_vertex(), None);
assert!(pair.projective().is_empty());
let donor = almost(&sum(&algebra, &[&p1, &p2]));
assert!(donor.verify(), "the donor is honest");
assert_eq!(donor.module().module().dim_vector(), &[0, 1, 2]);
assert_eq!(donor.omitted_vertex(), Some(0));
assert!(donor.projective().is_empty());
let mut moved = almost(&sum(&algebra, &[&p1, &p2]));
moved.omitted = Some(1);
assert!(!moved.verify());
let mut forged = almost(&two);
assert_eq!(
donor.rigid().summands().len(),
forged.rigid.summands().len()
);
forged.rigid = donor.rigid().clone();
assert!(!forged.verify(), "over F_{}", field.modulus());
}
}