use super::*;
#[test]
fn isomorphic_pairs_have_equal_fingerprints() {
for field in fields() {
let algebra = linear_an(3, field);
let p0 = Module::projective(&algebra, 0);
let p2 = Module::projective(&algebra, 2);
let first = basic(&sum(&[&p0, &p2]));
let second = basic(&sum(&[&p2, &p0]));
let s = support(&algebra, &[1]);
assert_eq!(
PairFingerprint::new(&first, &s).unwrap(),
PairFingerprint::new(&second, &s).unwrap(),
"over F_{}",
field.modulus()
);
}
}
#[test]
fn fingerprints_separate_obviously_different_pairs() {
let algebra = linear_an(3, f5());
let p0 = basic(&Module::projective(&algebra, 0));
let p1 = basic(&Module::projective(&algebra, 1));
let both = basic(&sum(&[
&Module::projective(&algebra, 0),
&Module::projective(&algebra, 2),
]));
let left = support(&algebra, &[1]);
let right = support(&algebra, &[2]);
let base = PairFingerprint::new(&p0, &left).unwrap();
assert_ne!(base, PairFingerprint::new(&p0, &right).unwrap());
assert_ne!(base, PairFingerprint::new(&p1, &left).unwrap());
assert_ne!(base, PairFingerprint::new(&both, &left).unwrap());
assert_eq!(base.projective_support(), &[1]);
assert_eq!(base.summands().len(), 1);
}
#[test]
fn the_a3_regular_projective_fingerprint_is_hand_checkable() {
for field in fields() {
let algebra = linear_an(3, field);
let p0 = basic(&Module::projective(&algebra, 0));
let s = support(&algebra, &[]);
let fingerprint = PairFingerprint::new(&p0, &s).unwrap();
let record = &fingerprint.summands()[0];
assert_eq!(record.dim_vector(), &[1, 1, 1]);
assert_eq!(record.loewy_length(), 3);
assert_eq!(record.top_dim_vector(), &[1, 0, 0]);
assert_eq!(record.socle_dim_vector(), &[0, 0, 1]);
assert_eq!(record.end_dim(), 1);
assert_eq!(record.residue_degree(), 1);
assert_eq!(record.hom_from_simples(), &[0, 0, 1]);
assert_eq!(
record.hom_to_simples(),
&[1, 0, 0],
"over F_{}",
field.modulus()
);
assert!(fingerprint.projective_support().is_empty());
}
}
#[test]
fn the_kronecker_line_modules_collide_in_the_fingerprint() {
let field = f2();
let algebra = kronecker(2, field);
let modules = [
kronecker_line(&algebra, field, 1, 0),
kronecker_line(&algebra, field, 0, 1),
kronecker_line(&algebra, field, 1, 1),
];
let empty = support(&algebra, &[]);
let decompositions: Vec<BasicDecomposition> = modules.iter().map(basic).collect();
for decomposition in &decompositions {
assert_eq!(decomposition.len(), 1);
assert_eq!(decomposition.dim_vectors(), vec![vec![1, 1]]);
}
let fingerprints: Vec<PairFingerprint> = decompositions
.iter()
.map(|d| PairFingerprint::new(d, &empty).unwrap())
.collect();
assert_eq!(fingerprints[0], fingerprints[1]);
assert_eq!(fingerprints[0], fingerprints[2]);
let record = &fingerprints[0].summands()[0];
assert_eq!(record.loewy_length(), 2);
assert_eq!(record.top_dim_vector(), &[1, 0]);
assert_eq!(record.socle_dim_vector(), &[0, 1]);
assert_eq!(record.end_dim(), 1);
assert_eq!(record.hom_from_simples(), &[0, 1]);
assert_eq!(record.hom_to_simples(), &[1, 0]);
for i in 0..3 {
for j in 0..3 {
let outcome = pair_iso(&decompositions[i], &empty, &decompositions[j], &empty).unwrap();
if i == j {
assert!(expect_witness(outcome).verify());
} else {
assert_eq!(
expect_obstruction(outcome),
SupportPairObstruction::UnmatchedSummand {
index: 0,
dim_vector: vec![1, 1]
},
"the [1, 1] modules {i} and {j} are not isomorphic"
);
}
}
}
}
struct XorShift64(u64);
impl XorShift64 {
fn next(&mut self) -> u64 {
let mut x = self.0;
x ^= x << 13;
x ^= x >> 7;
x ^= x << 17;
self.0 = x;
x
}
fn below(&mut self, n: u64) -> u64 {
if n == 0 { 0 } else { self.next() % n }
}
}
fn invertible(rng: &mut XorShift64, field: &PrimeField, d: usize) -> DenseMat {
let mut g = DenseMat::identity(d);
if d == 0 {
return g;
}
for _ in 0..2 * d + 2 {
let i = rng.below(d as u64) as usize;
if d == 1 || rng.below(3) == 0 {
let c = field.elem(1 + rng.below(field.modulus() - 1) as i64);
for k in 0..d {
g.set(i, k, field.mul(g.get(i, k), c));
}
continue;
}
let j = (i + 1 + rng.below(d as u64 - 1) as usize) % d;
if rng.below(2) == 0 {
for k in 0..d {
let (a, b) = (g.get(i, k), g.get(j, k));
g.set(i, k, b);
g.set(j, k, a);
}
} else {
let c = field.elem(rng.below(field.modulus()) as i64);
for k in 0..d {
g.set(i, k, field.add(g.get(i, k), field.mul(c, g.get(j, k))));
}
}
}
g
}
fn basis_change(rng: &mut XorShift64, m: &Module) -> Module {
let field = m.field();
let quiver = m.algebra().quiver();
let g: Vec<DenseMat> = m
.dim_vector()
.iter()
.map(|&d| invertible(rng, &field, d))
.collect();
let g_inv: Vec<DenseMat> = g
.iter()
.map(|x| {
x.inverse(&field)
.expect("elementary operations stay invertible")
})
.collect();
let maps: Vec<DenseMat> = (0..quiver.num_arrows())
.map(|i| {
let a = ArrowId(i as u32);
let (s, t) = (quiver.source(a) as usize, quiver.target(a) as usize);
g[s].mul(m.map(a), &field).mul(&g_inv[t], &field)
})
.collect();
Module::new(m.algebra().clone(), m.dim_vector().to_vec(), maps)
.expect("a vertexwise basis change preserves the relations")
}
#[test]
fn the_fingerprint_is_constant_on_isomorphism_classes() {
let field = f5();
let algebra = d4(field);
let catalog = IndecomposableCatalog::dynkin(&algebra).expect("D_4 is Dynkin");
let enumeration = enumerate_over_catalog(&catalog).expect("D_4 enumerates");
assert_eq!(enumeration.len(), 50);
let mut rng = XorShift64(0x5eed_0005_0005_0001);
let mut fingerprints = Vec::with_capacity(enumeration.len());
let mut moved = 0;
for pair in enumeration.pairs() {
let before = PairFingerprint::new(pair.module(), &pair.projective()).unwrap();
let module = pair.module().module();
let rebuilt = basis_change(&mut rng, module);
let decomposition =
BasicDecomposition::new(&rebuilt).expect("a basis change keeps the module basic");
let after = PairFingerprint::new(&decomposition, &pair.projective()).unwrap();
assert_eq!(
before,
after,
"the fingerprint moved under a basis change of {:?}",
pair.module().dim_vectors()
);
let arrows = 0..algebra.quiver().num_arrows();
let same: Vec<bool> = arrows
.map(|i| {
let a = ArrowId(i as u32);
rebuilt.map(a) == module.map(a)
})
.collect();
if same.iter().all(|&s| s) {
for i in 0..algebra.quiver().num_arrows() {
let matrix = module.map(ArrowId(i as u32));
assert!(
matrix.rows() == 0 || matrix.cols() == 0,
"a nonempty arrow matrix survived the basis change in {:?}",
pair.module().dim_vectors()
);
}
} else {
moved += 1;
}
fingerprints.push(before);
}
assert_eq!(moved, 41);
let mut admitted = 0;
for (i, left) in fingerprints.iter().enumerate() {
for (j, right) in fingerprints.iter().enumerate() {
if left == right {
admitted += 1;
assert_eq!(i, j, "pairs {i} and {j} share a fingerprint");
}
}
}
assert_eq!(admitted, 50);
}
#[test]
fn the_fingerprint_separates_on_residue_degree() {
let field = f2();
let algebra = kronecker(2, field);
let mut companion = DenseMat::zero(3, 3);
companion.set(0, 1, field.one());
companion.set(1, 2, field.one());
companion.set(2, 0, field.one());
companion.set(2, 1, field.one());
let w = Module::new(
algebra.clone(),
vec![3, 3],
vec![DenseMat::identity(3), companion],
)
.expect("a Kronecker representation is a module");
let mut jordan = DenseMat::zero(3, 3);
jordan.set(0, 1, field.one());
jordan.set(1, 2, field.one());
let j = Module::new(
algebra.clone(),
vec![3, 3],
vec![DenseMat::identity(3), jordan],
)
.expect("a Kronecker representation is a module");
let empty = support(&algebra, &[]);
let f8 = PairFingerprint::new(&basic(&w), &empty).unwrap();
let f2_residue = PairFingerprint::new(&basic(&j), &empty).unwrap();
let (left, right) = (&f8.summands()[0], &f2_residue.summands()[0]);
assert_eq!(left.residue_degree(), 3);
assert_eq!(right.residue_degree(), 1);
assert_ne!(f8, f2_residue, "residue degree is the separating field");
assert_eq!(left.dim_vector(), right.dim_vector());
assert_eq!(left.dim_vector(), &[3, 3]);
assert_eq!(left.loewy_length(), right.loewy_length());
assert_eq!(left.loewy_length(), 2);
assert_eq!(left.top_dim_vector(), right.top_dim_vector());
assert_eq!(left.top_dim_vector(), &[3, 0]);
assert_eq!(left.socle_dim_vector(), right.socle_dim_vector());
assert_eq!(left.socle_dim_vector(), &[0, 3]);
assert_eq!(left.end_dim(), right.end_dim());
assert_eq!(left.end_dim(), 3);
assert_eq!(left.hom_from_simples(), right.hom_from_simples());
assert_eq!(left.hom_from_simples(), &[0, 3]);
assert_eq!(left.hom_to_simples(), right.hom_to_simples());
assert_eq!(left.hom_to_simples(), &[3, 0]);
}