Struct MilnorAlgebra 

pub struct MilnorAlgebra {
    profile: MilnorProfile,
    p: ValidPrime,
    generic: bool,
    unstable_enabled: bool,
    ppart_table: OnceVec<Vec<PPart>>,
    basis_table: OnceVec<Vec<MilnorBasisElement>>,
    excess_table: OnceVec<Vec<usize>>,
    basis_element_to_index_map: OnceVec<FxHashMap<MilnorBasisElement, usize>>,
    multiplication_table: OnceVec<OnceVec<Vec<Vec<FpVector>>>>,
}

Fields

profile: MilnorProfile

p: ValidPrime

generic: bool

unstable_enabled: bool

ppart_table: OnceVec<Vec<PPart>>

This is a list of possible P(R) of each degree, where ppart_table[i] contains elements of degree q * i.

basis_table: OnceVec<Vec<MilnorBasisElement>>

A list of all basis elements of each degree, constructed from Self::ppart_table

excess_table: OnceVec<Vec<usize>>

basis_element_to_index_map: OnceVec<FxHashMap<MilnorBasisElement, usize>>

degree -> MilnorBasisElement -> index

multiplication_table: OnceVec<OnceVec<Vec<Vec<FpVector>>>>

source_deg -> target_deg -> source_op -> target_op

Implementations

impl MilnorAlgebra

pub fn new(p: ValidPrime, unstable_enabled: bool) -> Self

pub fn new_with_profile( p: ValidPrime, profile: MilnorProfile, unstable_enabled: bool, ) -> Self

pub fn generic(&self) -> bool

pub fn q(&self) -> i32

pub fn profile(&self) -> &MilnorProfile

pub fn basis_element_from_index( &self, degree: i32, idx: usize, ) -> &MilnorBasisElement

pub fn try_basis_element_to_index( &self, elt: &MilnorBasisElement, ) -> Option<usize>

pub fn basis_element_to_index(&self, elt: &MilnorBasisElement) -> usize

pub fn ppart_table(&self, t: i32) -> &[PPart]

Gives a list of PPart’s in degree t.

impl MilnorAlgebra

fn compute_ppart(&self, max_degree: i32)

fn generate_basis_generic(&self, max_degree: i32)

fn generate_basis_2(&self, max_degree: i32)

fn generate_excess_table(&self, max_degree: i32)

impl MilnorAlgebra

fn try_beps_pn(&self, e: u32, x: PPartEntry) -> Option<(i32, usize)>

pub fn beps_pn(&self, e: u32, x: PPartEntry) -> (i32, usize)

Return the degree and index of $Q_1^e P(x)$.

fn multiply_qpart( &self, m1: &MilnorBasisElement, f: u32, ) -> Vec<(u32, MilnorBasisElement)>

pub fn multiply( &self, res: FpSliceMut<'_>, coef: u32, m1: &MilnorBasisElement, m2: &MilnorBasisElement, )

pub fn multiply_with_allocation( &self, res: FpSliceMut<'_>, coef: u32, m1: &MilnorBasisElement, m2: &MilnorBasisElement, excess: i32, allocation: PPartAllocation, ) -> PPartAllocation

pub fn multiply_basis_by_element( &self, res: FpSliceMut<'_>, coef: u32, m1: &MilnorBasisElement, s_deg: i32, s: FpSlice<'_>, )

fn multiply_basis_by_element_with_allocation( &self, res: FpSliceMut<'_>, coef: u32, m1: &MilnorBasisElement, s_deg: i32, s: FpSlice<'_>, allocation: PPartAllocation, ) -> PPartAllocation

impl MilnorAlgebra

fn decompose_basis_element_qpart( &self, degree: i32, idx: usize, ) -> Vec<(u32, (i32, usize), (i32, usize))>

fn decompose_basis_element_ppart( &self, degree: i32, idx: usize, ) -> Vec<(u32, (i32, usize), (i32, usize))>

impl MilnorAlgebra

fn increment_p_part(element: &mut PPart, max: &[PPartEntry]) -> bool

Returns true if the new element is not within the bounds

Trait Implementations

impl Algebra for MilnorAlgebra

fn prefix(&self) -> &str

A name for the algebra to use in serialization operations. This defaults to “” for algebras that don’t care about this problem.

fn magic(&self) -> u32

A magic constant used to identify the algebra in save files. When working with the Milnor algebra, it is easy to forget to specify the algebra and load Milnor save files with the Adem basis. If we somehow manage to resume computation, this can have disasterous consequences. So we store the magic in the save files.

fn prime(&self) -> ValidPrime

Returns the prime the algebra is over.

fn default_filtration_one_products(&self) -> Vec<(String, i32, usize)>

Returns a list of filtration-one elements in $Ext(k, k)$.

fn compute_basis(&self, max_degree: i32)

Computes basis elements up to and including degree.

fn dimension(&self, degree: i32) -> usize

Returns the dimension of the algebra in degree degree.

fn multiply_basis_elements( &self, result: FpSliceMut<'_>, coef: u32, r_degree: i32, r_idx: usize, s_degree: i32, s_idx: usize, )

Computes the product r * s of two basis elements, and adds the result to result.

fn multiply_basis_element_by_element( &self, result: FpSliceMut<'_>, coeff: u32, r_degree: i32, r_idx: usize, s_degree: i32, s: FpSlice<'_>, )

Computes the product r * s of a basis element r and a general element s, and adds the result to result.

fn multiply_element_by_element( &self, res: FpSliceMut<'_>, coef: u32, r_deg: i32, r: FpSlice<'_>, s_deg: i32, s: FpSlice<'_>, )

Computes the product r * s of two general elements, and adds the result to result.

fn basis_element_to_string(&self, degree: i32, idx: usize) -> String

Converts a basis element into a string for display.

fn basis_element_from_string(&self, elt: &str) -> Option<(i32, usize)>

Converts a string to a basis element. This must be a one-sided inverse inverse to both basis_element_to_string and generator_to_string (if GeneratedAlgebra is implemented).

fn multiply_element_by_basis_element( &self, result: FpSliceMut<'_>, coeff: u32, r_degree: i32, r: FpSlice<'_>, s_degree: i32, s_idx: usize, )

Computes the product r * s of a general element r and a basis element s, and adds the result to result.

fn element_to_string(&self, degree: i32, element: FpSlice<'_>) -> String

Converts a general element into a string for display.

impl Bialgebra for MilnorAlgebra

fn coproduct(&self, op_deg: i32, op_idx: usize) -> Vec<(i32, usize, i32, usize)>

Computes a coproduct $\Delta(x)$, expressed as

fn decompose(&self, op_deg: i32, op_idx: usize) -> Vec<(i32, usize)>

Decomposes an element of the algebra into a product of elements, each of which we can compute a coproduct on efficiently.

impl Display for MilnorAlgebra

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<MilnorAlgebra> for SteenrodAlgebra

fn from(v: MilnorAlgebra) -> SteenrodAlgebra

Converts to this type from the input type.

impl GeneratedAlgebra for MilnorAlgebra

fn generator_to_string(&self, degree: i32, idx: usize) -> String

Returns the name of a generator.

fn generators(&self, degree: i32) -> Vec<usize>

Return generators in degree.

fn decompose_basis_element( &self, degree: i32, idx: usize, ) -> Vec<(u32, (i32, usize), (i32, usize))>

Decomposes an element into generators.

fn generating_relations( &self, degree: i32, ) -> Vec<Vec<(u32, (i32, usize), (i32, usize))>>

Returns relations that the algebra wants checked to ensure the consistency of module.

impl PairAlgebra for MilnorAlgebra

fn finalize_element(elt: &mut Self::Element)

Assert that elt is in the image of the differential. Drop the data recording the complement of the image of the differential.

type Element = MilnorPairElement

An element in the cohomological degree zero part of the pair algebra. This tends to not be a ring over Fp, so we let the algebra specify how it wants to represent the elements.

fn new_pair_element(&self, degree: i32) -> Self::Element

Create a new zero element in the given degree.

fn element_is_zero(elt: &Self::Element) -> bool

fn p_tilde(&self) -> usize

The element p is classified by a filtration on element in Ext of the underlying algebra, which is represented by an indecomposable in degree 1. This returns the index of said indecomposable.

fn sigma_multiply_basis( &self, result: &mut Self::Element, coeff: u32, r_degree: i32, r_idx: usize, s_degree: i32, s_idx: usize, )

Given $r, s \in \pi_0(A)$, compute $\sigma(r) \sigma(s)$ and add the result to result.

fn a_multiply( &self, result: FpSliceMut<'_>, coeff: u32, r_degree: i32, r: FpSlice<'_>, s_degree: i32, s: &Self::Element, )

Compute $A(r, s)$ and write the result to result.

fn element_to_bytes( &self, elt: &Self::Element, buffer: &mut impl Write, ) -> Result<()>

fn element_from_bytes( &self, degree: i32, buffer: &mut impl Read, ) -> Result<Self::Element>

fn sigma_multiply( &self, result: &mut Self::Element, coeff: u32, r_degree: i32, r: FpSlice<'_>, s_degree: i32, s: FpSlice<'_>, )

Same as PairAlgebra::sigma_multiply_basis but with non-basis elements.

impl<'a> TryInto<&'a MilnorAlgebra> for &'a SteenrodAlgebra

type Error = Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<&'a MilnorAlgebra, Self::Error>

Performs the conversion.

impl TryInto<MilnorAlgebra> for SteenrodAlgebra

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into( self, ) -> Result<MilnorAlgebra, <Self as TryInto<MilnorAlgebra>>::Error>

Performs the conversion.

impl UnstableAlgebra for MilnorAlgebra

fn dimension_unstable(&self, degree: i32, excess: i32) -> usize

fn multiply_basis_elements_unstable( &self, result: FpSliceMut<'_>, coeff: u32, r_degree: i32, r_index: usize, s_degree: i32, s_index: usize, excess: i32, )

fn multiply_basis_element_by_element_unstable( &self, result: FpSliceMut<'_>, coeff: u32, r_degree: i32, r_idx: usize, s_degree: i32, s: FpSlice<'_>, excess: i32, )

Computes the product r * s of a basis element r and a general element s, and adds the result to result.

fn multiply_element_by_basis_element_unstable( &self, result: FpSliceMut<'_>, coeff: u32, r_degree: i32, r: FpSlice<'_>, s_degree: i32, s_idx: usize, excess: i32, )

Computes the product r * s of a general element r and a basis element s, and adds the result to result.

fn multiply_element_by_element_unstable( &self, result: FpSliceMut<'_>, coeff: u32, r_degree: i32, r: FpSlice<'_>, s_degree: i32, s: FpSlice<'_>, excess: i32, )

Computes the product r * s of two general elements, and adds the result to result.