commalg · GradedCommutativePresentation

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

Worked example

The complete checked program Reproduce Fisher's order-five elliptic-function normalization uses this API directly.

# SPDX-License-Identifier: MIT
# Copyright (c) 2026 Benjamin Antieau and Deven Manam
"""Reproduce Fisher's order-five elliptic-function normalization."""

from noether import Q
from noether.commalg import RationalFunctionField, WeilDivisor
from noether.numthy import EllipticCurve, NthPowerClassGroup


def main() -> None:
    coefficients = RationalFunctionField(Q, "lambda")
    parameter = coefficients.generator()
    curve = EllipticCurve(
        coefficients,
        [1 - parameter, -parameter, -parameter, 0, 0],
    )
    point = curve.point(0, 0)
    point.verify_exact_order(5)

    miller = curve.miller_function(point, 5)
    divisor = WeilDivisor(
        curve.underlying_curve,
        [
            (curve.origin().underlying_curve_point.as_closed_point(), 5),
            (point.underlying_curve_point.as_closed_point(), -5),
        ],
    )
    function = divisor.riemann_roch_space().basis[0]
    assert (function / miller.function).as_constant() is not None

    evaluation_at_two = function.evaluate_at((2 * point).underlying_curve_point)
    evaluation_at_four = function.evaluate_at((4 * point).underlying_curve_point)
    assert evaluation_at_two.value is not None
    assert evaluation_at_four.value is not None
    classes = NthPowerClassGroup(coefficients, 5)
    normalization = classes.class_of(evaluation_at_two.value) ** -2 * classes.class_of(
        evaluation_at_four.value
    )
    assert normalization.is_identity()
    print("order 5 verified; Riemann--Roch and Miller agree; normalization is trivial")


if __name__ == "__main__":
    main()

Run it with .venv/bin/python examples/26_elliptic_descent_functions.py.

commalg.GradedCommutativePresentation

A homogeneous quotient presentation with exact degreewise normal forms.

PythonRust

GradedCommutativePresentation(ring: GradedCommutativePolynomialRing, relations: Sequence[GradedCommutativePolynomial])

noether::commalg::GradedCommutativePresentation · Direct Rust declaration

pub struct GradedCommutativePresentation { /* private fields */ }

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL	attached / bounded
Semantic ID	noether/commalg/GradedCommutativePresentation@1

Executable usage: validation/unit/commalg/test_graded_commutative_facade.py:24 · validation/unit/commalg/test_graded_commutative_facade.py:29 · validation/unit/commalg/test_graded_commutative_facade.py:7

commalg.GradedCommutativePresentation.basis

Compute basis for this GradedCommutativePresentation.

Detailed contract

Canonical monomial basis of the quotient in one degree.

PythonRust

(self, degree: int) -> list[GradedMonomial]

noether::commalg::GradedCommutativePresentation::basis · Direct Rust declaration

pub fn basis( &self, degree: u32, ) -> Result<Vec<GradedMonomial>, GradedCommutativeError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL	attached / bounded
Semantic ID	noether/commalg/GradedCommutativePresentation@1

Executable usage: examples/26_elliptic_descent_functions.py:28 · examples/30_modules_and_resolutions.py:27 · examples/30_modules_and_resolutions.py:28 · examples/30_modules_and_resolutions.py:29 · examples/33_simplicial_cohomology_operations.py:26 · examples/33_simplicial_cohomology_operations.py:27

commalg.GradedCommutativePresentation.dimension

Compute dimension for this GradedCommutativePresentation.

Detailed contract

Exact vector-space dimension of the quotient in one degree.

PythonRust

(self, degree: int) -> int

noether::commalg::GradedCommutativePresentation::dimension · Direct Rust declaration

pub fn dimension(&self, degree: u32) -> Result<usize, GradedCommutativeError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL	attached / bounded
Semantic ID	noether/commalg/GradedCommutativePresentation@1

Executable usage: examples/03_exact_linear_systems.py:15 · examples/03_exact_linear_systems.py:16 · examples/15_groebner_twisted_cubic.py:14 · examples/15_groebner_twisted_cubic.py:28 · examples/27_weight_characters.py:25 · examples/34_finite_group_cohomology.py:13

commalg.GradedCommutativePresentation.from_json

Deserialize and revalidate a GradedCommutativePresentation from typed JSON.

Detailed contract

Deserialize and revalidate a presentation.

PythonRust

(cls, value: str) -> GradedCommutativePresentation

noether::commalg::GradedCommutativePresentation::from_json · Direct Rust declaration

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

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL	attached / bounded
Semantic ID	noether/commalg/GradedCommutativePresentation@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

commalg.GradedCommutativePresentation.hilbert_function

Compute hilbert function for this GradedCommutativePresentation.

Detailed contract

Hilbert function in degrees 0,...,through_degree.

PythonRust

(self, through_degree: int) -> list[int]

noether::commalg::GradedCommutativePresentation::hilbert_function · Direct Rust declaration

pub fn hilbert_function( &self, through_degree: u32, ) -> Result<Vec<usize>, GradedCommutativeError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL	attached / bounded
Semantic ID	noether/commalg/GradedCommutativePresentation@1

Executable usage: validation/unit/commalg/test_graded_commutative_facade.py:25 · validation/unit/homalg/test_finite_group_cohomology.py:162 · validation/unit/homalg/test_finite_group_cohomology.py:174 · validation/unit/homalg/test_finite_group_cohomology.py:42 · validation/unit/topology/test_eilenberg_maclane.py:166 · validation/unit/topology/test_simplicial_complex_facade.py:199

commalg.GradedCommutativePresentation.normal_form

Compute normal form for this GradedCommutativePresentation.

Detailed contract

Canonical degreewise normal form modulo the homogeneous relation ideal.

PythonRust

(self, value: GradedCommutativePolynomial) -> GradedCommutativePolynomial

noether::commalg::GradedCommutativePresentation::normal_form · Direct Rust declaration

pub fn normal_form( &self, value: &GradedCommutativePolynomial, ) -> Result<GradedCommutativePolynomial, GradedCommutativeError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL	attached / bounded
Semantic ID	noether/commalg/GradedCommutativePresentation@1

Executable usage: validation/unit/commalg/test_graded_commutative_facade.py:26 · validation/unit/commalg/test_integer_groebner_facade.py:17 · validation/unit/commalg/test_polynomial_ideal_facade.py:194 · validation/unit/commalg/test_polynomial_ideal_facade.py:409 · validation/unit/commalg/test_polynomial_ideal_facade.py:441 · validation/unit/commalg/test_polynomial_ideal_facade.py:52

commalg.GradedCommutativePresentation.relations

Return the relations recorded by this GradedCommutativePresentation.

Detailed contract

Canonically normalized homogeneous relation family.

PythonRust

(self) -> list[GradedCommutativePolynomial]

noether::commalg::GradedCommutativePresentation::relations · Direct Rust declaration

pub fn relations(&self) -> &[GradedCommutativePolynomial]

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL	attached / bounded
Semantic ID	noether/commalg/GradedCommutativePresentation@1

Executable usage: validation/unit/combinatorics/test_partition_types.py:63 · validation/unit/combinatorics/test_partition_types.py:68 · validation/unit/combinatorics/test_partition_types.py:72 · validation/unit/homalg/test_exterior_algebra.py:263 · validation/unit/homalg/test_exterior_algebra.py:267 · validation/unit/homalg/test_exterior_algebra.py:456

commalg.GradedCommutativePresentation.ring

Return the ring recorded by this GradedCommutativePresentation.

Detailed contract

Ambient free graded-commutative algebra.

PythonRust

(self) -> GradedCommutativePolynomialRing

noether::commalg::GradedCommutativePresentation::ring · Direct Rust declaration

pub fn ring(&self) -> &GradedCommutativePolynomialRing

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL	attached / bounded
Semantic ID	noether/commalg/GradedCommutativePresentation@1

Executable usage: examples/11_qadic_witt_vectors.py:3 · examples/13_chinese_remainder_theorem.py:10 · examples/13_chinese_remainder_theorem.py:12 · examples/13_chinese_remainder_theorem.py:9 · examples/14_weighted_polynomials.py:10 · examples/14_weighted_polynomials.py:11

commalg.GradedCommutativePresentation.to_json

Serialize this GradedCommutativePresentation to its canonical typed JSON representation.

Detailed contract

Serialize the exact presentation.

PythonRust

(self) -> str

noether::commalg::GradedCommutativePresentation::to_json · Direct Rust declaration

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

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL	attached / bounded
Semantic ID	noether/commalg/GradedCommutativePresentation@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

commalg.GradedCommutativePresentation.verify

Replay and verify the mathematical evidence carried by this GradedCommutativePresentation.

Detailed contract

Reconstruct and verify the normalized presentation.

PythonRust

(self) -> None

noether::commalg::GradedCommutativePresentation::verify · Direct Rust declaration

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

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL	attached / bounded
Semantic ID	noether/commalg/GradedCommutativePresentation@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