Struct Resolution 

pub struct Resolution<M: ZeroModule<Algebra = MilnorAlgebra>> {
    lock: Mutex<()>,
    name: String,
    max_degree: i32,
    modules: OnceBiVec<Arc<FreeModule<MilnorAlgebra>>>,
    zero_module: Arc<FreeModule<MilnorAlgebra>>,
    differentials: OnceBiVec<Arc<FreeModuleHomomorphism<FreeModule<MilnorAlgebra>>>>,
    target: Arc<FiniteChainComplex<M>>,
    chain_maps: OnceBiVec<Arc<FreeModuleHomomorphism<M>>>,
    save_dir: SaveDirectory,
}

A resolution of S_2 using Nassau’s algorithm.

This aims to have an API similar to that of resolution::Resolution. From an API point of view, the main difference between the two is that this is a chain complex over MilnorAlgebra over SteenrodAlgebra.

Fields

lock: Mutex<()>

name: String

max_degree: i32

modules: OnceBiVec<Arc<FreeModule<MilnorAlgebra>>>

zero_module: Arc<FreeModule<MilnorAlgebra>>

differentials: OnceBiVec<Arc<FreeModuleHomomorphism<FreeModule<MilnorAlgebra>>>>

target: Arc<FiniteChainComplex<M>>

chain_maps: OnceBiVec<Arc<FreeModuleHomomorphism<M>>>

save_dir: SaveDirectory

Implementations

impl<M: ZeroModule<Algebra = MilnorAlgebra>> Resolution<M>

pub fn name(&self) -> &str

pub fn set_name(&mut self, name: String)

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

pub fn new_with_save( module: Arc<M>, save_dir: impl Into<SaveDirectory>, ) -> Result<Self>

fn add_generators(&self, b: Bidegree, num_new_gens: usize)

fn extend_through_degree(&self, max_s: i32)

This function prepares the Resolution object to perform computations up to the specified s degree. It does not perform any computations by itself. It simply lengthens the OnceVecs modules, chain_maps, etc. to the right length.

fn write_qi( f: &mut Option<impl Write>, scratch: &mut FpVector, signature: &[PPartEntry], next_mask: &[usize], full_matrix: &Matrix, masked_matrix: &AugmentedMatrix<2>, ) -> Result<()>

fn write_differential( &self, b: Bidegree, num_new_gens: usize, target_dim: usize, ) -> Result<()>

fn step_resolution_with_subalgebra( &self, b: Bidegree, subalgebra: MilnorSubalgebra, ) -> Result<()>

fn step0(&self, t: i32)

Step resolution for s = 0

fn step1(&self, t: i32) -> Result<()>

Step resolution for s = 1

fn step_resolution_with_result(&self, b: Bidegree) -> Result<()>

fn step_resolution(&self, b: Bidegree)

pub fn compute_through_stem(&self, max: Bidegree)

This function resolves up till a fixed stem instead of a fixed t.

Trait Implementations

impl<M: ZeroModule<Algebra = MilnorAlgebra>> AugmentedChainComplex for Resolution<M>

type ChainMap = MuFreeModuleHomomorphism<false, M>

type TargetComplex = FiniteChainComplex<M>

fn target(&self) -> Arc<Self::TargetComplex>

fn chain_map(&self, s: i32) -> Arc<Self::ChainMap>

impl<M: ZeroModule<Algebra = MilnorAlgebra>> ChainComplex for Resolution<M>

type Algebra = MilnorAlgebra

type Homomorphism = MuFreeModuleHomomorphism<false, MuFreeModule<false, <Resolution<M> as ChainComplex>::Algebra>>

type Module = MuFreeModule<false, <Resolution<M> as ChainComplex>::Algebra>

fn prime(&self) -> ValidPrime

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

fn module(&self, s: i32) -> Arc<Self::Module>

fn zero_module(&self) -> Arc<Self::Module>

fn min_degree(&self) -> i32

fn has_computed_bidegree(&self, b: Bidegree) -> bool

If the complex has been computed at bidegree (s, t). This means the module has been computed at (s, t), and so has the differential at (s, t). In the case of a free module, the target of the differential, namely the bidegree (s - 1, t), need not be computed, as long as all the generators hit by the differential have already been computed.

fn differential(&self, s: i32) -> Arc<Self::Homomorphism>

This returns the differential starting from the sth module.

fn compute_through_bidegree(&self, max: Bidegree)

Ensure all bidegrees less than or equal to (s, t) have been computed

fn next_homological_degree(&self) -> i32

The first s such that self.module(s) is not defined.

fn save_dir(&self) -> &SaveDirectory

A directory used to save information about the chain complex.

fn apply_quasi_inverse<T, S>( &self, results: &mut [T], b: Bidegree, inputs: &[S], ) -> bool

where for<'a> &'a mut T: Into<FpSliceMut<'a>>, for<'a> &'a S: Into<FpSlice<'a>>,

Apply the quasi-inverse of the (s, t)th differential to the list of inputs and results. This defaults to applying self.differentials(s).quasi_inverse(t), but in some cases the quasi-inverse might be stored separately on disk.

fn iter_stem(&self) -> StemIterator<'_, Self>

Iterate through all defined bidegrees in increasing order of stem.

fn save_file(&self, kind: SaveKind, b: Bidegree) -> SaveFile<Self::Algebra>

Get the save file of a bidegree