Struct ModuleHomomorphism 

pub struct ModuleHomomorphism<R: Ring> { /* private fields */ }

An exact homomorphism between finite based free modules.

Matrices act on column coordinates and therefore have shape target.rank() x source.rank(). Dense and sparse storage are private representations of the same mathematical map.

Implementations

impl ModuleHomomorphism<IntegerRing>

pub fn image(&self) -> Result<ImageSubmodule<IntegerRing>, ModuleError>

Canonical image lattice with map-bound completeness evidence.

pub fn kernel(&self) -> Result<KernelSubmodule<IntegerRing>, ModuleError>

Canonical complete kernel lattice with map-bound evidence.

impl ModuleHomomorphism<ResidueRing>

pub fn image(&self) -> Result<ImageSubmodule<ResidueRing>, ModuleError>

Canonical image submodule with map-bound completeness evidence.

pub fn kernel(&self) -> Result<KernelSubmodule<ResidueRing>, ModuleError>

Canonical complete kernel with evidence over a possibly composite modulus.

impl<R: Ring> ModuleHomomorphism<R>

pub fn from_matrix( source: FreeModule<R>, target: FreeModule<R>, matrix: Matrix<R>, ) -> Result<Self, ModuleError>

Construct a map from a dense matrix.

pub fn from_sparse_matrix( source: FreeModule<R>, target: FreeModule<R>, matrix: SparseMatrix<R>, ) -> Result<Self, ModuleError>

Construct a map from a canonical sparse matrix.

pub fn zero( source: FreeModule<R>, target: FreeModule<R>, ) -> Result<Self, ModuleError>

Sparse zero map between two modules over the same exact ring context.

pub fn identity(module: FreeModule<R>) -> Result<Self, ModuleError>

Sparse identity map of one based free module.

pub fn source(&self) -> &FreeModule<R>

Source based free module.

pub fn target(&self) -> &FreeModule<R>

Target based free module.

pub fn matrix(&self) -> Matrix<R>

Losslessly materialize the presentation matrix.

pub fn sparse_matrix(&self) -> Option<&SparseMatrix<R>>

Borrow the sparse presentation when this map retains sparse storage.

pub fn is_sparse(&self) -> bool

Whether the map retains canonical sparse storage.

pub fn apply( &self, element: &ModuleElement<R>, ) -> Result<ModuleElement<R>, ModuleError>

Apply this map to an element of its exact source module.

pub fn compose(&self, inner: &Self) -> Result<Self, ModuleError>

Compose self after inner.

pub fn add(&self, rhs: &Self) -> Result<Self, ModuleError>

Add maps with identical source and target based modules.

pub fn sub(&self, rhs: &Self) -> Result<Self, ModuleError>

Subtract maps with identical source and target based modules.

pub fn copair(&self, rhs: &Self) -> Result<Self, ModuleError>

Copair maps with one common target into a map from the direct sum of their sources. Its matrix is the horizontal block [self rhs].

pub fn pair(&self, rhs: &Self) -> Result<Self, ModuleError>

Pair maps with one common source into a map to the direct sum of their targets. Its matrix is the vertical block [self; rhs].

pub fn direct_sum(&self, rhs: &Self) -> Result<Self, ModuleError>

Block-diagonal direct sum of two maps.

pub fn tensor(&self, rhs: &Self) -> Result<Self, ModuleError>

where R: CommutativeRing,

Tensor product of maps between finite based free modules.

The tensor bases use the same lexicographic order as FreeModule::tensor: the left basis position is the outer index and the right basis position is the inner index. Sparse inputs retain a sparse Kronecker product without materializing zero coefficients.

pub fn dual(&self) -> Result<Self, ModuleError>

where R: CommutativeRing,

Dual map between the dual based free modules.

pub fn map_coefficients<M>( &self, map: &M, ) -> Result<ModuleHomomorphism<M::Target>, ModuleError>

where M: CoefficientMap<Source = R>, R: Display,

Apply a checked coefficient map to source, target, and every matrix entry.

pub fn to_json(&self) -> Result<String, NoetherError>

where R: Serialize, R::Element: Serialize,

Serialize both endpoint modules and the retained matrix layout.

pub fn from_json(value: &str) -> Result<Self, NoetherError>

where R: for<'de> Deserialize<'de>, R::Element: for<'de> Deserialize<'de>,

Deserialize and revalidate an exact module homomorphism.

impl ModuleHomomorphism<PolynomialRing<IntegerRing>>

pub fn kernel( &self, order: ModuleMonomialOrder, ) -> Result<Submodule<PolynomialRing<IntegerRing>>, ModuleGroebnerError>

Exact kernel as a generated integral polynomial submodule.

impl<C: Field> ModuleHomomorphism<PolynomialRing<C>>

pub fn kernel( &self, order: ModuleMonomialOrder, ) -> Result<Submodule<PolynomialRing<C>>, ModuleGroebnerError>

Exact kernel as a generated submodule of this map’s source.

impl<C: Field> ModuleHomomorphism<QuotientRing<PolynomialRing<C>>>

pub fn kernel( &self, order: ModuleMonomialOrder, ) -> Result<Submodule<QuotientRing<PolynomialRing<C>>>, ModuleGroebnerError>

Exact kernel over a polynomial quotient, computed through the lifted graph [lift(self), -I e_j] in the ambient polynomial ring.

impl<R: CommutativeRing> ModuleHomomorphism<R>

pub fn symmetric_power( &self, degree: usize, ) -> Result<ModulePowerHomomorphism<R>, ModulePowerError>

Map induced on the degree-degree symmetric powers.

pub fn exterior_power( &self, degree: usize, ) -> Result<ModulePowerHomomorphism<R>, ModulePowerError>

Map induced on the degree-degree exterior powers.

Trait Implementations

impl<R: Ring> Add<&ModuleHomomorphism<R>> for &ModuleHomomorphism<R>

type Output = Result<ModuleHomomorphism<R>, ModuleError>

The resulting type after applying the + operator.

fn add(self, rhs: &ModuleHomomorphism<R>) -> Self::Output

Performs the + operation.

impl<R: Clone + Ring> Clone for ModuleHomomorphism<R>

fn clone(&self) -> ModuleHomomorphism<R>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<R: Ring> Debug for ModuleHomomorphism<R>

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

Formats the value using the given formatter.

impl<'de, R> Deserialize<'de> for ModuleHomomorphism<R>

where R: Ring + Deserialize<'de>, R::Element: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R: Ring> Display for ModuleHomomorphism<R>

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

Formats the value using the given formatter.

impl<R: PartialEq + Ring> PartialEq for ModuleHomomorphism<R>

fn eq(&self, other: &ModuleHomomorphism<R>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R: Ring> SemanticType for ModuleHomomorphism<R>

const TYPE_ID: &'static str = "noether/homalg/ModuleHomomorphism@1"

Versioned, language-neutral semantic identity.

fn canonical_bytes(&self) -> Result<Vec<u8>, NoetherError>

Serialize without backend- or language-specific identity.

fn describe() -> &'static TypeDescription

Return static discovery metadata for the type.

impl<R> Serialize for ModuleHomomorphism<R>

where R: Ring + Serialize, R::Element: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<R: Ring> Sub<&ModuleHomomorphism<R>> for &ModuleHomomorphism<R>

type Output = Result<ModuleHomomorphism<R>, ModuleError>

The resulting type after applying the - operator.

fn sub(self, rhs: &ModuleHomomorphism<R>) -> Self::Output

Performs the - operation.

impl<R: Eq + Ring> Eq for ModuleHomomorphism<R>

impl<R: Ring> StructuralPartialEq for ModuleHomomorphism<R>