auslander 0.8.0

Computational representation theory of finite-dimensional bound quiver algebras
Documentation
use super::*;
use crate::algebra::{dual_numbers, linear_an};
use crate::ext::ExtClass;
use crate::field::PrimeField;
use crate::module::Module;
use crate::resolution::ResolutionEnd;

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

fn dual_number_simple() -> Module {
    let algebra = dual_numbers(f5());
    Module::simple(&algebra, 0)
}

#[test]
fn a_finite_resolution_gives_a_complete_algebra_through_the_requested_bound() {
    let algebra = linear_an(3, f5());
    let source = Module::simple(&algebra, 0);
    let ExtAlgebraOutcome::Complete(ext) = ExtAlgebraOutcome::compute(&source, 3).unwrap() else {
        panic!("S_0 over linear A_3 has finite projective dimension");
    };
    assert_eq!(ext.bound(), 3);
    assert_eq!(ext.spaces().len(), 4);
    assert!(matches!(ext.resolution_end(), ResolutionEnd::Finite));
    assert!(ext.verify());
}

#[test]
fn a_cut_keeps_all_requested_exact_degrees_and_names_the_first_omitted_degree() {
    let source = dual_number_simple();
    let ExtAlgebraOutcome::Cut(cut) = ExtAlgebraOutcome::compute(&source, 3).unwrap() else {
        panic!("the dual-number simple has an unbounded minimal resolution");
    };
    assert_eq!(cut.algebra().spaces().len(), 4);
    assert_eq!(cut.first_omitted_degree(), 4);
    assert!(matches!(
        cut.algebra().resolution_end(),
        ResolutionEnd::Cut { at: 3 }
    ));
    assert!(cut.verify());
}

#[test]
fn tensors_use_the_same_order_as_then_with_witness() {
    let source = dual_number_simple();
    let ExtAlgebraOutcome::Cut(ext) = ExtAlgebraOutcome::compute(&source, 3).unwrap() else {
        panic!("the dual-number simple has an unbounded minimal resolution");
    };
    let ext = ext.algebra();
    let alpha = &ext.basis(1).unwrap()[0];
    let beta = &ext.basis(2).unwrap()[0];
    let (direct, witness) = alpha.then_with_witness(beta).unwrap();
    let tensor = ext.multiplication(1, 2).unwrap();
    let stored = ext.multiply(alpha, beta).unwrap();
    assert!(direct.equals(&stored).unwrap());
    assert!(witness.verify(alpha, beta, &direct));
    assert_eq!(
        tensor.basis_product(0, 0),
        Some(stored.coordinates()),
        "the degree (1, 2) tensor uses alpha.then(beta)"
    );
    assert!(ext.verify());
}

#[test]
fn repeated_builds_keep_bases_and_tensors_in_the_same_order() {
    let source = dual_number_simple();
    let ExtAlgebraOutcome::Cut(left) = ExtAlgebraOutcome::compute(&source, 3).unwrap() else {
        panic!("the dual-number simple has an unbounded minimal resolution");
    };
    let ExtAlgebraOutcome::Cut(right) = ExtAlgebraOutcome::compute(&source, 3).unwrap() else {
        panic!("the dual-number simple has an unbounded minimal resolution");
    };
    let (left, right) = (left.algebra(), right.algebra());
    for degree in 0..=left.bound() {
        assert!(
            left.space(degree)
                .unwrap()
                .matches(right.space(degree).unwrap())
        );
        assert_eq!(
            left.basis(degree)
                .unwrap()
                .iter()
                .map(ExtClass::coordinates)
                .collect::<Vec<_>>(),
            right
                .basis(degree)
                .unwrap()
                .iter()
                .map(ExtClass::coordinates)
                .collect::<Vec<_>>(),
            "basis degree {degree}"
        );
    }
    for left_degree in 0..=left.bound() {
        for right_degree in 0..=left.bound() - left_degree {
            assert_eq!(
                left.multiplication(left_degree, right_degree)
                    .unwrap()
                    .coefficients(),
                right
                    .multiplication(left_degree, right_degree)
                    .unwrap()
                    .coefficients(),
                "tensor degree ({left_degree}, {right_degree})"
            );
        }
    }
    let order: Vec<(usize, usize, usize, usize)> = left
        .product_records()
        .map(|record| {
            (
                record.left_degree(),
                record.left_basis(),
                record.right_degree(),
                record.right_basis(),
            )
        })
        .collect();
    assert!(order.windows(2).all(|pair| pair[0] <= pair[1]));
    let expected_records: usize = (0..=left.bound())
        .flat_map(|left_degree| {
            (0..=left.bound() - left_degree).map(move |right_degree| {
                left.basis(left_degree).unwrap().len() * left.basis(right_degree).unwrap().len()
            })
        })
        .sum();
    assert_eq!(order.len(), expected_records);
}

#[test]
fn verifier_rejects_a_changed_tensor_coefficient_and_a_changed_unit() {
    let source = dual_number_simple();
    let ExtAlgebraOutcome::Cut(cut) = ExtAlgebraOutcome::compute(&source, 3).unwrap() else {
        panic!("the dual-number simple has an unbounded minimal resolution");
    };
    let ext = cut.algebra();
    let field = ext.module().field();
    let mut wrong_tensor = ext.clone();
    let coefficient = wrong_tensor.products[1][1]
        .coefficients
        .first_mut()
        .expect("the degree (1, 1) tensor has one coefficient");
    *coefficient = field.add(*coefficient, field.one());
    assert!(!wrong_tensor.verify());

    let mut wrong_unit = ext.clone();
    wrong_unit.unit = wrong_unit.spaces[0].zero_class();
    assert!(!wrong_unit.verify());
}