Struct QuotientModule 

pub struct QuotientModule<M: Module> {
    pub module: Arc<M>,
    pub subspaces: BiVec<Subspace>,
    pub basis_list: BiVec<Vec<usize>>,
    pub truncation: i32,
}

A quotient of a module truncated below a fix degree.

Fields

module: Arc<M>

The underlying module

subspaces: BiVec<Subspace>

The subspaces that we quotient out by

basis_list: BiVec<Vec<usize>>

For each degree d, basis_list[d] is a list of basis elements of self.module that generates the quotient.

truncation: i32

Everything above this degree is quotiented out.

Implementations

impl<M: Module> QuotientModule<M>

pub fn new(module: Arc<M>, truncation: i32) -> Self

pub fn quotient(&mut self, degree: i32, element: FpSlice<'_>)

pub fn quotient_basis_elements( &mut self, degree: i32, elements: impl Iterator<Item = usize>, )

pub fn quotient_vectors( &mut self, degree: i32, vecs: impl for<'a> FnMut(FpSliceMut<'a>) -> Option<()>, )

Arguments

• degree: The degree to quotient in
• vecs: See Subspace::add_vectors

fn flush(&mut self, degree: i32)

pub fn quotient_all(&mut self, degree: i32)

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

pub fn reduce(&self, degree: i32, vec: FpSliceMut<'_>)

pub fn old_basis_to_new( &self, degree: i32, new: FpSliceMut<'_>, old: FpSlice<'_>, )

Trait Implementations

impl<M: Module> Display for QuotientModule<M>

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

Formats the value using the given formatter.

impl<M: Module> Module for QuotientModule<M>

type Algebra = <M as Module>::Algebra

fn algebra(&self) -> Arc<Self::Algebra>

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 dimension(&self, degree: i32) -> usize

The dimension of a module at the given degree

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

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 max_degree(&self) -> Option<i32>

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

fn compute_basis(&self, 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 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_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 total_dimension(&self) -> 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 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<M: ZeroModule> ZeroModule for QuotientModule<M>

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