Struct MuResolutionHomomorphism 

pub struct MuResolutionHomomorphism<const U: bool, CC1, CC2>
where
    CC1: FreeChainComplex<U>,
    CC1::Algebra: MuAlgebra<U>,
    CC2: ChainComplex<Algebra = CC1::Algebra>,
{
    name: String,
    pub source: Arc<CC1>,
    pub target: Arc<CC2>,
    maps: OnceBiVec<Arc<MuFreeModuleHomomorphism<U, CC2::Module>>>,
    pub shift: Bidegree,
    save_dir: SaveDirectory,
}

A chain complex homomorphims from a FreeChainComplex. This contains logic to lift chain maps using the freeness.

Fields

name: String

source: Arc<CC1>

target: Arc<CC2>

maps: OnceBiVec<Arc<MuFreeModuleHomomorphism<U, CC2::Module>>>

shift: Bidegree

save_dir: SaveDirectory

Implementations

impl<const U: bool, CC1, CC2> MuResolutionHomomorphism<U, CC1, CC2>

where CC1: FreeChainComplex<U>, CC1::Algebra: MuAlgebra<U>, CC2: ChainComplex<Algebra = CC1::Algebra>,

pub fn new( name: String, source: Arc<CC1>, target: Arc<CC2>, shift: Bidegree, ) -> Self

pub fn name(&self) -> &str

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

pub fn next_homological_degree(&self) -> i32

fn get_map_ensure_length( &self, input_s: i32, ) -> &MuFreeModuleHomomorphism<U, CC2::Module>

pub fn get_map( &self, input_s: i32, ) -> Arc<MuFreeModuleHomomorphism<U, CC2::Module>>

Returns the chain map on the sth source module.

pub fn save_dir(&self) -> &SaveDirectory

impl<const U: bool, CC1, CC2> MuResolutionHomomorphism<U, CC1, CC2>

where CC1: FreeChainComplex<U>, CC1::Algebra: MuAlgebra<U>, CC2: ChainComplex<Algebra = CC1::Algebra>,

pub fn extend(&self, max: Bidegree)

Extend the resolution homomorphism such that it is defined on degrees (max_s, max_t).

This assumes in yet-uncomputed bidegrees, the homology of the source consists only of decomposables (e.g. it is trivial). More precisely, we assume MuResolutionHomomorphism::extend_step_raw can be called with extra_images = None.

pub fn extend_through_stem(&self, max: Bidegree)

Extend the resolution homomorphism such that it is defined on degrees (max_n, max_s).

This assumes in yet-uncomputed bidegrees, the homology of the source consists only of decomposables (e.g. it is trivial). More precisely, we assume MuResolutionHomomorphism::extend_step_raw can be called with extra_images = None.

pub fn extend_all(&self)

Extend the resolution homomorphism as far as possible, as constrained by how much the source and target have been resolved.

This assumes in yet-uncomputed bidegrees, the homology of the source consists only of decomposables (e.g. it is trivial). More precisely, we assume MuResolutionHomomorphism::extend_step_raw can be called with extra_images = None.

pub fn extend_profile<AUX: Sync>(&self, max: BidegreeRange<'_, AUX>)

Extends the resolution homomorphism up to a given range. This range is first specified by the maximum s, then the maximum t for each s. This should rarely be used directly; instead one should use MuResolutionHomomorphism::extend, MuResolutionHomomorphism::extend_through_stem and ResolutionHomomorphism::extend_all as appropriate.

Note that unlike the more specific versions of this function, the bounds max_s and max_t are exclusive.

This assumes in yet-uncomputed bidegrees, the homology of the source consists only of decomposables (e.g. it is trivial). More precisely, we assume MuResolutionHomomorphism::extend_step_raw can be called with extra_images = None.

pub fn extend_step_raw( &self, input: Bidegree, extra_images: Option<Vec<FpVector>>, ) -> Range<i32>

Extend the MuResolutionHomomorphism to be defined on (input_s, input_t). The resulting homomorphism f is a chain map such that if g is the kth generator in the source such that d(g) = 0, then f(g) is the kth row of extra_images.

The user should call this function explicitly to manually define the chain map where the chain complex is not exact, and then call MuResolutionHomomorphism::extend_all to extend the rest by exactness.

impl<const U: bool, CC1, CC2> MuResolutionHomomorphism<U, CC1, CC2>

where CC1: FreeChainComplex<U>, CC1::Algebra: MuAlgebra<U>, CC2: AugmentedChainComplex<Algebra = CC1::Algebra>,

pub fn from_class( name: String, source: Arc<CC1>, target: Arc<CC2>, shift: Bidegree, class: &[u32], ) -> Self

pub fn extend_step( &self, input: Bidegree, extra_images: Option<&Matrix>, ) -> Range<i32>

Extend the MuResolutionHomomorphism to be defined on (input_s, input_t). The resulting homomorphism f is a chain map such that if g is the kth generator in the source such that d(g) = 0, then the image of f(g) in the augmentation of the target is the kth row of extra_images.

The user should call this function explicitly to manually define the chain map where the chain complex is not exact, and then call MuResolutionHomomorphism::extend_all to extend the rest by exactness.

impl<const U: bool, CC1, CC2> MuResolutionHomomorphism<U, CC1, CC2>

where CC1: AugmentedChainComplex + FreeChainComplex<U>, CC1::Algebra: MuAlgebra<U>, CC2: AugmentedChainComplex<Algebra = CC1::Algebra>, CC1::TargetComplex: BoundedChainComplex, CC2::TargetComplex: BoundedChainComplex,

pub fn from_module_homomorphism( name: String, source: Arc<CC1>, target: Arc<CC2>, f: &impl ModuleHomomorphism<Source = <<CC1 as AugmentedChainComplex>::TargetComplex as ChainComplex>::Module, Target = <<CC2 as AugmentedChainComplex>::TargetComplex as ChainComplex>::Module>, ) -> Self

Construct a chain map that lifts a given module homomorphism.

impl<const U: bool, CC1, CC2> MuResolutionHomomorphism<U, CC1, CC2>

where CC1: FreeChainComplex<U>, CC1::Algebra: MuAlgebra<U>, CC2: FreeChainComplex<U, Algebra = CC1::Algebra>,

pub fn act(&self, result: FpSliceMut<'_>, coef: u32, g: BidegreeGenerator)

Given a chain map $f: C \to C’$ between free chain complexes, apply $$ \Hom(f, k): \Hom(C’, k) \to \Hom(C, k) $$ to the specified generator of $\Hom(C’, k)$.