homalg · Submodule¶

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

Worked example¶

The complete checked program Reduce a module element and certify a minimal free resolution uses this API directly.

# SPDX-License-Identifier: MIT
# Copyright (c) 2026 Benjamin Antieau and Deven Manam
"""Reduce a module element and certify a minimal free resolution."""

from noether import Q
from noether.commalg import Degree, MonomialOrder, PolynomialRing
from noether.homalg import (
    FreeModule,
    ModuleElement,
    ModuleHomomorphism,
    ModuleMonomialOrder,
    PresentedModule,
    Submodule,
)
from noether.linalg import Matrix, Vector


def main() -> None:
    ring = PolynomialRing(Q, ["x", "y", "z", "w"])
    x, y, z, w = ring.generators()
    order = ModuleMonomialOrder.term_over_position(MonomialOrder.GREVLEX)

    ambient = FreeModule(ring, 2)
    first = ModuleElement(ambient, Vector.from_values(ring, [x, y]))
    second = ModuleElement(ambient, Vector.from_values(ring, [y, 1]))
    submodule = Submodule.from_generators(ambient, [first, second])
    basis = submodule.groebner_basis(order)
    reduction = basis.reduce(first + second * x)
    basis.verify()
    reduction.verify()
    assert reduction.is_member()

    target = FreeModule(ring, 1, grading_rank=1, degree_shifts=[Degree([0])])
    source = FreeModule(ring, 3, grading_rank=1, degree_shifts=[Degree([-2])] * 3)
    twisted_cubic = PresentedModule(
        ModuleHomomorphism(
            source,
            target,
            Matrix.from_rows(ring, [[x * z - y**2, x * w - y * z, y * w - z**2]]),
        )
    )
    resolution = twisted_cubic.minimal_free_resolution(order)
    resolution.verify()
    betti = resolution.graded_betti_table()
    betti.verify()
    assert betti.entries == [
        (0, Degree([0]), 1),
        (1, Degree([2]), 3),
        (2, Degree([3]), 2),
    ]
    print(f"module member certified; minimal Betti entries={betti.entries}")


if __name__ == "__main__":
    main()

Run it with .venv/bin/python examples/30_modules_and_resolutions.py.

`homalg.Submodule`¶

A finitely generated submodule of one based free module.

PythonRust

Submodule(ambient: FreeModule[_BasicModuleRing], generator_map: ModuleHomomorphism[_BasicModuleRing])

noether::homalg::Submodule · Direct Rust declaration

pub struct Submodule<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/Submodule@1

Executable usage: examples/30_modules_and_resolutions.py:13 · examples/30_modules_and_resolutions.py:26 · examples/38_exact_linear_systems.py:56 · examples/38_exact_linear_systems.py:9 · validation/unit/homalg/test_exact_submodules.py:101 · validation/unit/homalg/test_exact_submodules.py:106

`homalg.Submodule.ambient`¶

Return the ambient recorded by this Submodule.

Detailed contract

Ambient based free module.

PythonRust

(self) -> FreeModule[_BasicModuleRing]

noether::homalg::Submodule::ambient · Direct Rust declaration

pub fn ambient(&self) -> &FreeModule<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/Submodule@1

Executable usage: examples/30_modules_and_resolutions.py:23 · examples/30_modules_and_resolutions.py:24 · examples/30_modules_and_resolutions.py:25 · examples/30_modules_and_resolutions.py:26 · examples/38_exact_linear_systems.py:49 · examples/38_exact_linear_systems.py:53

`homalg.Submodule.colon_by_element`¶

Compute colon by element for this Submodule.

Detailed contract

Exact module quotient self : scalar inside the ambient free module. This is the preimage of self under scalar multiplication. The kernel of [scalar * identity,-A] retains a complete witness for every relation scalar * u = Av; projecting to u gives the colon module.

PythonRust

(self: Submodule[PolynomialRing[RationalField]], scalar: Polynomial[RationalField], order: ModuleMonomialOrder) -> Submodule[PolynomialRing[RationalField]]
(self: Submodule[PolynomialRing[FiniteField]], scalar: Polynomial[FiniteField], order: ModuleMonomialOrder) -> Submodule[PolynomialRing[FiniteField]]

noether::homalg::Submodule::colon_by_element · Direct Rust declaration

pub fn colon_by_element( &self, scalar: &Polynomial<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	released
Semantic ID	noether/homalg/Submodule@1

Executable usage: validation/unit/homalg/test_module_facade.py:135 · validation/unit/infra/test_discovery.py:161

`homalg.Submodule.contains`¶

Decide exact membership.

Detailed contract

Decide exact membership in this integer submodule. Decide exact membership, including for composite moduli.

PythonRust

(self: Submodule[_ExactModuleRing], element: ModuleElement[_ExactModuleRing]) -> bool

noether::homalg::Submodule::contains · Direct Rust declaration

pub fn contains( &self, element: &ModuleElement<IntegerRing>, ) -> Result<bool, ModuleError>
pub fn contains( &self, element: &ModuleElement<ResidueRing>, ) -> Result<bool, 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/Submodule@1

Executable usage: examples/38_exact_linear_systems.py:73 · validation/unit/commalg/test_local_algebra.py:63 · validation/unit/commalg/test_prime_localization.py:50 · validation/unit/commalg/test_prime_localization.py:55 · validation/unit/groups/test_acceptance_workload.py:56 · validation/unit/groups/test_permutation_group_facade.py:81

`homalg.Submodule.finite_index`¶

Finite index, rejecting positive-free-rank integer quotients.

Detailed contract

Index in the ambient lattice, failing closed when the quotient is infinite. Finite cardinal index in the ambient residue module.

PythonRust

(self: Submodule[_ExactModuleRing]) -> int

noether::homalg::Submodule::finite_index · Direct Rust declaration

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

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/Submodule@1

Executable usage: examples/38_exact_linear_systems.py:57 · examples/38_exact_linear_systems.py:61 · validation/unit/homalg/test_exact_submodules.py:152 · validation/unit/homalg/test_exact_submodules.py:41 · validation/unit/homalg/test_exact_submodules.py:61 · validation/unit/homalg/test_exact_submodules.py:67

`homalg.Submodule.from_generators`¶

Construct a Submodule using generators.

Detailed contract

Construct a submodule from ordered ambient elements.

PythonRust

(cls, ambient: FreeModule[_BasicModuleRing], generators: Sequence[ModuleElement[_BasicModuleRing]]) -> Submodule[_BasicModuleRing]

noether::homalg::Submodule::from_generators · Direct Rust declaration

pub fn from_generators( ambient: FreeModule<R>, generators: Vec<ModuleElement<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	released
Semantic ID	noether/homalg/Submodule@1

Executable usage: examples/19_permutation_groups.py:9 · examples/20_conjugacy_classes.py:9 · examples/30_modules_and_resolutions.py:26 · examples/34_finite_group_cohomology.py:10 · examples/38_exact_linear_systems.py:56 · validation/unit/groups/test_acceptance_workload.py:122

`homalg.Submodule.from_json`¶

Deserialize and revalidate a Submodule from typed JSON.

Detailed contract

Deserialize and revalidate a generated submodule.

PythonRust

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

noether::homalg::Submodule::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/Submodule@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.Submodule.generator_count`¶

Return the generator count recorded by this Submodule.

Detailed contract

Number of retained ordered generators.

PythonRust

(self) -> int

noether::homalg::Submodule::generator_count · Direct Rust declaration

pub fn generator_count(&self) -> usize

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/Submodule@1

Executable usage: examples/38_exact_linear_systems.py:72 · validation/unit/commalg/test_kahler_differentials.py:119 · validation/unit/commalg/test_kahler_differentials.py:36 · validation/unit/commalg/test_kahler_differentials.py:60 · validation/unit/commalg/test_kahler_differentials.py:66 · validation/unit/homalg/test_exact_submodules.py:130

`homalg.Submodule.generator_map`¶

Return the generator map recorded by this Submodule.

Detailed contract

Ordered generator map whose image is this submodule.

PythonRust

(self) -> ModuleHomomorphism[_BasicModuleRing]

noether::homalg::Submodule::generator_map · Direct Rust declaration

pub fn generator_map(&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/Submodule@1

Executable usage: validation/unit/homalg/test_exact_submodules.py:43 · validation/unit/homalg/test_module_facade.py:255 · validation/unit/homalg/test_module_facade.py:368 · validation/unit/homalg/test_module_facade.py:528 · validation/unit/homalg/test_module_facade.py:532 · validation/unit/homalg/test_module_facade.py:582

`homalg.Submodule.generators`¶

Canonical generators for exact integer and residue submodules.

Detailed contract

Canonical ambient generators in column-Hermite convention. Canonical ambient generators in column-Howell convention.

PythonRust

(self: Submodule[_ExactModuleRing]) -> list[ModuleElement[_ExactModuleRing]]

noether::homalg::Submodule::generators · Direct Rust declaration

pub fn generators(&self) -> Vec<ModuleElement<IntegerRing>>
pub fn generators(&self) -> Vec<ModuleElement<ResidueRing>>

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/Submodule@1

Executable usage: examples/14_weighted_polynomials.py:11 · examples/15_groebner_twisted_cubic.py:11 · examples/15_groebner_twisted_cubic.py:19 · examples/17_weighted_power_series.py:15 · examples/18_finite_field_schemes.py:12 · examples/30_modules_and_resolutions.py:20

`homalg.Submodule.groebner_basis`¶

Compute groebner basis for this Submodule.

Detailed contract

Compute the complete canonical reduced module Groebner basis. Complete reduced module Groebner basis over a polynomial quotient. Internally this computes the preimage in the ambient polynomial free module after adjoining every defining-ideal relation I e_j. Returned generators and transformations live in the quotient context; ambient ideal relations that project to zero are not exposed as fake module generators.

PythonRust

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

noether::homalg::Submodule::groebner_basis · Direct Rust declaration

pub fn groebner_basis( &self, order: ModuleMonomialOrder, ) -> Result<ModuleGroebnerBasis<PolynomialRing<C>>, ModuleGroebnerError>
pub fn groebner_basis( &self, order: ModuleMonomialOrder, ) -> Result<ModuleGroebnerBasis<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/Submodule@1

Executable usage: examples/15_groebner_twisted_cubic.py:29 · examples/30_modules_and_resolutions.py:27 · validation/unit/commalg/test_groebner_verification_budget.py:53 · validation/unit/commalg/test_groebner_verification_budget.py:64 · validation/unit/commalg/test_polynomial_ideal_facade.py:49 · validation/unit/homalg/test_module_facade.py:256

`homalg.Submodule.groebner_basis_with_hilbert_series`¶

Compute groebner basis with hilbert series for this Submodule.

Detailed contract

Compute the complete canonical reduced basis using an exact Hilbert series as a construction-completion target. The input must be multihomogeneous in an explicitly shifted ambient module. A target match can discard remaining construction pairs, but the returned basis still passes the independent Buchberger and change-map verifier. A bad target fails closed after an ordinary retry.

PythonRust

(self: Submodule[_FieldModuleRing], order: ModuleMonomialOrder, target: HilbertSeries) -> ModuleGroebnerBasis[_FieldModuleRing]

noether::homalg::Submodule::groebner_basis_with_hilbert_series · Direct Rust declaration

pub fn groebner_basis_with_hilbert_series( &self, order: ModuleMonomialOrder, target: &HilbertSeries, ) -> Result<ModuleGroebnerBasis<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/Submodule@1

Executable usage: validation/unit/homalg/test_module_facade.py:266 · validation/unit/infra/test_discovery.py:102

`homalg.Submodule.intersection`¶

Compute intersection for this Submodule.

Detailed contract

Exact intersection inside the common ambient free abelian group. Exact intersection inside the common free Z/nZ-module. Exact intersection with another submodule of the same free module. The kernel of [A,-B] records every equality Au=Bv. Projecting its generators to u and applying A therefore generates precisely the intersection of the two images.

PythonRust

(self: Submodule[_ExactModuleRing], rhs: Submodule[_ExactModuleRing], order: None=None) -> Submodule[_ExactModuleRing]
(self: Submodule[_FieldModuleRing], rhs: Submodule[_FieldModuleRing], order: ModuleMonomialOrder) -> Submodule[_FieldModuleRing]

noether::homalg::Submodule::intersection · Direct Rust declaration

pub fn intersection(&self, rhs: &Self) -> Result<Self, ModuleError>
pub fn intersection( &self, rhs: &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/Submodule@1

Executable usage: examples/37_complete_intersection_theory.py:3 · examples/39_kahler_differentials.py:37 · validation/unit/commalg/test_intersection_theory.py:100 · validation/unit/commalg/test_intersection_theory.py:102 · validation/unit/commalg/test_intersection_theory.py:3 · validation/unit/commalg/test_monomial_ideal_facade.py:33

`homalg.Submodule.is_equal`¶

Test whether this Submodule is equal.

Detailed contract

Decide equality of generated submodules, independently of generators.

PythonRust

(self: Submodule[_ExactModuleRing], rhs: Submodule[_ExactModuleRing], order: None=None) -> bool
(self: Submodule[_FieldModuleRing], rhs: Submodule[_FieldModuleRing], order: ModuleMonomialOrder) -> bool

noether::homalg::Submodule::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/Submodule@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.Submodule.is_subset_of`¶

Test whether this Submodule is subset of.

Detailed contract

Decide inclusion using replayable membership computations on canonical generators. Decide inclusion, including over composite moduli. Decide exact containment in another submodule of the same free module.

PythonRust

(self: Submodule[_ExactModuleRing], rhs: Submodule[_ExactModuleRing], order: None=None) -> bool
(self: Submodule[_FieldModuleRing], rhs: Submodule[_FieldModuleRing], order: ModuleMonomialOrder) -> bool

noether::homalg::Submodule::is_subset_of · Direct Rust declaration

pub fn is_subset_of(&self, rhs: &Self) -> Result<bool, ModuleError>
pub fn is_subset_of( &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/Submodule@1

Executable usage: validation/unit/homalg/test_exact_submodules.py:63 · validation/unit/homalg/test_module_facade.py:117 · validation/unit/homalg/test_module_facade.py:118 · validation/unit/homalg/test_module_facade.py:119 · validation/bench/macaulay2_derived.py:560 · validation/bench/macaulay2_derived.py:602

`homalg.Submodule.membership_witness`¶

Return replayable coefficients exactly when membership holds.

Detailed contract

Return replayable generator coefficients exactly when membership holds.

PythonRust

(self: Submodule[_ExactModuleRing], element: ModuleElement[_ExactModuleRing]) -> SubmoduleMembership[_ExactModuleRing] | None

noether::homalg::Submodule::membership_witness · Direct Rust declaration

pub fn membership_witness( &self, element: &ModuleElement<IntegerRing>, ) -> Result<Option<SubmoduleMembership<IntegerRing>>, ModuleError>
pub fn membership_witness( &self, element: &ModuleElement<ResidueRing>, ) -> Result<Option<SubmoduleMembership<ResidueRing>>, 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/Submodule@1

Executable usage: examples/38_exact_linear_systems.py:58 · validation/unit/homalg/test_exact_submodules.py:153 · validation/unit/homalg/test_exact_submodules.py:47

`homalg.Submodule.minimal_homogeneous_generators`¶

Compute minimal homogeneous generators for this Submodule.

Detailed contract

Remove redundant homogeneous generators over a positively graded polynomial field. The returned generators are a deterministic subset of the nonzero input generators. Their image is either unchanged or independently checked to equal the original submodule. This operation requires explicit shifts on the ambient free module and a positive rank-one polynomial grading. Those hypotheses make a nonzero constant coefficient in a homogeneous relation a scalar unit, so exact field elimination detects precisely the redundant generators.

PythonRust

(self: Submodule[_FieldModuleRing]) -> Submodule[_FieldModuleRing]

noether::homalg::Submodule::minimal_homogeneous_generators · Direct Rust declaration

pub fn minimal_homogeneous_generators( &self, ) -> Result<Submodule<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/Submodule@1

Executable usage: validation/unit/homalg/test_module_facade.py:595 · validation/unit/homalg/test_module_facade.py:610 · validation/unit/infra/test_discovery.py:103 · validation/unit/infra/test_macaulay2_benchmark_protocol.py:556 · validation/unit/infra/test_macaulay2_benchmark_protocol.py:557 · validation/bench/macaulay2_core.py:1273

`homalg.Submodule.quotient`¶

Cokernel presentation of the ambient module modulo this submodule.

Detailed contract

Cokernel presentation Z^r / self retaining the canonical relation map. Cokernel presentation (Z/nZ)^r / self retaining canonical relations.

PythonRust

(self: Submodule[_ExactModuleRing]) -> PresentedModule[_ExactModuleRing]

noether::homalg::Submodule::quotient · Direct Rust declaration

pub fn quotient(&self) -> PresentedModule<IntegerRing>
pub fn quotient(&self) -> PresentedModule<ResidueRing>

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/Submodule@1

Executable usage: examples/15_groebner_twisted_cubic.py:24 · examples/15_groebner_twisted_cubic.py:25 · examples/39_kahler_differentials.py:13 · validation/unit/commalg/test_kahler_differentials.py:109 · validation/unit/commalg/test_kahler_differentials.py:128 · validation/unit/commalg/test_kahler_differentials.py:56

`homalg.Submodule.quotient_invariants`¶

Invariant factors of the ambient quotient as an abelian group.

Detailed contract

Canonical invariant factors of the underlying quotient abelian group. Canonical invariant factors of the quotient’s underlying finite abelian group.

PythonRust

(self: Submodule[_ExactModuleRing]) -> FinitelyGeneratedAbelianGroup

noether::homalg::Submodule::quotient_invariants · Direct Rust declaration

pub fn quotient_invariants(&self) -> FinitelyGeneratedAbelianGroup

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/Submodule@1

Executable usage: validation/unit/homalg/test_exact_submodules.py:42 · validation/parity/linalg/test_exact_solution_modules_parity.py:100 · validation/parity/linalg/test_exact_solution_modules_parity.py:104 · validation/parity/linalg/test_exact_solution_modules_parity.py:105 · validation/parity/linalg/test_exact_solution_modules_parity.py:234

`homalg.Submodule.saturate_by_element`¶

Compute saturate by element for this Submodule.

Detailed contract

Saturation self : scalar^infinity, stopping only at exact equality. Iterated colons form an ascending chain and therefore stabilize over the Noetherian polynomial ring. The implementation fails closed if the explicit native resource bound is reached before equality is proved.

PythonRust

(self: Submodule[PolynomialRing[RationalField]], scalar: Polynomial[RationalField], order: ModuleMonomialOrder) -> Submodule[PolynomialRing[RationalField]]
(self: Submodule[PolynomialRing[FiniteField]], scalar: Polynomial[FiniteField], order: ModuleMonomialOrder) -> Submodule[PolynomialRing[FiniteField]]

noether::homalg::Submodule::saturate_by_element · Direct Rust declaration

pub fn saturate_by_element( &self, scalar: &Polynomial<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	released
Semantic ID	noether/homalg/Submodule@1

Executable usage: validation/unit/homalg/test_module_facade.py:136 · validation/unit/infra/test_discovery.py:162

`homalg.Submodule.saturation`¶

Primitive closure inside the ambient integer lattice.

Detailed contract

Primitive closure (self tensor Q) intersect Z^r in canonical form.

PythonRust

(self: Submodule[IntegerRing]) -> Submodule[IntegerRing]

noether::homalg::Submodule::saturation · Direct Rust declaration

pub fn saturation(&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/Submodule@1

Executable usage: examples/38_exact_linear_systems.py:61 · validation/unit/homalg/test_exact_submodules.py:60 · validation/unit/homalg/test_exact_submodules.py:61 · validation/unit/homalg/test_exact_submodules.py:62 · validation/unit/homalg/test_exact_submodules.py:63 · validation/unit/infra/test_macaulay2_benchmark_protocol.py:883

`homalg.Submodule.strong_groebner_basis`¶

Compute strong groebner basis for this Submodule.

Detailed contract

Compute the complete normalized strong module Gröbner basis over Z.

PythonRust

(self: Submodule[_IntegralModuleRing], order: ModuleMonomialOrder) -> StrongModuleGroebnerBasis

noether::homalg::Submodule::strong_groebner_basis · Direct Rust declaration

pub fn strong_groebner_basis( &self, order: ModuleMonomialOrder, ) -> Result<StrongModuleGroebnerBasis, 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/Submodule@1

Executable usage: validation/unit/commalg/test_integer_groebner_facade.py:11 · validation/unit/homalg/test_module_facade.py:718 · validation/unit/homalg/test_module_facade.py:760 · validation/unit/infra/test_discovery.py:101 · validation/unit/infra/test_discovery.py:127 · validation/unit/infra/test_macaulay2_benchmark_protocol.py:602

`homalg.Submodule.sum`¶

Compute sum for this Submodule.

Detailed contract

Sum with another submodule of the same free module.

PythonRust

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

noether::homalg::Submodule::sum · Direct Rust declaration

pub fn sum(&self, rhs: &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/Submodule@1

Executable usage: examples/32_poset_core_and_morse.py:18 · validation/unit/combin/test_acceptance_workload.py:64 · validation/unit/combinatorics/test_boundary.py:31 · validation/unit/commalg/test_acceptance_workload.py:137 · validation/unit/commalg/test_monomial_ideal_facade.py:94 · validation/unit/commalg/test_polynomial_ideal_facade.py:334

`homalg.Submodule.to_json`¶

Serialize this Submodule to its canonical typed JSON representation.

Detailed contract

Serialize the exact generator map defining this image.

PythonRust

(self) -> str

noether::homalg::Submodule::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/Submodule@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.Submodule.verify`¶

Recheck the canonical integer/Howell generator form.

Detailed contract

Recheck the unique column-Hermite generator convention. Recheck the unique column-Howell generator convention.

PythonRust

(self: Submodule[_ExactModuleRing]) -> None

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

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

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/Submodule@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 · Submodule¶

Worked example¶

homalg.Submodule¶

homalg.Submodule.ambient¶

homalg.Submodule.colon_by_element¶

homalg.Submodule.contains¶

homalg.Submodule.finite_index¶

homalg.Submodule.from_generators¶

homalg.Submodule.from_json¶

homalg.Submodule.generator_count¶

homalg.Submodule.generator_map¶

homalg.Submodule.generators¶

homalg.Submodule.groebner_basis¶

homalg.Submodule.groebner_basis_with_hilbert_series¶

homalg.Submodule.intersection¶

homalg.Submodule.is_equal¶

homalg.Submodule.is_subset_of¶

homalg.Submodule.membership_witness¶

homalg.Submodule.minimal_homogeneous_generators¶

homalg.Submodule.quotient¶

homalg.Submodule.quotient_invariants¶

homalg.Submodule.saturate_by_element¶

homalg.Submodule.saturation¶

homalg.Submodule.strong_groebner_basis¶

homalg.Submodule.sum¶

homalg.Submodule.to_json¶

homalg.Submodule.verify¶

`homalg.Submodule`¶

`homalg.Submodule.ambient`¶

`homalg.Submodule.colon_by_element`¶

`homalg.Submodule.contains`¶

`homalg.Submodule.finite_index`¶

`homalg.Submodule.from_generators`¶

`homalg.Submodule.from_json`¶

`homalg.Submodule.generator_count`¶

`homalg.Submodule.generator_map`¶

`homalg.Submodule.generators`¶

`homalg.Submodule.groebner_basis`¶

`homalg.Submodule.groebner_basis_with_hilbert_series`¶

`homalg.Submodule.intersection`¶

`homalg.Submodule.is_equal`¶

`homalg.Submodule.is_subset_of`¶

`homalg.Submodule.membership_witness`¶

`homalg.Submodule.minimal_homogeneous_generators`¶

`homalg.Submodule.quotient`¶

`homalg.Submodule.quotient_invariants`¶

`homalg.Submodule.saturate_by_element`¶

`homalg.Submodule.saturation`¶

`homalg.Submodule.strong_groebner_basis`¶

`homalg.Submodule.sum`¶

`homalg.Submodule.to_json`¶

`homalg.Submodule.verify`¶