use crate::hom::Morphism;
use crate::module::Module;
use crate::opposite::{dual, dual_morphism, opposite};
use crate::resolution::{Bounded, ResolutionEnd, projective_cover, resolve};
pub fn injective_envelope(m: &Module) -> (Module, Morphism) {
let op = opposite(m.algebra());
let dm = dual(m, &op).expect("m lives over the algebra side of its own opposite pair");
let (cover_term, cover) = projective_cover(&dm);
let envelope =
dual(&cover_term, &op).expect("the cover of D(m) lives over the opposite side of the pair");
let embedding = dual_morphism(&cover, m, &envelope, &op)
.expect("D(D(m)) is m entry for entry, and the envelope is D of the cover term");
(envelope, embedding)
}
pub struct InjectiveCoresolution {
pub terms: Vec<Module>,
pub maps: Vec<Morphism>,
pub coaugmentation: Morphism,
pub end: ResolutionEnd,
}
pub fn coresolve(m: &Module, steps: usize) -> InjectiveCoresolution {
let op = opposite(m.algebra());
let dm = dual(m, &op).expect("m lives over the algebra side of its own opposite pair");
let resolution = resolve(&dm, steps);
let terms: Vec<Module> = resolution
.terms
.iter()
.map(|p| dual(p, &op).expect("resolution terms live over the opposite side of the pair"))
.collect();
let coaugmentation = dual_morphism(&resolution.augmentation, m, &terms[0], &op)
.expect("D(D(m)) is m entry for entry, and terms[0] is D(P_0)");
let maps = resolution
.maps
.iter()
.enumerate()
.map(|(k, d)| {
dual_morphism(d, &terms[k], &terms[k + 1], &op)
.expect("terms[k] is D(P_k) and terms[k + 1] is D(P_{k+1})")
})
.collect();
InjectiveCoresolution {
terms,
maps,
coaugmentation,
end: resolution.end,
}
}
pub fn injective_dimension(m: &Module, bound: usize) -> Bounded<usize> {
let coresolution = coresolve(m, bound);
match coresolution.end {
ResolutionEnd::Finite => Bounded::Exact(coresolution.terms.len() - 1),
ResolutionEnd::Cut { at } => Bounded::AtLeast(at + 1),
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::algebra::{
MonomialAlgebra, an_with_relations, cyclic_nakayama, dual_numbers, linear_an,
linear_nakayama, radical_square_zero_cycle, truncated_poly,
};
use crate::field::PrimeField;
use crate::hom::{image, kernel};
use crate::iso::{IsoOutcome, is_isomorphic};
use crate::module::direct_sum;
use crate::radical::socle;
use std::sync::Arc;
fn fields() -> [PrimeField; 3] {
[
PrimeField::new(2).unwrap(),
PrimeField::new(5).unwrap(),
PrimeField::new(32003).unwrap(),
]
}
fn socle_injective_sum(m: &Module) -> Module {
let algebra = m.algebra();
let field = m.field();
let (soc, _) = socle(m);
let mut parts = Vec::new();
for v in 0..algebra.quiver().num_vertices() {
for _ in 0..soc.dim_at(v) {
parts.push(Module::injective(algebra, field, v));
}
}
if parts.is_empty() {
return Module::zero(algebra, field);
}
let refs: Vec<&Module> = parts.iter().collect();
direct_sum(&refs).0
}
fn is_mono(f: &Morphism) -> bool {
let field = f.source().field();
(0..f.source().algebra().quiver().num_vertices())
.all(|v| f.map_at(v).rank(&field) == f.source().dim_at(v))
}
fn fixtures() -> Vec<Arc<MonomialAlgebra>> {
vec![
linear_an(3),
an_with_relations(3, &[(0, 2)]).unwrap(),
dual_numbers(),
truncated_poly(3).unwrap(),
radical_square_zero_cycle(3),
cyclic_nakayama(&[3, 3, 3]).unwrap(),
]
}
fn assorted_modules(algebra: &Arc<MonomialAlgebra>, field: PrimeField) -> Vec<Module> {
let n = algebra.quiver().num_vertices();
let mut modules = vec![Module::zero(algebra, field)];
for v in 0..n {
modules.push(Module::simple(algebra, field, v));
modules.push(Module::projective(algebra, field, v));
modules.push(Module::injective(algebra, field, v));
}
let s0 = Module::simple(algebra, field, 0);
let p_last = Module::projective(algebra, field, n - 1);
modules.push(direct_sum(&[&s0, &p_last]).0);
modules
}
#[test]
fn envelope_of_a_simple_is_the_indecomposable_injective() {
for algebra in fixtures() {
for field in fields() {
for v in 0..algebra.quiver().num_vertices() {
let s = Module::simple(&algebra, field, v);
let (envelope, embedding) = injective_envelope(&s);
let i_v = Module::injective(&algebra, field, v);
assert_eq!(envelope.dim_vector(), i_v.dim_vector(), "I(S_{v})");
assert!(is_mono(&embedding));
assert!(embedding.source().ptr_eq(&s));
}
}
}
}
#[test]
fn envelope_of_the_zero_module_is_zero() {
let algebra = linear_an(3);
let z = Module::zero(&algebra, PrimeField::new(5).unwrap());
let (envelope, embedding) = injective_envelope(&z);
assert!(envelope.is_zero());
assert!(embedding.is_zero());
assert_eq!(injective_dimension(&z, 4), Bounded::Exact(0));
}
#[test]
fn envelope_agrees_with_the_socle_direct_sum_and_is_essential() {
for algebra in fixtures() {
for field in fields() {
for m in assorted_modules(&algebra, field) {
let (envelope, embedding) = injective_envelope(&m);
let by_socle = socle_injective_sum(&m);
assert_eq!(
envelope.dim_vector(),
by_socle.dim_vector(),
"envelope of {:?} over F_{}",
m.dim_vector(),
field.modulus()
);
assert!(is_mono(&embedding));
assert_eq!(
socle(&envelope).0.dim_vector(),
socle(&m).0.dim_vector(),
"essential image for {:?}",
m.dim_vector()
);
}
}
}
}
#[test]
fn envelope_is_isomorphic_to_the_socle_direct_sum() {
for algebra in [linear_an(3), an_with_relations(3, &[(0, 2)]).unwrap()] {
for field in fields() {
for m in assorted_modules(&algebra, field) {
let (envelope, _) = injective_envelope(&m);
let by_socle = socle_injective_sum(&m);
assert!(
matches!(
is_isomorphic(&envelope, &by_socle).unwrap(),
IsoOutcome::Isomorphic(_)
),
"envelope of {:?} over F_{}",
m.dim_vector(),
field.modulus()
);
}
}
}
}
#[test]
fn a3_simples_have_injective_dimensions_0_1_1() {
for field in fields() {
let algebra = linear_an(3);
let expected = [0usize, 1, 1];
for v in 0..3u32 {
let s = Module::simple(&algebra, field, v);
assert_eq!(
injective_dimension(&s, 5),
Bounded::Exact(expected[v as usize]),
"id S_{v}"
);
}
}
}
#[test]
fn a3_mod_ab_simple_2_coresolves_through_i2_i1_i0() {
for field in fields() {
let algebra = an_with_relations(3, &[(0, 2)]).unwrap();
let s2 = Module::simple(&algebra, field, 2);
let coresolution = coresolve(&s2, 5);
assert_eq!(coresolution.end, ResolutionEnd::Finite);
let dims: Vec<&[usize]> = coresolution.terms.iter().map(Module::dim_vector).collect();
assert_eq!(dims, vec![&[0, 1, 1][..], &[1, 1, 0], &[1, 0, 0]]);
assert_eq!(injective_dimension(&s2, 5), Bounded::Exact(2));
let s1 = Module::simple(&algebra, field, 1);
let s0 = Module::simple(&algebra, field, 0);
assert_eq!(injective_dimension(&s1, 5), Bounded::Exact(1));
assert_eq!(injective_dimension(&s0, 5), Bounded::Exact(0));
}
}
#[test]
fn truncated_poly_projectives_are_injective() {
for field in fields() {
for n in 2..5 {
let algebra = truncated_poly(n).unwrap();
let p = Module::projective(&algebra, field, 0);
assert_eq!(
injective_dimension(&p, 6),
Bounded::Exact(0),
"id A for x^{n}"
);
let i = Module::injective(&algebra, field, 0);
assert_eq!(p.dim_vector(), i.dim_vector());
}
}
}
#[test]
fn dual_numbers_simple_coresolves_periodically() {
for field in fields() {
let algebra = dual_numbers();
let s = Module::simple(&algebra, field, 0);
let coresolution = coresolve(&s, 6);
assert_eq!(coresolution.end, ResolutionEnd::Cut { at: 6 });
assert_eq!(coresolution.terms.len(), 7);
for term in &coresolution.terms {
assert_eq!(term.dim_vector(), &[2]);
}
assert_eq!(injective_dimension(&s, 10), Bounded::AtLeast(11));
}
}
#[test]
fn cyclic_nakayama_is_self_injective_and_linear_nakayama_is_not() {
for field in fields() {
let cyclic = cyclic_nakayama(&[3, 3, 3]).unwrap();
for v in 0..3u32 {
let p = Module::projective(&cyclic, field, v);
assert_eq!(injective_dimension(&p, 6), Bounded::Exact(0), "id P_{v}");
}
let linear = linear_nakayama(&[3, 2, 1]).unwrap();
let p1 = Module::projective(&linear, field, 1);
assert_eq!(p1.dim_vector(), &[0, 1, 1]);
assert_eq!(injective_dimension(&p1, 6), Bounded::Exact(1));
}
}
#[test]
fn coresolve_with_zero_steps_reports_cut_for_a_noninjective_module() {
let field = PrimeField::new(32003).unwrap();
let algebra = linear_an(3);
let s2 = Module::simple(&algebra, field, 2);
let coresolution = coresolve(&s2, 0);
assert_eq!(coresolution.end, ResolutionEnd::Cut { at: 0 });
assert_eq!(coresolution.terms.len(), 1);
let i0 = Module::injective(&algebra, field, 0);
assert_eq!(coresolve(&i0, 0).end, ResolutionEnd::Finite);
}
#[test]
fn coresolution_prefixes_are_complexes_and_exact() {
for algebra in fixtures() {
for field in fields() {
for m in assorted_modules(&algebra, field) {
let coresolution = coresolve(&m, 4);
assert!(is_mono(&coresolution.coaugmentation));
if let Some(d0) = coresolution.maps.first() {
assert!(
coresolution.coaugmentation.then(d0).unwrap().is_zero(),
"d^0 ∘ ι = 0"
);
}
for pair in coresolution.maps.windows(2) {
assert!(pair[0].then(&pair[1]).unwrap().is_zero(), "d² = 0");
}
for k in 0..coresolution.terms.len() {
let (incoming, _) = if k == 0 {
image(&coresolution.coaugmentation)
} else {
image(&coresolution.maps[k - 1])
};
if k + 1 < coresolution.terms.len() {
let (ker, _) = kernel(&coresolution.maps[k]);
assert_eq!(
ker.dim_vector(),
incoming.dim_vector(),
"exactness at I^{k}"
);
} else if coresolution.end == ResolutionEnd::Finite {
assert_eq!(
incoming.dim_vector(),
coresolution.terms[k].dim_vector(),
"a finite coresolution ends onto its last term"
);
}
}
}
}
}
}
#[test]
fn differentials_vanish_on_socles() {
for algebra in fixtures() {
for field in fields() {
for m in assorted_modules(&algebra, field) {
let coresolution = coresolve(&m, 4);
for (k, d) in coresolution.maps.iter().enumerate() {
let (_, inclusion) = socle(&coresolution.terms[k]);
assert!(
inclusion.then(d).unwrap().is_zero(),
"soc I^{k} survives d^{k}"
);
}
}
}
}
}
#[test]
fn every_first_term_is_the_injective_envelope() {
for algebra in fixtures() {
for field in fields() {
for m in assorted_modules(&algebra, field) {
let coresolution = coresolve(&m, 3);
let (envelope, _) = injective_envelope(&m);
assert_eq!(coresolution.terms[0].dim_vector(), envelope.dim_vector());
assert_eq!(
injective_dimension(&coresolution.terms[0], 3),
Bounded::Exact(0),
"I^0 of {:?} is injective",
m.dim_vector()
);
}
}
}
}
}