Struct MuFreeModule 

pub struct MuFreeModule<const U: bool, A: MuAlgebra<U>> {
    algebra: Arc<A>,
    name: String,
    min_degree: i32,
    gen_names: OnceBiVec<Vec<String>>,
    gen_deg_idx_to_internal_idx: OnceBiVec<usize>,
    num_gens: OnceBiVec<usize>,
    basis_element_to_opgen: OnceBiVec<OnceVec<OperationGeneratorPair>>,
    generator_to_index: OnceBiVec<OnceVec<usize>>,
}

A free module.

A free module is uniquely determined by its list of generators. The generators are listed in increasing degrees, and the index in this list is the internal index.

Fields

algebra: Arc<A>

name: String

min_degree: i32

gen_names: OnceBiVec<Vec<String>>

gen_deg_idx_to_internal_idx: OnceBiVec<usize>

degree -> internal index of first generator in degree

num_gens: OnceBiVec<usize>

basis_element_to_opgen: OnceBiVec<OnceVec<OperationGeneratorPair>>

generator_to_index: OnceBiVec<OnceVec<usize>>

degree -> internal_gen_idx -> the offset of the generator in degree

Implementations

impl<const U: bool, A: MuAlgebra<U>> MuFreeModule<U, A>

pub fn new(algebra: Arc<A>, name: String, min_degree: i32) -> Self

impl<const U: bool, A: MuAlgebra<U>> MuFreeModule<U, A>

pub fn gen_names(&self) -> &OnceBiVec<Vec<String>>

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

pub fn add_generators( &self, degree: i32, num_gens: usize, names: Option<Vec<String>>, )

pub fn internal_generator_offset( &self, degree: i32, internal_gen_idx: usize, ) -> usize

Given a generator (gen_deg, gen_idx), find the first index in degree degree with elements from the generator.

pub fn iter_gens(&self, degree: i32) -> impl Iterator<Item = (i32, usize)> + '_

Iterate the degrees and indices of each generator up to degree degree.

pub fn iter_gen_offsets<const N: usize>( &self, degree: [i32; N], ) -> impl Iterator<Item = GeneratorData<N>> + '_

Iterate the degrees and offsets of each generator up to degree degree.

pub fn generator_offset( &self, degree: i32, gen_deg: i32, gen_idx: usize, ) -> usize

Given a generator (gen_deg, gen_idx), find the first index in degree degree with elements from the generator.

pub fn operation_generator_to_index( &self, op_deg: i32, op_idx: usize, gen_deg: i32, gen_idx: usize, ) -> usize

pub fn index_to_op_gen( &self, degree: i32, index: usize, ) -> &OperationGeneratorPair

pub fn extend_by_zero(&self, degree: i32)

pub fn slice_vector<'a>( &self, degree: i32, gen_degree: i32, gen_index: usize, v: FpSlice<'a>, ) -> FpSlice<'a>

Given a vector that represents an element in degree degree, slice it to the part that represents the terms that correspond to the specified generator.

pub fn iter_slices<'a>( &'a self, degree: i32, slice: FpSlice<'a>, ) -> impl Iterator<Item = (i32, usize, i32, FpSlice<'a>)> + 'a

Given an element in a degree, iterate through the slices corresponding to each generator. Each item of the iterator is (gen_degree, gen_index, op_degree, slice). This skips slices that are zero length.

Trait Implementations

impl<const U: bool, A: MuAlgebra<U>> Display for MuFreeModule<U, A>

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

Formats the value using the given formatter.

impl<const U: bool, A: MuAlgebra<U>> Module for MuFreeModule<U, A>

type Algebra = A

fn algebra(&self) -> Arc<A>

The algebra the module is over.

fn min_degree(&self) -> i32

The minimum degree of the module, which is required to be bounded below

fn max_computed_degree(&self) -> i32

The maximum t for which the module is fully defined at t. See Module documentation for more details.

fn max_generator_degree(&self) -> Option<i32>

Maximum degree of a generator under the Steenrod action. Every element in higher degree must be obtainable from applying a Steenrod action to a lower degree element.

fn compute_basis(&self, max_degree: i32)

Compute internal data of the module so that we can query information up to degree degree. This should be run by the user whenever they want to query such information.

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

The dimension of a module at the given degree

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

The name of a basis element. This is useful for debugging and printing results.

fn act_on_basis( &self, result: FpSliceMut<'_>, coeff: u32, op_degree: i32, op_index: usize, mod_degree: i32, mod_index: usize, )

fn act( &self, result: FpSliceMut<'_>, coeff: u32, op_degree: i32, op_index: usize, input_degree: i32, input: FpSlice<'_>, )

The length of input need not be equal to the dimension of the module in said degree. Missing entries are interpreted to be 0, while extra entries must be zero.

fn is_unit(&self) -> bool

Whether this is the unit module.

fn prime(&self) -> ValidPrime

The prime the module is over, which should be equal to the prime of the algebra.

fn max_degree(&self) -> Option<i32>

max_degree is the a degree such that if t > max_degree, then self.dimension(t) = 0.

fn total_dimension(&self) -> usize

fn act_by_element( &self, result: FpSliceMut<'_>, coeff: u32, op_degree: i32, op: FpSlice<'_>, input_degree: i32, input: FpSlice<'_>, )

fn act_by_element_on_basis( &self, result: FpSliceMut<'_>, coeff: u32, op_degree: i32, op: FpSlice<'_>, input_degree: i32, input_index: usize, )

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

Gives the name of an element. The default implementation is derived from Module::basis_element_to_string in the obvious way.

impl<const U: bool, M: Module> ZeroHomomorphism<MuFreeModule<U, <M as Module>::Algebra>, M> for MuFreeModuleHomomorphism<U, M>

where M::Algebra: MuAlgebra<U>,

fn zero_homomorphism( source: Arc<MuFreeModule<U, M::Algebra>>, target: Arc<M>, degree_shift: i32, ) -> Self

impl<const U: bool, A: MuAlgebra<U>> ZeroModule for MuFreeModule<U, A>

fn zero_module(algebra: Arc<A>, min_degree: i32) -> Self