auslander 0.8.0

Computational representation theory of finite-dimensional bound quiver algebras
Documentation
use std::sync::Arc;

use super::complex::zero_between;
use super::*;
use crate::algebra::linear_an;
use crate::field::PrimeField;
use crate::hom::{Morphism, identity};
use crate::module::Module;

fn f5() -> PrimeField {
    PrimeField::new(5).unwrap()
}

fn one_term() -> (Arc<crate::algebra::Algebra>, Module) {
    let algebra = linear_an(1, f5());
    let module = Module::simple(&algebra, 0);
    (algebra, module)
}

fn zero_differential(m: &Module) -> Morphism {
    zero_between(m, m)
}

#[test]
fn constructor_uses_homological_degree_order() {
    let (_algebra, simple) = one_term();
    let complex = BoundedComplex::new(
        -1,
        vec![simple.clone(), simple.clone()],
        vec![zero_differential(&simple)],
    )
    .unwrap();
    assert_eq!(complex.range(), DegreeRange::new(-1, 0).unwrap());
    assert!(complex.differential(0).unwrap().source().ptr_eq(&simple));
    assert!(complex.verify());
}

#[test]
fn odd_shift_negates_differentials_and_moves_degrees() {
    let (_algebra, simple) = one_term();
    let differential = zero_differential(&simple);
    let complex = BoundedComplex::new(0, vec![simple.clone(), simple], vec![differential]).unwrap();
    let shifted = complex.shift(1).unwrap();
    assert_eq!(shifted.range(), DegreeRange::new(1, 2).unwrap());
    assert!(shifted.verify());
    assert!(shifted.differential(2).unwrap().is_zero());
}

#[test]
fn identity_and_zero_chain_maps_check_composition() {
    let (_algebra, simple) = one_term();
    let complex = BoundedComplex::new(
        0,
        vec![simple.clone(), simple.clone()],
        vec![zero_differential(&simple)],
    )
    .unwrap();
    let identity = ChainMap::identity(&complex);
    let zero = ChainMap::zero(&complex, &complex).unwrap();
    assert!(identity.then(&identity).unwrap().agrees_with(&identity));
    assert!(zero.then(&identity).unwrap().agrees_with(&zero));
    assert_eq!(
        ChainMap::new(&complex, &complex, vec![identity.components()[0].clone()]).unwrap_err(),
        ChainMapError::ComponentCount {
            expected: 2,
            got: 1
        }
    );
    assert!(identity.verify());
}

#[test]
fn composition_rejects_same_terms_with_different_differentials() {
    let (_algebra, simple) = one_term();
    let zero = BoundedComplex::new(
        0,
        vec![simple.clone(), simple.clone()],
        vec![zero_differential(&simple)],
    )
    .unwrap();
    let nonzero = BoundedComplex::new(
        0,
        vec![simple.clone(), simple.clone()],
        vec![identity(&simple)],
    )
    .unwrap();
    let left = ChainMap::identity(&nonzero);
    let right = ChainMap::identity(&zero);
    assert_eq!(
        left.then(&right).unwrap_err(),
        ChainMapError::CompositionMismatch
    );
}

#[test]
fn zero_homotopy_has_zero_boundary() {
    let (_algebra, simple) = one_term();
    let complex = BoundedComplex::new(
        0,
        vec![simple.clone(), simple.clone()],
        vec![zero_differential(&simple)],
    )
    .unwrap();
    let h = ChainHomotopy::new(
        &complex,
        &complex,
        vec![zero_differential(&complex.terms()[0])],
    )
    .unwrap();
    assert!(
        h.boundary()
            .unwrap()
            .components()
            .iter()
            .all(Morphism::is_zero)
    );
}

#[test]
fn cone_of_zero_map_has_signed_square_zero() {
    let (_algebra, simple) = one_term();
    let complex = BoundedComplex::new(
        0,
        vec![simple.clone(), simple.clone()],
        vec![zero_differential(&simple)],
    )
    .unwrap();
    let zero = ChainMap::zero(&complex, &complex).unwrap();
    let cone = zero.mapping_cone().unwrap();
    assert_eq!(cone.range(), DegreeRange::new(0, 2).unwrap());
    assert!(cone.verify());
}

#[test]
fn chain_hom_quotient_reduces_a_null_homotopic_map() {
    let (_algebra, simple) = one_term();
    let complex = BoundedComplex::new(
        0,
        vec![simple.clone(), simple.clone()],
        vec![zero_differential(&simple)],
    )
    .unwrap();
    let space = ChainHomSpace::new(&complex, &complex).unwrap();
    let quotient = space.quotient().unwrap();
    assert_eq!(quotient.dim(), space.dim());
    let map = space.basis_morphism(0);
    let (coordinates, remainder) = quotient.reduce(&map).unwrap();
    assert_eq!(coordinates.len(), quotient.dim());
    let rebuilt = quotient
        .representative(&coordinates)
        .add(&remainder)
        .unwrap();
    assert!(map.agrees_with(&rebuilt));
}

#[test]
fn identity_differential_complex_is_zero_in_the_homotopy_category() {
    let (_algebra, simple) = one_term();
    let identity = identity(&simple);
    let complex = BoundedComplex::new(0, vec![simple.clone(), simple], vec![identity]).unwrap();
    let space = ChainHomSpace::new(&complex, &complex).unwrap();
    let quotient = space.quotient().unwrap();
    assert_eq!(space.dim(), 1);
    assert_eq!(quotient.null_homotopic_basis().rows(), 1);
    assert_eq!(quotient.dim(), 0);
    for map in space.basis_iter() {
        assert!(map.is_null_homotopic().unwrap());
    }
}

#[test]
fn chain_maps_pad_different_supports_to_the_union() {
    let algebra = linear_an(1, f5());
    let simple = Module::simple(&algebra, 0);
    let zero = Module::zero(&algebra);
    let short = BoundedComplex::new(0, vec![simple.clone()], Vec::new()).unwrap();
    let target_differential = zero_between(&simple, &zero);
    let long =
        BoundedComplex::new(-1, vec![zero, simple.clone()], vec![target_differential]).unwrap();
    let source = short.padded_to(DegreeRange::new(-1, 0).unwrap()).unwrap();
    let components = vec![
        zero_between(&source.terms()[0], &long.terms()[0]),
        identity(&simple),
    ];
    let map = ChainMap::new(&short, &long, components).unwrap();
    assert_eq!(map.range(), DegreeRange::new(-1, 0).unwrap());
    assert!(map.source().verify());
    assert!(map.target().verify());
    assert!(map.verify());
}

#[test]
fn fresh_padding_rebases_hom_coordinates_and_reduction() {
    let algebra = linear_an(1, f5());
    let simple = Module::simple(&algebra, 0);
    let zero = Module::zero(&algebra);
    let short = BoundedComplex::new(0, vec![simple.clone()], Vec::new()).unwrap();
    let long = BoundedComplex::new(
        -1,
        vec![zero.clone(), simple.clone()],
        vec![zero_between(&simple, &zero)],
    )
    .unwrap();
    let fresh_zero = Module::zero(&algebra);
    let fresh_source = BoundedComplex::new(
        -1,
        vec![fresh_zero.clone(), simple.clone()],
        vec![zero_between(&simple, &fresh_zero)],
    )
    .unwrap();
    let fresh_map = ChainMap::new(
        &short,
        &long,
        vec![
            zero_between(&fresh_zero, &long.terms()[0]),
            identity(&simple),
        ],
    )
    .unwrap();
    assert!(fresh_source.agrees_with(&fresh_map.source().clone()));
    let space = ChainHomSpace::new(&short, &long).unwrap();
    assert!(space.coords(&fresh_map).is_ok());
    let quotient = space.quotient().unwrap();
    let (coordinates, remainder) = quotient.reduce(&fresh_map).unwrap();
    let rebuilt = quotient
        .representative(&coordinates)
        .add(&remainder)
        .unwrap();
    assert!(fresh_map.agrees_with(&rebuilt));
}

#[test]
fn nonzero_cones_and_shift_signs_hold_in_characteristics_two_and_five() {
    for modulus in [2, 5] {
        let field = PrimeField::new(modulus).unwrap();
        let algebra = linear_an(1, field);
        let simple = Module::simple(&algebra, 0);
        let complex = BoundedComplex::new(
            0,
            vec![simple.clone(), simple.clone()],
            vec![identity(&simple)],
        )
        .unwrap();
        let cone = ChainMap::identity(&complex).mapping_cone().unwrap();
        assert!(cone.verify());
        assert!(!cone.differential(1).unwrap().is_zero());
        let shifted = complex.shift(1).unwrap();
        assert_eq!(
            shifted.differential(2).unwrap().map_at(0).get(0, 0),
            field.neg(field.one())
        );
    }
}

#[test]
fn direct_sum_pads_support_and_rechecks_each_block() {
    let algebra = linear_an(1, f5());
    let simple = Module::simple(&algebra, 0);
    let zero = Module::zero(&algebra);
    let left = BoundedComplex::new(0, vec![simple.clone()], Vec::new()).unwrap();
    let right = BoundedComplex::new(
        -1,
        vec![zero.clone(), simple.clone()],
        vec![zero_between(&simple, &zero)],
    )
    .unwrap();
    let sum = BoundedComplex::direct_sum(&[&left, &right]).unwrap();
    assert_eq!(sum.range(), DegreeRange::new(-1, 0).unwrap());
    assert_eq!(sum.term(-1).unwrap().dim_at(0), 0);
    assert_eq!(sum.term(0).unwrap().dim_at(0), 2);
    assert!(sum.verify());
}