homalg · PresentedModuleHomomorphism

26 accepted declarations. Python and Rust forms, contracts, evidence, failure boundaries, and checked usages are kept together below.

Worked example

The complete checked program Compute in an exterior algebra and induce a linear map on two-forms uses this API directly.

# SPDX-License-Identifier: MIT
# Copyright (c) 2026 Benjamin Antieau and Deven Manam
"""Compute in an exterior algebra and induce a linear map on two-forms."""

from noether import Q
from noether.commalg import PolynomialRing
from noether.homalg import FreeModule, ModuleElement, ModuleHomomorphism
from noether.linalg import Matrix, Vector


def main() -> None:
    ring = PolynomialRing(Q, ["t"])
    module = FreeModule(ring, 3, basis_labels=["e0", "e1", "e2"])
    exterior = module.exterior_algebra()
    e0, e1, e2 = [exterior.generator(position) for position in range(3)]

    volume = e0 * e1 * e2
    assert volume == exterior.alternating_product(
        [
            ModuleElement(module, Vector.from_values(ring, [1, 0, 0])),
            ModuleElement(module, Vector.from_values(ring, [0, 1, 0])),
            ModuleElement(module, Vector.from_values(ring, [0, 0, 1])),
        ]
    )
    assert e1 * e0 == -(e0 * e1)
    assert e0 * e0 == exterior.zero()

    e0_dual = ModuleElement(module.dual(), Vector.from_values(ring, [1, 0, 0]))
    assert volume.contract(e0_dual) == e1 * e2

    linear_map = ModuleHomomorphism(
        module,
        module,
        Matrix.from_rows(ring, [[1, 1, 0], [0, 1, 0], [0, 0, 2]]),
    )
    on_two_forms = linear_map.exterior_power(2)
    on_two_forms.verify()
    assert on_two_forms.apply_exterior(e1 * e2) == 2 * (e0 * e2 + e1 * e2)
    print(
        "Λ² has basis",
        exterior.basis(2),
        "and the induced map sends e1∧e2 to",
        on_two_forms.apply_exterior(e1 * e2).terms,
    )


if __name__ == "__main__":
    main()

Run it with .venv/bin/python examples/40_exterior_algebra.py.

homalg.PresentedModuleHomomorphism

A checked homomorphism between retained module presentations.

PythonRust

PresentedModuleHomomorphism(source: PresentedModule[_BasicModuleRing], target: PresentedModule[_BasicModuleRing], generator_lift: ModuleHomomorphism[_BasicModuleRing], relation_lift: ModuleHomomorphism[_BasicModuleRing])

noether::homalg::PresentedModuleHomomorphism · Direct Rust declaration

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

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	attached / bounded
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: validation/unit/homalg/test_exterior_algebra.py:26 · validation/unit/homalg/test_exterior_algebra.py:272 · validation/unit/homalg/test_exterior_algebra.py:273 · validation/unit/homalg/test_exterior_algebra.py:274 · validation/unit/homalg/test_exterior_algebra.py:283 · validation/unit/homalg/test_exterior_algebra.py:326

homalg.PresentedModuleHomomorphism.__add__

Add another compatible value to this value.

Detailed contract

Add maps with identical retained source and target presentations. Returns the argument unchanged.

PythonRust

(self, rhs: PresentedModuleHomomorphism[_BasicModuleRing]) -> PresentedModuleHomomorphism[_BasicModuleRing]

noether::homalg::PresentedModuleHomomorphism::add · Direct Rust declaration

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

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: validation/unit/infra/test_discovery.py:211 · validation/unit/infra/test_public_api_index.py:293

homalg.PresentedModuleHomomorphism.__sub__

Subtract another compatible value from this value.

Detailed contract

Subtract maps with identical retained source and target presentations.

PythonRust

(self, rhs: PresentedModuleHomomorphism[_BasicModuleRing]) -> PresentedModuleHomomorphism[_BasicModuleRing]

noether::homalg::PresentedModuleHomomorphism::sub · Direct Rust declaration

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

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: validation/unit/infra/test_discovery.py:212

homalg.PresentedModuleHomomorphism.coimage

Compute coimage for this PresentedModuleHomomorphism.

Detailed contract

Coimage as the exact quotient projection from the source. The target presentation is identical to the source of Self::image when both are computed with the same order. Coimage as the exact quotient projection from the source.

PythonRust

(self: PresentedModuleHomomorphism[_GroebnerModuleRing], order: ModuleMonomialOrder) -> PresentedModuleHomomorphism[_GroebnerModuleRing]

noether::homalg::PresentedModuleHomomorphism::coimage · Direct Rust declaration

pub fn coimage( &self, order: ModuleMonomialOrder, ) -> Result<Self, ModuleGroebnerError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: validation/unit/infra/test_discovery.py:156

homalg.PresentedModuleHomomorphism.cokernel

Compute cokernel for this PresentedModuleHomomorphism.

Detailed contract

Cokernel with its direct block presentation [Q A], where Q is the target presentation and A is the retained generator lift.

PythonRust

(self) -> PresentedModule[_BasicModuleRing]

noether::homalg::PresentedModuleHomomorphism::cokernel · Direct Rust declaration

pub fn cokernel(&self) -> Result<PresentedModule<R>, ModuleError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: validation/bench/macaulay2_presented_modules.py:417 · validation/bench/macaulay2_presented_modules.py:554 · validation/bench/macaulay2_presented_modules.py:56 · validation/bench/macaulay2_presented_modules.py:594 · validation/bench/macaulay2_presented_modules.py:6 · validation/bench/macaulay2_presented_modules.py:790

homalg.PresentedModuleHomomorphism.cokernel_projection

Compute cokernel projection for this PresentedModuleHomomorphism.

Detailed contract

Canonical quotient map from the target onto Self::cokernel. Its relation certificate is the inclusion of the target’s retained relations into the first block of the cokernel presentation [Q A].

PythonRust

(self) -> PresentedModuleHomomorphism[_BasicModuleRing]

noether::homalg::PresentedModuleHomomorphism::cokernel_projection · Direct Rust declaration

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

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: validation/unit/homalg/test_exterior_algebra.py:282 · validation/unit/homalg/test_module_facade.py:389

homalg.PresentedModuleHomomorphism.compose

Compose this PresentedModuleHomomorphism with another compatible map.

Detailed contract

Compose self after inner, composing both parts of the checked commuting squares.

PythonRust

(self, inner: PresentedModuleHomomorphism[_BasicModuleRing]) -> PresentedModuleHomomorphism[_BasicModuleRing]

noether::homalg::PresentedModuleHomomorphism::compose · Direct Rust declaration

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

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: validation/unit/commalg/test_context_tower_workload.py:3 · validation/unit/commalg/test_polynomial_facade.py:200 · validation/unit/commalg/test_power_series_facade.py:151 · validation/unit/commalg/test_power_series_facade.py:245 · validation/unit/commalg/test_power_series_facade.py:248 · validation/unit/groups/test_permutation_group_facade.py:41

homalg.PresentedModuleHomomorphism.exterior_power

Map induced between degree-degree exterior-power presentations.

Detailed contract

Checked map induced on the degree-degree exterior power presentations.

PythonRust

(self, degree: int) -> PresentedModulePowerHomomorphism[_BasicModuleRing]

noether::homalg::PresentedModuleHomomorphism::exterior_power · Direct Rust declaration

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

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: examples/40_exterior_algebra.py:36 · validation/unit/homalg/test_exterior_algebra.py:163 · validation/unit/homalg/test_exterior_algebra.py:164 · validation/unit/homalg/test_exterior_algebra.py:165 · validation/unit/homalg/test_exterior_algebra.py:242 · validation/unit/homalg/test_exterior_algebra.py:246

homalg.PresentedModuleHomomorphism.from_generator_lift

Construct a PresentedModuleHomomorphism using generator lift.

Detailed contract

Construct the unique retained presented-module map induced by a map on generators, computing an exact target-relation certificate. Every source presentation relation is reduced against the target presentation. Failure means that the supplied generator map does not descend to the cokernels. Construct a quotient-module map from its generator lift, computing the exact relation certificate in the quotient context.

PythonRust

(cls, source: PresentedModule[_GroebnerModuleRing], target: PresentedModule[_GroebnerModuleRing], generator_lift: ModuleHomomorphism[_GroebnerModuleRing], order: ModuleMonomialOrder) -> PresentedModuleHomomorphism[_GroebnerModuleRing]

noether::homalg::PresentedModuleHomomorphism::from_generator_lift · Direct Rust declaration

pub fn from_generator_lift( source: PresentedModule<PolynomialRing<C>>, target: PresentedModule<PolynomialRing<C>>, generator_lift: ModuleHomomorphism<PolynomialRing<C>>, order: ModuleMonomialOrder, ) -> Result<Self, ModuleGroebnerError>
pub fn from_generator_lift( source: PresentedModule<QuotientRing<PolynomialRing<C>>>, target: PresentedModule<QuotientRing<PolynomialRing<C>>>, generator_lift: ModuleHomomorphism<QuotientRing<PolynomialRing<C>>>, order: ModuleMonomialOrder, ) -> Result<Self, ModuleGroebnerError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	attached / bounded
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: validation/unit/homalg/test_module_facade.py:311 · validation/unit/homalg/test_module_facade.py:379

homalg.PresentedModuleHomomorphism.from_json

Deserialize and revalidate a PresentedModuleHomomorphism from typed JSON.

Detailed contract

Deserialize and reverify a presented-module homomorphism.

PythonRust

(cls, value: str) -> PresentedModuleHomomorphism[_BasicModuleRing]

noether::homalg::PresentedModuleHomomorphism::from_json · Direct Rust declaration

pub fn from_json(value: &str) -> Result<Self, NoetherError>where R: for<'de> Deserialize<'de>, R::Element: for<'de> Deserialize<'de>,

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: validation/unit/category/test_category.py:14 · validation/unit/combin/test_acceptance_workload.py:65 · validation/unit/combin/test_acceptance_workload.py:86 · validation/unit/combin/test_graph_facade.py:106 · validation/unit/combin/test_graph_facade.py:25 · validation/unit/combinatorics/test_kashiwara_crystal.py:32

homalg.PresentedModuleHomomorphism.generator_lift

Return the generator lift recorded by this PresentedModuleHomomorphism.

Detailed contract

Map between generator modules inducing this presented-module map.

PythonRust

(self) -> ModuleHomomorphism[_BasicModuleRing]

noether::homalg::PresentedModuleHomomorphism::generator_lift · Direct Rust declaration

pub fn generator_lift(&self) -> &ModuleHomomorphism<R>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	attached / bounded
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: validation/unit/homalg/test_exterior_algebra.py:275 · validation/unit/homalg/test_module_facade.py:312 · validation/unit/homalg/test_module_facade.py:346 · validation/bench/macaulay2_presented_modules.py:593

homalg.PresentedModuleHomomorphism.homology

Compute homology for this PresentedModuleHomomorphism.

Detailed contract

Module-valued homology at self.source() for the complex incoming -> self.source() -> self.target(). Module-valued homology at self.source() over the polynomial quotient.

PythonRust

(self: PresentedModuleHomomorphism[_GroebnerModuleRing], incoming: PresentedModuleHomomorphism[_GroebnerModuleRing], order: ModuleMonomialOrder) -> PresentedModuleHomology[_GroebnerModuleRing]

noether::homalg::PresentedModuleHomomorphism::homology · Direct Rust declaration

pub fn homology( &self, incoming: &Self, order: ModuleMonomialOrder, ) -> Result<PresentedModuleHomology<PolynomialRing<C>>, ModuleGroebnerError>
pub fn homology( &self, incoming: &Self, order: ModuleMonomialOrder, ) -> Result<PresentedModuleHomology<QuotientRing<PolynomialRing<C>>>, ModuleGroebnerError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: examples/28_steiner_categories.py:3 · examples/35_eilenberg_maclane_spaces.py:12 · examples/35_eilenberg_maclane_spaces.py:13 · examples/35_eilenberg_maclane_spaces.py:14 · examples/35_eilenberg_maclane_spaces.py:21 · validation/unit/homalg/test_chain_complex.py:111

homalg.PresentedModuleHomomorphism.identity

Construct a PresentedModuleHomomorphism using identity.

Detailed contract

Identity map, with identity lifts on generators and relations.

PythonRust

(cls, module: PresentedModule[_BasicModuleRing]) -> PresentedModuleHomomorphism[_BasicModuleRing]

noether::homalg::PresentedModuleHomomorphism::identity · Direct Rust declaration

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

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	attached / bounded
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: examples/01_bezout_certificates.py:10 · examples/01_bezout_certificates.py:12 · examples/01_bezout_certificates.py:14 · examples/01_bezout_certificates.py:9 · examples/02_ball_arithmetic.py:3 · examples/distributed/f2_linear_algebra.py:20

homalg.PresentedModuleHomomorphism.image

Compute image for this PresentedModuleHomomorphism.

Detailed contract

Image as its exact inclusion into the target presented module. Its source presentation is the canonical coimage presentation F/A^-1(im Q), and the relation lift proves that the inducing map lands in the target quotient. Image as its exact inclusion into the target quotient module.

PythonRust

(self: PresentedModuleHomomorphism[_GroebnerModuleRing], order: ModuleMonomialOrder) -> PresentedModuleHomomorphism[_GroebnerModuleRing]

noether::homalg::PresentedModuleHomomorphism::image · Direct Rust declaration

pub fn image( &self, order: ModuleMonomialOrder, ) -> Result<Self, ModuleGroebnerError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: examples/05_sparse_exact_operators.py:16 · examples/05_sparse_exact_operators.py:17 · examples/05_sparse_exact_operators.py:19 · examples/33_simplicial_cohomology_operations.py:30 · examples/33_simplicial_cohomology_operations.py:31 · examples/38_exact_linear_systems.py:69

homalg.PresentedModuleHomomorphism.is_equal

Test whether this PresentedModuleHomomorphism is equal.

Detailed contract

Decide equality of the induced quotient maps by reducing the difference of their generator lifts modulo the target relations. Structural PartialEq deliberately compares the retained lifts. This operation answers the stronger mathematical question and requires a portable term-over-position or position-over-term module order. Decide equality of induced maps over a polynomial quotient by reducing their generator-lift difference modulo the target relations.

PythonRust

(self: PresentedModuleHomomorphism[_GroebnerModuleRing], rhs: PresentedModuleHomomorphism[_GroebnerModuleRing], order: ModuleMonomialOrder) -> bool

noether::homalg::PresentedModuleHomomorphism::is_equal · Direct Rust declaration

pub fn is_equal( &self, rhs: &Self, order: ModuleMonomialOrder, ) -> Result<bool, ModuleGroebnerError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: validation/unit/homalg/test_exact_submodules.py:131 · validation/unit/homalg/test_exact_submodules.py:51 · validation/unit/homalg/test_exact_submodules.py:62 · validation/unit/homalg/test_module_facade.py:121 · validation/unit/homalg/test_module_facade.py:135 · validation/unit/homalg/test_module_facade.py:136

homalg.PresentedModuleHomomorphism.is_exact_at_source

Test whether this PresentedModuleHomomorphism is exact at source.

Detailed contract

Decide exactness in incoming -> self.source() -> self.target(). This compares the lifted incoming image plus the source relations with the exact preimage of the target relations, in both directions. Decide exactness in incoming -> self.source() -> self.target() over the quotient context.

PythonRust

(self: PresentedModuleHomomorphism[_GroebnerModuleRing], incoming: PresentedModuleHomomorphism[_GroebnerModuleRing], order: ModuleMonomialOrder) -> bool

noether::homalg::PresentedModuleHomomorphism::is_exact_at_source · Direct Rust declaration

pub fn is_exact_at_source( &self, incoming: &Self, order: ModuleMonomialOrder, ) -> Result<bool, ModuleGroebnerError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: validation/unit/homalg/test_module_facade.py:395 · validation/unit/infra/test_discovery.py:160 · validation/bench/macaulay2_presented_modules.py:555

homalg.PresentedModuleHomomorphism.is_zero

Test whether this PresentedModuleHomomorphism is zero.

Detailed contract

Decide whether the induced map is zero modulo the target relations. Decide whether this induced quotient-module map is zero.

PythonRust

(self: PresentedModuleHomomorphism[_GroebnerModuleRing], order: ModuleMonomialOrder) -> bool

noether::homalg::PresentedModuleHomomorphism::is_zero · Direct Rust declaration

pub fn is_zero( &self, order: ModuleMonomialOrder, ) -> Result<bool, ModuleGroebnerError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: examples/17_weighted_power_series.py:16 · examples/17_weighted_power_series.py:17 · examples/39_kahler_differentials.py:20 · validation/unit/commalg/test_graded_commutative_facade.py:26 · validation/unit/commalg/test_kahler_differentials.py:113 · validation/unit/commalg/test_kahler_differentials.py:38

homalg.PresentedModuleHomomorphism.kernel

Compute kernel for this PresentedModuleHomomorphism.

Detailed contract

Kernel as its exact inclusion into the source presented module. The returned map has source ker(self) and target self.source(). Its retained presentation includes both syzygies of the computed preimage and the original source relations, so it presents A^-1(im Q) / im P rather than the unrelated ambient preimage. Kernel as its exact inclusion into the source quotient module.

PythonRust

(self: PresentedModuleHomomorphism[_GroebnerModuleRing], order: ModuleMonomialOrder) -> PresentedModuleHomomorphism[_GroebnerModuleRing]

noether::homalg::PresentedModuleHomomorphism::kernel · Direct Rust declaration

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

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: examples/38_exact_linear_systems.py:68 · examples/38_exact_linear_systems.py:70 · examples/38_exact_linear_systems.py:72 · validation/unit/homalg/test_exact_submodules.py:78 · validation/unit/homalg/test_exact_submodules.py:93 · validation/unit/homalg/test_exact_submodules.py:95

homalg.PresentedModuleHomomorphism.relation_lift

Return the relation lift recorded by this PresentedModuleHomomorphism.

Detailed contract

Retained certificate mapping source relations to target relations.

PythonRust

(self) -> ModuleHomomorphism[_BasicModuleRing]

noether::homalg::PresentedModuleHomomorphism::relation_lift · Direct Rust declaration

pub fn relation_lift(&self) -> &ModuleHomomorphism<R>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	attached / bounded
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: validation/unit/homalg/test_exterior_algebra.py:275 · validation/unit/homalg/test_exterior_algebra.py:467 · validation/unit/homalg/test_exterior_algebra.py:468

homalg.PresentedModuleHomomorphism.source

Return the source recorded by this PresentedModuleHomomorphism.

Detailed contract

Retained source cokernel presentation.

PythonRust

(self) -> PresentedModule[_BasicModuleRing]

noether::homalg::PresentedModuleHomomorphism::source · Direct Rust declaration

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

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	attached / bounded
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: examples/09_finite_field_isomorphisms.py:11 · examples/09_finite_field_isomorphisms.py:13 · examples/09_finite_field_isomorphisms.py:9 · examples/30_modules_and_resolutions.py:34 · examples/30_modules_and_resolutions.py:37 · validation/unit/category/test_acceptance_workload.py:25

homalg.PresentedModuleHomomorphism.symmetric_power

Map induced between degree-degree symmetric-power presentations.

Detailed contract

Checked map induced on the degree-degree symmetric power presentations.

PythonRust

(self, degree: int) -> PresentedModulePowerHomomorphism[_BasicModuleRing]

noether::homalg::PresentedModuleHomomorphism::symmetric_power · Direct Rust declaration

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

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: validation/unit/homalg/test_exterior_algebra.py:242 · validation/unit/homalg/test_exterior_algebra.py:286 · validation/unit/homalg/test_exterior_algebra.py:443 · validation/unit/homalg/test_module_powers.py:119 · validation/unit/homalg/test_module_powers.py:141 · validation/unit/homalg/test_module_powers.py:157

homalg.PresentedModuleHomomorphism.target

Return the target recorded by this PresentedModuleHomomorphism.

Detailed contract

Retained target cokernel presentation.

PythonRust

(self) -> PresentedModule[_BasicModuleRing]

noether::homalg::PresentedModuleHomomorphism::target · Direct Rust declaration

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

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	attached / bounded
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: examples/09_finite_field_isomorphisms.py:10 · examples/09_finite_field_isomorphisms.py:11 · examples/30_modules_and_resolutions.py:33 · examples/30_modules_and_resolutions.py:38 · examples/31_local_fields_and_precision.py:27 · examples/36_affine_normalization.py:16

homalg.PresentedModuleHomomorphism.tensor

Compute tensor for this PresentedModuleHomomorphism.

Detailed contract

Tensor product of two checked maps between retained presentations. The generator lift is the tensor product of generator lifts. The two relation blocks retain respectively the tensor products of the left relation lift with the right generator lift and the left generator lift with the right relation lift. Self::from_lifts then rechecks the complete tensor-presentation square.

PythonRust

(self, rhs: PresentedModuleHomomorphism[_BasicModuleRing]) -> PresentedModuleHomomorphism[_BasicModuleRing]

noether::homalg::PresentedModuleHomomorphism::tensor · Direct Rust declaration

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

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: examples/23_kashiwara_crystals.py:10 · examples/23_kashiwara_crystals.py:3 · validation/unit/combin/test_acceptance_workload.py:58 · validation/unit/combinatorics/test_kashiwara_crystal.py:41 · validation/unit/combinatorics/test_kashiwara_crystal.py:42 · validation/unit/combinatorics/test_kashiwara_crystal.py:44

homalg.PresentedModuleHomomorphism.to_json

Serialize this PresentedModuleHomomorphism to its canonical typed JSON representation.

Detailed contract

Serialize both endpoint presentations, the inducing lift, and its commuting-square certificate.

PythonRust

(self) -> str

noether::homalg::PresentedModuleHomomorphism::to_json · Direct Rust declaration

pub fn to_json(&self) -> Result<String, NoetherError>where R: Serialize, R::Element: Serialize,

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: validation/unit/category/test_category.py:14 · validation/unit/category/test_category.py:15 · validation/unit/combin/test_acceptance_workload.py:30 · validation/unit/combin/test_acceptance_workload.py:65 · validation/unit/combin/test_acceptance_workload.py:86 · validation/unit/combin/test_graph_facade.py:106

homalg.PresentedModuleHomomorphism.verify

Replay and verify the mathematical evidence carried by this PresentedModuleHomomorphism.

Detailed contract

Recheck the exact commuting-square certificate.

PythonRust

(self) -> None

noether::homalg::PresentedModuleHomomorphism::verify · Direct Rust declaration

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

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: examples/01_bezout_certificates.py:10 · examples/01_bezout_certificates.py:3 · examples/03_exact_linear_systems.py:13 · examples/03_exact_linear_systems.py:3 · examples/04_smith_normal_form.py:12 · examples/06_shortest_lattice_vectors.py:12

homalg.PresentedModuleHomomorphism.zero

Construct a PresentedModuleHomomorphism using zero.

Detailed contract

Zero map, with sparse zero lifts on generators and relations.

PythonRust

(cls, source: PresentedModule[_BasicModuleRing], target: PresentedModule[_BasicModuleRing]) -> PresentedModuleHomomorphism[_BasicModuleRing]

noether::homalg::PresentedModuleHomomorphism::zero · Direct Rust declaration

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

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	attached / bounded
Semantic ID	noether/homalg/PresentedModuleHomomorphism@1

Executable usage: examples/08_finite_field_extensions.py:11 · examples/10_padic_hensel_lifting.py:15 · examples/40_exterior_algebra.py:26 · examples/distributed/f2_linear_algebra.py:28 · examples/distributed/f2_linear_algebra.py:29 · examples/distributed/f2_linear_algebra.py:30