Struct AdemAlgebra 

pub struct AdemAlgebra {
    p: ValidPrime,
    generic: bool,
    unstable_enabled: bool,
    even_basis_table: OnceVec<Vec<AdemBasisElement>>,
    basis_table: OnceVec<Vec<AdemBasisElement>>,
    basis_element_to_index_map: OnceVec<FxHashMap<AdemBasisElement, usize>>,
    multiplication_table: OnceVec<Vec<Vec<FpVector>>>,
    excess_table: OnceVec<Vec<usize>>,
}

An Algebra implementing the Steenrod algebra, using the Adem basis.

Fields

p: ValidPrime

generic: bool

unstable_enabled: bool

even_basis_table: OnceVec<Vec<AdemBasisElement>>

basis_table: OnceVec<Vec<AdemBasisElement>>

degree -> index -> AdemBasisElement

basis_element_to_index_map: OnceVec<FxHashMap<AdemBasisElement, usize>>

degree -> AdemBasisElement -> index

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

degree -> first square -> admissible sequence idx -> result

excess_table: OnceVec<Vec<usize>>

Implementations

impl AdemAlgebra

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

Constructs a new AdemAlgebra.

pub fn generic(&self) -> bool

pub fn q(&self) -> i32

fn generate_basis_even(&self, max_degree: i32)

fn generate_basis2(&self, max_degree: i32)

fn generate_basis_generic(&self, max_degree: i32)

fn generate_basis_element_to_index_map(&self, max_degree: i32)

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

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

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

fn tail_of_basis_element_to_index( &self, elt: &mut AdemBasisElement, idx: u32, q: u32, ) -> usize

fn generate_multiplication_table_2(&self, max_degree: i32)

fn generate_multiplication_table_2_step( &self, table: &[Vec<FpVector>], n: i32, x: i32, idx: usize, ) -> FpVector

fn generate_multiplication_table_generic(&self, max_degree: i32)

fn generate_multiplication_table_generic_step( &self, table: &[Vec<FpVector>], n: i32, x: i32, idx: usize, ) -> FpVector

This function expresses $Sq^x$ (current) in terms of the admissible basis and returns the result as an FpVector, where (current) is the admissible monomial of degree $n - qx$ (so that $Sq^x)$ (current) has degree $n$) and index idx.

Here $Sq^x$ means $P^{x/2}$ if $x$ is even and $\beta P^{(x-1)/2}$ if $x$ is odd.

Note that x is always positive.

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

pub fn make_mono_admissible( &self, result: FpSliceMut<'_>, coeff: u32, monomial: &mut AdemBasisElement, excess: i32, )

fn make_mono_admissible_2( &self, result: FpSliceMut<'_>, monomial: &mut AdemBasisElement, idx: i32, leading_degree: i32, excess: i32, stop_early: bool, )

Reduce a Steenrod monomial at the prime 2.

Arguments:

• algebra - an Adem algebra. This would be a method of class AdemAlgebra.
• result - Where we put the result
• monomial - a not necessarily admissible Steenrod monomial which we will reduce. We destroy monomial->Ps.
• idx - the only index to check for inadmissibility in the input (we assume that we’ve gotten our input as a product of two admissible sequences.)
• leading_degree - the degree of the squares between 0 and idx (so of length idx + 1)

fn make_mono_admissible_generic( &self, result: FpSliceMut<'_>, coeff: u32, monomial: &mut AdemBasisElement, idx: i32, leading_degree: i32, excess: i32, stop_early: bool, )

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

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

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

impl AdemAlgebra

fn generate_excess_table(&self, max_degree: i32)

Trait Implementations

impl Algebra for AdemAlgebra

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<'_>, coeff: u32, r_degree: i32, r_index: usize, s_degree: i32, s_index: usize, )

Computes the product r * s of two basis 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_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_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 multiply_element_by_element( &self, result: FpSliceMut<'_>, coeff: u32, r_degree: i32, r: FpSlice<'_>, s_degree: i32, s: FpSlice<'_>, )

Computes the product r * s of two general elements, 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 AdemAlgebra

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.

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

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

impl Display for AdemAlgebra

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

Formats the value using the given formatter.

impl From<AdemAlgebra> for SteenrodAlgebra

fn from(v: AdemAlgebra) -> SteenrodAlgebra

Converts to this type from the input type.

impl GeneratedAlgebra for AdemAlgebra

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

We return Adem relations $b^2 = 0$, $P^i P^j = \cdots$ for $i < pj$, and $P^i b P^j = \cdots$ for $i < pj + 1$. It suffices to check these because they generate all relations.

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.

impl PairAlgebra for AdemAlgebra

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 element_is_zero(_elt: &Self::Element) -> bool

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.

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 new_pair_element(&self, _degree: i32) -> Self::Element

Create a new zero element in the given degree.

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 AdemAlgebra> for &'a SteenrodAlgebra

type Error = Error

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryInto<AdemAlgebra> for SteenrodAlgebra

type Error = &'static str

The type returned in the event of a conversion error.

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

Performs the conversion.

impl UnstableAlgebra for AdemAlgebra

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.