Enum SteenrodAlgebra 

pub enum SteenrodAlgebra {
    AdemAlgebra(AdemAlgebra),
    MilnorAlgebra(MilnorAlgebra),
}

Variants

AdemAlgebra(AdemAlgebra)

MilnorAlgebra(MilnorAlgebra)

Implementations

impl SteenrodAlgebra

pub fn from_json( json: &Value, algebra_type: AlgebraType, unstable: bool, ) -> Result<Self>

Trait Implementations

impl Algebra for SteenrodAlgebra

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.

This defaults to 0 for other kinds of algebra that don’t care about this problem.

fn prime(&self) -> ValidPrime

Returns the prime the algebra is over.

fn compute_basis(&self, __enum_dispatch_arg_0: i32)

Computes basis elements up to and including degree.

This function must be called by users before other functions that will involve operations at degree, so it should be used to update internal data structure in perparation for such operations.

This function must be idempotent and cheap to call again with the same argument.

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

Returns the dimension of the algebra in degree degree.

fn multiply_basis_elements( &self, __enum_dispatch_arg_0: FpSliceMut<'_>, __enum_dispatch_arg_1: u32, __enum_dispatch_arg_2: i32, __enum_dispatch_arg_3: usize, __enum_dispatch_arg_4: i32, __enum_dispatch_arg_5: usize, )

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

result is not required to be aligned.

fn multiply_basis_element_by_element( &self, __enum_dispatch_arg_0: FpSliceMut<'_>, __enum_dispatch_arg_1: u32, __enum_dispatch_arg_2: i32, __enum_dispatch_arg_3: usize, __enum_dispatch_arg_4: i32, __enum_dispatch_arg_5: FpSlice<'_>, )

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

Neither result nor s must be aligned.

fn multiply_element_by_basis_element( &self, __enum_dispatch_arg_0: FpSliceMut<'_>, __enum_dispatch_arg_1: u32, __enum_dispatch_arg_2: i32, __enum_dispatch_arg_3: FpSlice<'_>, __enum_dispatch_arg_4: i32, __enum_dispatch_arg_5: usize, )

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

Neither result nor r must be aligned.

fn multiply_element_by_element( &self, __enum_dispatch_arg_0: FpSliceMut<'_>, __enum_dispatch_arg_1: u32, __enum_dispatch_arg_2: i32, __enum_dispatch_arg_3: FpSlice<'_>, __enum_dispatch_arg_4: i32, __enum_dispatch_arg_5: FpSlice<'_>, )

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

Neither result, s, nor r must be aligned.

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

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

These are the same as indecomposable elements of the algebra.

This function returns a default list of such elements in the format (name, degree, index) for which we want to compute products with in the resolutions.

fn basis_element_to_string( &self, __enum_dispatch_arg_0: i32, __enum_dispatch_arg_1: usize, ) -> String

Converts a basis element into a string for display.

fn basis_element_from_string( &self, __enum_dispatch_arg_0: &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).

If the input is invalid, the function is allowed to return None or nonsense (since it is only required to be a one-sided inverse).

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

Converts a general element into a string for display.

impl Bialgebra for SteenrodAlgebra

fn coproduct( &self, __enum_dispatch_arg_0: i32, __enum_dispatch_arg_1: usize, ) -> Vec<(i32, usize, i32, usize)>

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

$$ Delta(x)i = \sum_j A{ij} \otimes B_{ij}. $$

The return value is a list of these pairs of basis elements.

x must have been returned by Bialgebra::decompose().

fn decompose( &self, __enum_dispatch_arg_0: i32, __enum_dispatch_arg_1: 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.

The product is laid out such that the first element of the vector is applied to a module element first when acting on it.

This function is to be used with Bialgebra::coproduct().

This API is motivated by the fact that, in the admissible basis for the Adem algebra, an element naturally decomposes into a product of Steenrod squares, each of which has an easy coproduct formula.

impl Display for SteenrodAlgebra

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 From<MilnorAlgebra> for SteenrodAlgebra

fn from(v: MilnorAlgebra) -> SteenrodAlgebra

Converts to this type from the input type.

impl GeneratedAlgebra for SteenrodAlgebra

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

Return generators in degree.

Generators are specified as basis element indices in that degree. The order of the list is not important.

This method need not be fast, because they will only be performed when constructing the module, and will often only involve low dimensional elements.

fn generator_to_string( &self, __enum_dispatch_arg_0: i32, __enum_dispatch_arg_1: usize, ) -> String

Returns the name of a generator.

Note: idx is the index within degree’s basis, not the list returned by GeneratedAlgebra::generators().

By default, this function will forward to Algebra::basis_element_to_string(), but may be overridden if more concise names are available.

fn decompose_basis_element( &self, __enum_dispatch_arg_0: i32, __enum_dispatch_arg_1: usize, ) -> Vec<(u32, (i32, usize), (i32, usize))>

Decomposes an element into generators.

Given a basis element $A$, this function returns a list of triples $(c_i, A_i, B_i)$, such that

$$ A = \sum_i c_i A_i B_i,$$

where either ($A_i$ and $B_i$ are basis elements of strictly smaller degree than $A$), or (one of them is a generator and the other is the identity).

Combined with actions for generators, this allows us to recursively compute the action of an element on a module.

This method need not be fast, because they will only be performed when constructing the module, and will often only involve low dimensional elements.

It is invalid to supply an element that is a generator.

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

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

Relations are encoded as general multi-degree elements which are killed in the quotient: $$ \sum_i c_i \alpha_i \beta_i = 0. $$ where $c_i$ are coefficients and $\alpha_i$ and $\beta_i$ are basis elements of arbitrary degree.

impl PairAlgebra for SteenrodAlgebra

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 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 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.

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 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.

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<'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<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 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 SteenrodAlgebra

fn multiply_basis_element_by_element_unstable( &self, __enum_dispatch_arg_0: FpSliceMut<'_>, __enum_dispatch_arg_1: u32, __enum_dispatch_arg_2: i32, __enum_dispatch_arg_3: usize, __enum_dispatch_arg_4: i32, __enum_dispatch_arg_5: FpSlice<'_>, __enum_dispatch_arg_6: i32, )

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

Neither result nor s must be aligned.

fn multiply_element_by_basis_element_unstable( &self, __enum_dispatch_arg_0: FpSliceMut<'_>, __enum_dispatch_arg_1: u32, __enum_dispatch_arg_2: i32, __enum_dispatch_arg_3: FpSlice<'_>, __enum_dispatch_arg_4: i32, __enum_dispatch_arg_5: usize, __enum_dispatch_arg_6: i32, )

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

Neither result nor r must be aligned.

fn multiply_element_by_element_unstable( &self, __enum_dispatch_arg_0: FpSliceMut<'_>, __enum_dispatch_arg_1: u32, __enum_dispatch_arg_2: i32, __enum_dispatch_arg_3: FpSlice<'_>, __enum_dispatch_arg_4: i32, __enum_dispatch_arg_5: FpSlice<'_>, __enum_dispatch_arg_6: i32, )

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

Neither result, s, nor r must be aligned.

fn dimension_unstable( &self, __enum_dispatch_arg_0: i32, __enum_dispatch_arg_1: i32, ) -> usize

fn multiply_basis_elements_unstable( &self, __enum_dispatch_arg_0: FpSliceMut<'_>, __enum_dispatch_arg_1: u32, __enum_dispatch_arg_2: i32, __enum_dispatch_arg_3: usize, __enum_dispatch_arg_4: i32, __enum_dispatch_arg_5: usize, __enum_dispatch_arg_6: i32, )