homalg · PresentedModule¶

26 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.PresentedModule`¶

A finitely presented module retaining an exact cokernel presentation.

PythonRust

PresentedModule(presentation: ModuleHomomorphism[_BasicModuleRing])

noether::homalg::PresentedModule · Direct Rust declaration

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

Executable usage: examples/30_modules_and_resolutions.py:12 · examples/30_modules_and_resolutions.py:35 · validation/unit/commalg/test_construction_algebras.py:14 · validation/unit/commalg/test_construction_algebras.py:27 · validation/unit/commalg/test_polynomial_ideal_facade.py:36 · validation/unit/commalg/test_polynomial_ideal_facade.py:573

`homalg.PresentedModule.annihilator`¶

Compute annihilator for this PresentedModule.

Detailed contract

Annihilator ideal of this finitely presented module. The implementation intersects the exact kernels of the maps R -> M sending 1 to each retained presentation generator, then independently checks that every returned ideal generator kills every module generator modulo the presentation relations.

PythonRust

(self: PresentedModule[_FieldModuleRing], order: ModuleMonomialOrder) -> Ideal[_FieldModuleRing]

noether::homalg::PresentedModule::annihilator · Direct Rust declaration

pub fn annihilator( &self, order: ModuleMonomialOrder, ) -> Result<Ideal<PolynomialRing<C>>, ModuleInvariantError>

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

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:574 · validation/unit/commalg/test_polynomial_ideal_facade.py:575 · validation/unit/commalg/test_polynomial_ideal_facade.py:576 · validation/unit/commalg/test_polynomial_ideal_facade.py:589 · validation/unit/commalg/test_polynomial_ideal_facade.py:590 · validation/unit/homalg/test_module_facade.py:463

`homalg.PresentedModule.associated_primes`¶

Compute associated primes for this PresentedModule.

Detailed contract

Compute all associated primes from verified EHV Ext-annihilator evidence.

PythonRust

(self: PresentedModule[PolynomialRing[RationalField]]) -> ModuleAssociatedPrimeSet[RationalField]
(self: PresentedModule[PolynomialRing[FiniteField]]) -> ModuleAssociatedPrimeSet[FiniteField]

noether::homalg::PresentedModule::associated_primes · Direct Rust declaration

pub fn associated_primes( &self, ) -> Result<ModuleAssociatedPrimeSet<RationalField>, AssociatedPrimeError>
pub fn associated_primes( &self, ) -> Result<ModuleAssociatedPrimeSet<FiniteField>, AssociatedPrimeError>

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

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:1271 · validation/unit/commalg/test_polynomial_ideal_facade.py:566 · validation/unit/commalg/test_polynomial_ideal_facade.py:577 · validation/unit/commalg/test_polynomial_ideal_facade.py:623 · validation/unit/commalg/test_polynomial_ideal_facade.py:654 · validation/unit/commalg/test_polynomial_ideal_facade.py:694

`homalg.PresentedModule.ext`¶

Compute ext for this PresentedModule.

Detailed contract

Compute Ext^degree(self, target) from a verified resolution through the required look-ahead degree. Compute Ext^degree(self, target) through the required explicit quotient-resolution look-ahead degree.

PythonRust

(self: PresentedModule[_GroebnerModuleRing], target: PresentedModule[_GroebnerModuleRing], degree: int, order: ModuleMonomialOrder) -> DerivedModule[_GroebnerModuleRing]

noether::homalg::PresentedModule::ext · Direct Rust declaration

pub fn ext( &self, target: &Self, degree: usize, order: ModuleMonomialOrder, ) -> Result<DerivedModule<PolynomialRing<C>>, DerivedError>
pub fn ext( &self, target: &Self, degree: usize, order: ModuleMonomialOrder, ) -> Result<DerivedModule<QuotientRing<PolynomialRing<C>>>, DerivedError>

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

Executable usage: validation/unit/homalg/test_module_facade.py:353 · validation/unit/homalg/test_module_facade.py:372 · validation/unit/homalg/test_module_facade.py:374 · validation/unit/homalg/test_module_facade.py:431 · validation/unit/infra/test_discovery.py:106 · validation/unit/infra/test_discovery.py:111

`homalg.PresentedModule.exterior_power`¶

Compute exterior power for this PresentedModule.

Detailed contract

Construct the degree-degree exterior power presentation.

PythonRust

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

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

pub fn exterior_power( &self, degree: usize, ) -> Result<PresentedModulePower<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/PresentedModule@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.PresentedModule.fitting_ideal`¶

Compute fitting ideal for this PresentedModule.

Detailed contract

The index-th Fitting ideal of this finite presentation. For a presentation R^m -> R^n -> M, this is generated by the (n-index)-minors. The standard conventions are retained: sizes above the matrix shape give the zero ideal, while index >= n gives the unit ideal. The result is canonicalized by the owning polynomial ring.

PythonRust

(self: PresentedModule[_FieldModuleRing], index: int) -> Ideal[_FieldModuleRing]

noether::homalg::PresentedModule::fitting_ideal · Direct Rust declaration

pub fn fitting_ideal( &self, index: usize, ) -> Result<Ideal<PolynomialRing<C>>, ModuleInvariantError>

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

Executable usage: validation/unit/homalg/test_module_facade.py:464 · validation/unit/homalg/test_module_facade.py:465 · validation/unit/homalg/test_module_facade.py:466 · validation/unit/homalg/test_module_facade.py:471 · validation/bench/macaulay2_derived.py:425 · validation/corpus/homalg/persistence-exterior-square.py:43

`homalg.PresentedModule.free_resolution`¶

Compute free resolution for this PresentedModule.

Detailed contract

Compute a complete verified Schreyer free resolution.

PythonRust

(self: PresentedModule[_FieldModuleRing], order: ModuleMonomialOrder) -> FreeResolution[_FieldModuleRing]

noether::homalg::PresentedModule::free_resolution · Direct Rust declaration

pub fn free_resolution( &self, order: ModuleMonomialOrder, ) -> Result<FreeResolution<PolynomialRing<C>>, ResolutionError>

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

Executable usage: validation/unit/homalg/test_module_facade.py:351 · validation/unit/homalg/test_module_facade.py:795 · validation/unit/infra/test_discovery.py:107

`homalg.PresentedModule.free_resolution_through`¶

Compute free resolution through for this PresentedModule.

Detailed contract

Compute a verified resolution through one homological degree. Exactness is asserted only below the last displayed free module unless Schreyer iteration proves that the resolution already terminates. Compute a verified free resolution through one homological degree. Polynomial quotients need not have finite global dimension, so this operation never promises termination merely from the ambient number of variables. It records a complete result only when the final displayed differential has zero kernel; otherwise its truncation boundary is explicit.

PythonRust

(self: PresentedModule[_GroebnerModuleRing], order: ModuleMonomialOrder, degree: int) -> FreeResolution[_GroebnerModuleRing]

noether::homalg::PresentedModule::free_resolution_through · Direct Rust declaration

pub fn free_resolution_through( &self, order: ModuleMonomialOrder, degree: usize, ) -> Result<FreeResolution<PolynomialRing<C>>, ResolutionError>
pub fn free_resolution_through( &self, order: ModuleMonomialOrder, degree: usize, ) -> Result<FreeResolution<QuotientRing<PolynomialRing<C>>>, ResolutionError>

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

Executable usage: validation/unit/homalg/test_module_facade.py:403 · validation/unit/homalg/test_module_facade.py:419 · validation/unit/homalg/test_module_facade.py:866

`homalg.PresentedModule.from_json`¶

Deserialize and revalidate a PresentedModule from typed JSON.

Detailed contract

Deserialize and revalidate a presented module.

PythonRust

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

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

Return the generator count recorded by this PresentedModule.

Detailed contract

Number of presentation generators.

PythonRust

(self) -> int

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

Return the generator module recorded by this PresentedModule.

Detailed contract

Based free module of retained quotient generators.

PythonRust

(self) -> FreeModule[_BasicModuleRing]

noether::homalg::PresentedModule::generator_module · Direct Rust declaration

pub fn generator_module(&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/PresentedModule@1

Executable usage: validation/unit/commalg/test_construction_algebras.py:26 · validation/unit/commalg/test_construction_algebras.py:30 · validation/unit/homalg/test_exterior_algebra.py:318 · validation/unit/homalg/test_exterior_algebra.py:322 · validation/unit/homalg/test_exterior_algebra.py:460 · validation/unit/homalg/test_exterior_algebra.py:461

`homalg.PresentedModule.graded_betti_table`¶

Compute graded betti table for this PresentedModule.

Detailed contract

Compute exact multigraded Betti numbers without retaining a free resolution or materializing its minimal differential matrices. Certified Schreyer frames are streamed one at a time. Each homogeneous differential is reduced modulo the irrelevant ideal, and the Betti multiplicities are the exact homology dimensions of those coefficient-field blocks.

PythonRust

(self: PresentedModule[_FieldModuleRing], order: ModuleMonomialOrder) -> GradedBettiTable

noether::homalg::PresentedModule::graded_betti_table · Direct Rust declaration

pub fn graded_betti_table( &self, order: ModuleMonomialOrder, ) -> Result<GradedBettiTable, GradedBettiTableError>

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

Executable usage: examples/30_modules_and_resolutions.py:44 · validation/unit/homalg/test_module_facade.py:825 · validation/unit/homalg/test_module_facade.py:850 · validation/unit/homalg/test_module_facade.py:862 · validation/unit/homalg/test_module_facade.py:874 · validation/bench/macaulay2_core.py:1262

`homalg.PresentedModule.graded_invariants`¶

Compute graded invariants for this PresentedModule.

Detailed contract

Compute the standard-graded projective dimension, regularity, depth, dimension, Cohen–Macaulay predicate, and perfect predicate with one shared exact evidence object.

PythonRust

(self: PresentedModule[_FieldModuleRing], order: ModuleMonomialOrder) -> GradedModuleInvariants[_FieldModuleRing]

noether::homalg::PresentedModule::graded_invariants · Direct Rust declaration

pub fn graded_invariants( &self, order: ModuleMonomialOrder, ) -> Result<GradedModuleInvariants<C>, ModuleInvariantError>

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

Executable usage: validation/unit/homalg/test_module_facade.py:495 · validation/bench/macaulay2_derived.py:428

`homalg.PresentedModule.hom`¶

Compute hom for this PresentedModule.

Detailed contract

Canonical presented module Hom(self, target). Use Self::hom_inclusion when the explicit inclusion certificate is required by a larger functorial construction. Canonical presented module Hom(self, target) over a polynomial quotient.

PythonRust

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

noether::homalg::PresentedModule::hom · Direct Rust declaration

pub fn hom( &self, target: &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/PresentedModule@1

Executable usage: validation/unit/homalg/test_module_facade.py:348 · validation/unit/infra/test_discovery.py:104 · validation/bench/macaulay2_derived.py:132 · validation/bench/macaulay2_derived.py:159 · validation/bench/macaulay2_derived.py:269 · validation/bench/macaulay2_derived.py:423

`homalg.PresentedModule.hom_inclusion`¶

Compute hom inclusion for this PresentedModule.

Detailed contract

Exact inclusion of Hom(self, target) into Hom(F_0, target). The source is the canonical retained presentation of the Hom module; the inclusion and its relation lift are replayable kernel evidence. Exact inclusion of Hom(self, target) over a polynomial quotient into Hom(F_0, target).

PythonRust

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

noether::homalg::PresentedModule::hom_inclusion · Direct Rust declaration

pub fn hom_inclusion( &self, target: &Self, order: ModuleMonomialOrder, ) -> Result<PresentedModuleHomomorphism<PolynomialRing<C>>, ModuleGroebnerError>
pub fn hom_inclusion( &self, target: &Self, order: ModuleMonomialOrder, ) -> Result<PresentedModuleHomomorphism<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/PresentedModule@1

Executable usage: validation/unit/homalg/test_module_facade.py:343 · validation/unit/homalg/test_module_facade.py:344 · validation/unit/homalg/test_module_facade.py:345 · validation/unit/homalg/test_module_facade.py:346 · validation/unit/homalg/test_module_facade.py:347 · validation/unit/homalg/test_module_facade.py:348

`homalg.PresentedModule.minimal_free_resolution`¶

Compute and certify the complete minimal graded free resolution.

Detailed contract

Compute and verify a complete minimal graded free resolution.

PythonRust

(self: PresentedModule[_FieldModuleRing], order: ModuleMonomialOrder) -> FreeResolution[_FieldModuleRing]

noether::homalg::PresentedModule::minimal_free_resolution · Direct Rust declaration

pub fn minimal_free_resolution( &self, order: ModuleMonomialOrder, ) -> Result<FreeResolution<PolynomialRing<C>>, ResolutionError>

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

Executable usage: examples/30_modules_and_resolutions.py:42 · validation/unit/homalg/test_module_facade.py:828 · validation/unit/infra/test_discovery.py:108 · validation/unit/infra/test_public_api_index.py:183 · validation/bench/macaulay2_core.py:1255 · validation/bench/magma_release.py:1670

`homalg.PresentedModule.minimal_free_resolution_through`¶

Compute minimal free resolution through for this PresentedModule.

Detailed contract

Compute and minimalize a verified resolution through one homological degree. Minimality of the last retained free module is witnessed by computing one additional differential before unit cancellation, then discarding that look-ahead map. This prevents a redundant last generator from surviving merely because its cancelling unit lies just beyond the requested truncation.

PythonRust

(self: PresentedModule[_FieldModuleRing], order: ModuleMonomialOrder, degree: int) -> FreeResolution[_FieldModuleRing]

noether::homalg::PresentedModule::minimal_free_resolution_through · Direct Rust declaration

pub fn minimal_free_resolution_through( &self, order: ModuleMonomialOrder, degree: usize, ) -> Result<FreeResolution<PolynomialRing<C>>, ResolutionError>

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

Executable usage: validation/unit/homalg/test_module_facade.py:872 · validation/unit/infra/test_macaulay2_benchmark_protocol.py:504 · validation/bench/macaulay2_core.py:1258

`homalg.PresentedModule.presentation`¶

Return the presentation recorded by this PresentedModule.

Detailed contract

Relation map whose cokernel defines this module.

PythonRust

(self) -> ModuleHomomorphism[_BasicModuleRing]

noether::homalg::PresentedModule::presentation · Direct Rust declaration

pub fn presentation(&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/PresentedModule@1

Executable usage: examples/34_finite_group_cohomology.py:3 · validation/unit/category/test_category.py:70 · validation/unit/category/test_category.py:71 · validation/unit/category/test_category.py:72 · validation/unit/commalg/test_graded_commutative_facade.py:24 · validation/unit/commalg/test_graded_commutative_facade.py:25

`homalg.PresentedModule.primary_decomposition`¶

Compute primary decomposition for this PresentedModule.

Detailed contract

Compute a verified primary decomposition of the zero submodule.

PythonRust

(self: PresentedModule[PolynomialRing[RationalField]]) -> ModulePrimaryDecomposition[RationalField]
(self: PresentedModule[PolynomialRing[FiniteField]]) -> ModulePrimaryDecomposition[FiniteField]

noether::homalg::PresentedModule::primary_decomposition · Direct Rust declaration

pub fn primary_decomposition( &self, ) -> Result<ModulePrimaryDecomposition<RationalField>, ModulePrimaryDecompositionError>
pub fn primary_decomposition( &self, ) -> Result<ModulePrimaryDecomposition<FiniteField>, ModulePrimaryDecompositionError>

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

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:1017 · validation/unit/commalg/test_polynomial_ideal_facade.py:1087 · validation/unit/commalg/test_polynomial_ideal_facade.py:1254 · validation/unit/commalg/test_polynomial_ideal_facade.py:1266 · validation/unit/commalg/test_polynomial_ideal_facade.py:1287 · validation/unit/commalg/test_polynomial_ideal_facade.py:593

`homalg.PresentedModule.relation_count`¶

Return the relation count recorded by this PresentedModule.

Detailed contract

Number of retained presentation relations.

PythonRust

(self) -> int

noether::homalg::PresentedModule::relation_count · Direct Rust declaration

pub fn relation_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/PresentedModule@1

Executable usage: validation/unit/commalg/test_kahler_differentials.py:37 · validation/unit/commalg/test_kahler_differentials.py:61 · validation/unit/homalg/test_module_facade.py:275 · validation/unit/homalg/test_module_facade.py:302 · validation/unit/homalg/test_module_facade.py:340 · validation/unit/homalg/test_module_powers.py:105

`homalg.PresentedModule.relation_module`¶

Return the relation module recorded by this PresentedModule.

Detailed contract

Based free module indexing retained relations.

PythonRust

(self) -> FreeModule[_BasicModuleRing]

noether::homalg::PresentedModule::relation_module · Direct Rust declaration

pub fn relation_module(&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/PresentedModule@1

Executable usage: validation/unit/commalg/test_construction_algebras.py:25 · validation/unit/commalg/test_construction_algebras.py:29 · validation/unit/homalg/test_exterior_algebra.py:317 · validation/unit/homalg/test_exterior_algebra.py:321 · validation/unit/homalg/test_exterior_algebra.py:467 · validation/bench/macaulay2_derived.py:536

`homalg.PresentedModule.symmetric_algebra`¶

Compute symmetric algebra for this PresentedModule.

Detailed contract

Construct this module’s symmetric algebra.

PythonRust

(self: PresentedModule[PolynomialRing[RationalField]]) -> SymmetricAlgebra[RationalField]
(self: PresentedModule[PolynomialRing[FiniteField]]) -> SymmetricAlgebra[FiniteField]

noether::homalg::PresentedModule::symmetric_algebra · Direct Rust declaration

pub fn symmetric_algebra( &self, ) -> Result<SymmetricAlgebra<R>, ConstructionAlgebraError>

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

Executable usage: validation/unit/commalg/test_construction_algebras.py:35

`homalg.PresentedModule.symmetric_power`¶

Compute symmetric power for this PresentedModule.

Detailed contract

Construct the degree-degree symmetric power presentation.

PythonRust

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

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

pub fn symmetric_power( &self, degree: usize, ) -> Result<PresentedModulePower<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/PresentedModule@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.PresentedModule.tensor`¶

Compute tensor for this PresentedModule.

Detailed contract

Tensor product of two finite presentations over one commutative ring. If self = coker(P) and rhs = coker(Q), the retained presentation is coker([P tensor id, id tensor Q]). Thus the construction is coefficient-generic and records both families of bilinearity relations explicitly; it does not require a Groebner basis or choose new quotient generators.

PythonRust

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

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

Serialize this PresentedModule to its canonical typed JSON representation.

Detailed contract

Serialize the exact retained cokernel presentation.

PythonRust

(self) -> str

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

Compute tor for this PresentedModule.

Detailed contract

Compute Tor_degree(self, rhs) from a verified resolution through the required look-ahead degree. Compute Tor_degree(self, rhs) through the required explicit quotient-resolution look-ahead degree.

PythonRust

(self: PresentedModule[_GroebnerModuleRing], rhs: PresentedModule[_GroebnerModuleRing], degree: int, order: ModuleMonomialOrder) -> DerivedModule[_GroebnerModuleRing]

noether::homalg::PresentedModule::tor · Direct Rust declaration

pub fn tor( &self, rhs: &Self, degree: usize, order: ModuleMonomialOrder, ) -> Result<DerivedModule<PolynomialRing<C>>, DerivedError>
pub fn tor( &self, rhs: &Self, degree: usize, order: ModuleMonomialOrder, ) -> Result<DerivedModule<QuotientRing<PolynomialRing<C>>>, DerivedError>

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

Executable usage: validation/unit/homalg/test_module_facade.py:353 · validation/unit/homalg/test_module_facade.py:371 · validation/unit/homalg/test_module_facade.py:373 · validation/unit/homalg/test_module_facade.py:390 · validation/unit/homalg/test_module_facade.py:399 · validation/unit/homalg/test_module_facade.py:405

homalg · PresentedModule¶

Worked example¶

homalg.PresentedModule¶

homalg.PresentedModule.annihilator¶

homalg.PresentedModule.associated_primes¶

homalg.PresentedModule.ext¶

homalg.PresentedModule.exterior_power¶

homalg.PresentedModule.fitting_ideal¶

homalg.PresentedModule.free_resolution¶

homalg.PresentedModule.free_resolution_through¶

homalg.PresentedModule.from_json¶

homalg.PresentedModule.generator_count¶

homalg.PresentedModule.generator_module¶

homalg.PresentedModule.graded_betti_table¶

homalg.PresentedModule.graded_invariants¶

homalg.PresentedModule.hom¶

homalg.PresentedModule.hom_inclusion¶

homalg.PresentedModule.minimal_free_resolution¶

homalg.PresentedModule.minimal_free_resolution_through¶

homalg.PresentedModule.presentation¶

homalg.PresentedModule.primary_decomposition¶

homalg.PresentedModule.relation_count¶

homalg.PresentedModule.relation_module¶

homalg.PresentedModule.symmetric_algebra¶

homalg.PresentedModule.symmetric_power¶

homalg.PresentedModule.tensor¶

homalg.PresentedModule.to_json¶

homalg.PresentedModule.tor¶

`homalg.PresentedModule`¶

`homalg.PresentedModule.annihilator`¶

`homalg.PresentedModule.associated_primes`¶

`homalg.PresentedModule.ext`¶

`homalg.PresentedModule.exterior_power`¶

`homalg.PresentedModule.fitting_ideal`¶

`homalg.PresentedModule.free_resolution`¶

`homalg.PresentedModule.free_resolution_through`¶

`homalg.PresentedModule.from_json`¶

`homalg.PresentedModule.generator_count`¶

`homalg.PresentedModule.generator_module`¶

`homalg.PresentedModule.graded_betti_table`¶

`homalg.PresentedModule.graded_invariants`¶

`homalg.PresentedModule.hom`¶

`homalg.PresentedModule.hom_inclusion`¶

`homalg.PresentedModule.minimal_free_resolution`¶

`homalg.PresentedModule.minimal_free_resolution_through`¶

`homalg.PresentedModule.presentation`¶

`homalg.PresentedModule.primary_decomposition`¶

`homalg.PresentedModule.relation_count`¶

`homalg.PresentedModule.relation_module`¶

`homalg.PresentedModule.symmetric_algebra`¶

`homalg.PresentedModule.symmetric_power`¶

`homalg.PresentedModule.tensor`¶

`homalg.PresentedModule.to_json`¶

`homalg.PresentedModule.tor`¶