use super::fixtures::{
assert_target, d4, f5, fields, left, no_left, pair_of, regular_pair, semisimple,
};
use crate::algebra::{linear_an, truncated_poly};
use crate::module::Module;
use crate::mutation::{ExchangeShape, MutationError, SlotOutcome, mutate_at, mutate_at_with_cache};
use crate::taurigid::TauCache;
#[test]
fn a2_pentagon_slot_by_slot() {
for field in fields() {
let algebra = linear_an(2, field);
let p0 = Module::projective(&algebra, 0);
let p1 = Module::projective(&algebra, 1);
let s0 = Module::simple(&algebra, 0);
let v1 = pair_of(&algebra, &[&p0, &p1], &[]);
let v2 = pair_of(&algebra, &[&p0, &s0], &[]);
let v3 = pair_of(&algebra, &[&s0], &[1]);
let v4 = pair_of(&algebra, &[&p1], &[0]);
let v5 = pair_of(&algebra, &[], &[0, 1]);
let at_p0 = left(&v1, &[1, 1]);
assert_target(&at_p0, &[&[0, 1]], &[0]);
assert_eq!(
*at_p0.shape(),
ExchangeShape::MovesToProjective { vertex: 0 }
);
assert!(at_p0.witness().approximation().map().target().is_zero());
let at_p1 = left(&v1, &[0, 1]);
assert_target(&at_p1, &[&[1, 1], &[1, 0]], &[]);
assert_eq!(
*at_p1.shape(),
ExchangeShape::ReplacedByModule { multiplicity: 1 }
);
assert_eq!(
at_p1.witness().replacement().map(|y| y.dim_vector()),
Some([1, 0].as_slice())
);
let v2_at_p0 = left(&v2, &[1, 1]);
assert_target(&v2_at_p0, &[&[1, 0]], &[1]);
assert_eq!(
*v2_at_p0.shape(),
ExchangeShape::MovesToProjective { vertex: 1 }
);
let fac = no_left(&v2, &[1, 0]);
assert_eq!(fac.image_dims(), [1, 0]);
assert_eq!(fac.maps().len(), 1);
let v3_at_s0 = left(&v3, &[1, 0]);
assert_target(&v3_at_s0, &[], &[0, 1]);
assert_eq!(
*v3_at_s0.shape(),
ExchangeShape::MovesToProjective { vertex: 0 }
);
let v4_at_p1 = left(&v4, &[0, 1]);
assert_target(&v4_at_p1, &[], &[0, 1]);
assert_eq!(
*v4_at_p1.shape(),
ExchangeShape::MovesToProjective { vertex: 1 }
);
assert_eq!(v5.module().len(), 0);
assert!(matches!(
mutate_at(&v5, 0),
Err(MutationError::SlotOutOfRange {
slot: 0,
summands: 0
})
));
}
}
#[test]
fn semisimple_two_vertex_cube() {
for field in fields() {
let algebra = semisimple(2, field);
let p0 = Module::projective(&algebra, 0);
let p1 = Module::projective(&algebra, 1);
let top = pair_of(&algebra, &[&p0, &p1], &[]);
let left_side = pair_of(&algebra, &[&p1], &[0]);
let right_side = pair_of(&algebra, &[&p0], &[1]);
let bottom = pair_of(&algebra, &[], &[0, 1]);
let drop_p0 = left(&top, &[1, 0]);
assert_target(&drop_p0, &[&[0, 1]], &[0]);
assert_eq!(
*drop_p0.shape(),
ExchangeShape::MovesToProjective { vertex: 0 }
);
let drop_p1 = left(&top, &[0, 1]);
assert_target(&drop_p1, &[&[1, 0]], &[1]);
let down_left = left(&left_side, &[0, 1]);
assert_target(&down_left, &[], &[0, 1]);
let down_right = left(&right_side, &[1, 0]);
assert_target(&down_right, &[], &[0, 1]);
assert_eq!(bottom.module().len(), 0);
}
}
#[test]
fn linear_an_3_pinned_edges() {
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 s0 = Module::simple(&algebra, 0);
assert_eq!(Module::injective(&algebra, 1).dim_vector(), [1, 1, 0]);
let vertex_a = pair_of(&algebra, &[&p0, &s0, &p2], &[]);
let vertex_b = pair_of(&algebra, &[&p0, &p1, &p2], &[]);
let vertex_h = pair_of(&algebra, &[&s0, &p2], &[1]);
let vertex_k = pair_of(&algebra, &[&p2], &[0, 1]);
let vertex_m = pair_of(&algebra, &[&s0], &[1, 2]);
let b_at_p2 = left(&vertex_b, &[0, 0, 1]);
assert_target(&b_at_p2, &[&[1, 1, 1], &[0, 1, 1], &[0, 1, 0]], &[]);
assert_eq!(
*b_at_p2.shape(),
ExchangeShape::ReplacedByModule { multiplicity: 1 }
);
let b_at_p1 = left(&vertex_b, &[0, 1, 1]);
assert_target(&b_at_p1, &[&[1, 1, 1], &[0, 0, 1], &[1, 0, 0]], &[]);
let b_at_p0 = left(&vertex_b, &[1, 1, 1]);
assert_target(&b_at_p0, &[&[0, 1, 1], &[0, 0, 1]], &[0]);
assert_eq!(
*b_at_p0.shape(),
ExchangeShape::MovesToProjective { vertex: 0 }
);
let a_at_p2 = left(&vertex_a, &[0, 0, 1]);
assert_target(&a_at_p2, &[&[1, 1, 1], &[1, 0, 0], &[1, 1, 0]], &[]);
let fac = no_left(&vertex_a, &[1, 0, 0]);
assert_eq!(fac.image_dims(), [1, 0, 0]);
let a_at_p0 = left(&vertex_a, &[1, 1, 1]);
assert_target(&a_at_p0, &[&[1, 0, 0], &[0, 0, 1]], &[1]);
assert_eq!(
*a_at_p0.shape(),
ExchangeShape::MovesToProjective { vertex: 1 }
);
let h_at_p2 = left(&vertex_h, &[0, 0, 1]);
assert_target(&h_at_p2, &[&[1, 0, 0]], &[1, 2]);
let h_at_s0 = left(&vertex_h, &[1, 0, 0]);
assert_target(&h_at_s0, &[&[0, 0, 1]], &[0, 1]);
let k_at_p2 = left(&vertex_k, &[0, 0, 1]);
assert_target(&k_at_p2, &[], &[0, 1, 2]);
let m_at_s0 = left(&vertex_m, &[1, 0, 0]);
assert_target(&m_at_s0, &[], &[0, 1, 2]);
}
}
#[test]
fn every_slot_of_the_regular_pair_mutates() {
for field in fields() {
for algebra in [linear_an(3, field), d4(field)] {
let pair = regular_pair(&algebra);
assert_eq!(pair.module().len(), pair.summand_count());
for slot in 0..pair.module().len() {
let outcome = mutate_at(&pair, slot).expect("the regular pair mutates");
let mutation = match outcome {
SlotOutcome::LeftMutation(mutation) => *mutation,
SlotOutcome::NoLeftMutation(_) => {
panic!("slot {slot} of the regular pair has a left mutation")
}
};
assert!(mutation.witness().verify());
assert!(mutation.target().verify());
}
}
}
}
#[test]
fn truncated_poly_3_has_one_slot_to_the_zero_pair() {
for field in fields() {
let algebra = truncated_poly(3, field).expect("x^3 is admissible");
let pair = regular_pair(&algebra);
assert_eq!(pair.module().len(), 1);
let mutation = left(&pair, &[3]);
assert_target(&mutation, &[], &[0]);
assert_eq!(
*mutation.shape(),
ExchangeShape::MovesToProjective { vertex: 0 }
);
assert!(mutation.target().module().is_empty());
}
}
#[test]
fn one_cache_serves_several_mutations() {
let algebra = linear_an(3, f5());
let pair = regular_pair(&algebra);
let indices: Vec<usize> = (0..pair.module().len()).collect();
let mut cache = TauCache::new();
let mut hits = Vec::new();
for slot in 0..pair.module().len() {
let outcome = mutate_at_with_cache(
&pair,
slot,
&indices,
indices.len() + slot,
Some(&mut cache),
)
.expect("the regular pair mutates");
assert!(outcome.is_left_mutation());
hits.push(cache.hits());
}
assert!(hits[0] > 0, "the first call already reuses a translate");
assert!(
hits[2] > hits[0],
"later calls keep hitting the shared store, got {hits:?}"
);
assert!(cache.misses() > 0);
}