use std::sync::Arc;
use crate::completion::CompletionLimits;
use crate::field::PrimeField;
use crate::monomial::{
MonomialIdeal, an_with_relations_ideal, cyclic_nakayama_ideal, kronecker_ideal,
linear_an_ideal, linear_nakayama_ideal, radical_square_zero_cycle_ideal, truncated_poly_ideal,
};
use crate::quiver::{ArrowId, Quiver};
use crate::relation::{Presentation, Relation};
use super::types::{Algebra, AlgebraBuildError};
pub fn monomial_presentation(ideal: &MonomialIdeal, field: PrimeField) -> Presentation {
let quiver = ideal.quiver().clone();
let relations = ideal
.forbidden()
.iter()
.map(|word| {
Relation::new(&quiver, field, vec![(field.one(), word.clone())])
.expect("a forbidden word is a path of length >= 2")
})
.collect();
Presentation::new(quiver, field, relations).expect("the relations were built over this quiver")
}
pub fn monomial_limits(ideal: &MonomialIdeal) -> CompletionLimits {
let defaults = CompletionLimits::default();
let words = ideal.forbidden().len() as u64;
let longest = ideal.forbidden().iter().map(Vec::len).max().unwrap_or(0) as u64;
CompletionLimits {
max_basis: defaults.max_basis.max(words),
max_word_len: defaults
.max_word_len
.max(longest.saturating_mul(2).saturating_sub(1)),
max_steps: defaults.max_steps,
max_origin_terms: defaults.max_origin_terms,
max_ambiguities: defaults.max_ambiguities.max(
words
.saturating_mul(words)
.saturating_mul(longest.saturating_mul(2)),
),
}
}
pub fn monomial_algebra(
ideal: &MonomialIdeal,
field: PrimeField,
) -> Result<Arc<Algebra>, AlgebraBuildError> {
Algebra::new(monomial_presentation(ideal, field), &monomial_limits(ideal))
}
pub fn path_algebra(quiver: Quiver, field: PrimeField) -> Result<Arc<Algebra>, AlgebraBuildError> {
let presentation =
Presentation::new(quiver, field, Vec::new()).expect("there is no relation to reject");
Algebra::new(presentation, &CompletionLimits::default())
}
pub fn linear_an(n: usize, field: PrimeField) -> Arc<Algebra> {
monomial_algebra(&linear_an_ideal(n), field)
.expect("the zero ideal over an acyclic quiver completes")
}
pub fn kronecker(m: usize, field: PrimeField) -> Arc<Algebra> {
monomial_algebra(&kronecker_ideal(m), field)
.expect("the zero ideal over an acyclic quiver completes")
}
pub fn dual_numbers(field: PrimeField) -> Arc<Algebra> {
truncated_poly(2, field).expect("x² is an admissible relation")
}
pub fn truncated_poly(n: usize, field: PrimeField) -> Result<Arc<Algebra>, AlgebraBuildError> {
let ideal = truncated_poly_ideal(n).map_err(AlgebraBuildError::Monomial)?;
monomial_algebra(&ideal, field)
}
pub fn linear_nakayama(
kupisch: &[usize],
field: PrimeField,
) -> Result<Arc<Algebra>, AlgebraBuildError> {
let ideal = linear_nakayama_ideal(kupisch).map_err(AlgebraBuildError::Monomial)?;
monomial_algebra(&ideal, field)
}
pub fn cyclic_nakayama(
kupisch: &[usize],
field: PrimeField,
) -> Result<Arc<Algebra>, AlgebraBuildError> {
let ideal = cyclic_nakayama_ideal(kupisch).map_err(AlgebraBuildError::Monomial)?;
monomial_algebra(&ideal, field)
}
pub fn radical_square_zero_cycle(n: usize, field: PrimeField) -> Arc<Algebra> {
monomial_algebra(&radical_square_zero_cycle_ideal(n), field)
.expect("rad² = 0 leaves only vertices and arrows")
}
pub fn an_with_relations(
n: usize,
zero_paths: &[(usize, usize)],
field: PrimeField,
) -> Result<Arc<Algebra>, AlgebraBuildError> {
let ideal = an_with_relations_ideal(n, zero_paths).map_err(AlgebraBuildError::Monomial)?;
monomial_algebra(&ideal, field)
}
pub fn commutative_square(field: PrimeField) -> Arc<Algebra> {
let quiver = Quiver::new(4, &[(0, 1), (1, 3), (0, 2), (2, 3)]).expect("endpoints in range");
let relation = Relation::new(
&quiver,
field,
vec![
(field.one(), vec![ArrowId(0), ArrowId(1)]),
(field.elem(-1), vec![ArrowId(2), ArrowId(3)]),
],
)
.expect("ab - cd is a valid uniform relation");
let presentation = Presentation::new(quiver, field, vec![relation])
.expect("the relation was built over this quiver and field");
Algebra::new(presentation, &CompletionLimits::default())
.expect("the commutative square is finite dimensional")
}