commalg · FiniteQuotientAlgebra

14 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.FiniteQuotientAlgebra

A verified standard-basis description of a finite-dimensional quotient.

PythonRust

class FiniteQuotientAlgebra

noether::commalg::FiniteQuotientAlgebra · Direct Rust declaration

pub struct FiniteQuotientAlgebra<R: Field> { /* 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/FiniteQuotientAlgebra@1

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:124 · validation/unit/commalg/test_polynomial_ideal_facade.py:148 · validation/unit/commalg/test_polynomial_ideal_facade.py:149 · validation/unit/commalg/test_polynomial_ideal_facade.py:19 · validation/unit/commalg/test_polynomial_ideal_facade.py:421 · validation/unit/commalg/test_polynomial_ideal_facade.py:449

commalg.FiniteQuotientAlgebra.basis

Canonically ordered standard-monomial basis.

Detailed contract

Canonically ordered standard-monomial vector-space basis.

PythonRust

(self) -> list[Polynomial[C]]

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

pub fn basis(&self) -> &[Polynomial<R>]

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/FiniteQuotientAlgebra@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.FiniteQuotientAlgebra.dimension

Vector-space dimension of the quotient.

Detailed contract

Vector-space dimension of this quotient algebra.

PythonRust

(self) -> int

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

pub fn dimension(&self) -> usize

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/FiniteQuotientAlgebra@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.FiniteQuotientAlgebra.from_json

Restore and exactly reverify a typed quotient algebra.

Detailed contract

Deserialize and exactly reverify a typed quotient algebra.

PythonRust

(cls, value: str) -> FiniteQuotientAlgebra[CoefficientRing]

noether::commalg::FiniteQuotientAlgebra::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, module-core, poly-core, resolution-kernel
GIL	attached / bounded
Semantic ID	noether/commalg/FiniteQuotientAlgebra@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.FiniteQuotientAlgebra.is_zero

Whether the source ideal is the unit ideal and this is the zero algebra.

Detailed contract

Whether this is the zero algebra obtained from the unit ideal.

PythonRust

(self) -> bool

noether::commalg::FiniteQuotientAlgebra::is_zero · Direct Rust declaration

pub fn is_zero(&self) -> bool

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/FiniteQuotientAlgebra@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

commalg.FiniteQuotientAlgebra.multiplication_operator

Sparse (row, column, coefficient) entries for one variable operator.

PythonRust

(self, variable: int) -> list[tuple[int, int, Coefficient]]

noether::commalg::FiniteQuotientAlgebra · Python projection

Python projection convenience over this Rust mathematical type

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

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:130 · validation/unit/commalg/test_polynomial_ideal_facade.py:144

commalg.FiniteQuotientAlgebra.multiplication_operator_nonzeros

Nonzero counts of the sparse variable-multiplication operators.

Detailed contract

Number of nonzero entries in each variable-multiplication operator.

PythonRust

(self) -> list[int]

noether::commalg::FiniteQuotientAlgebra::multiplication_operator_nonzeros · Direct Rust declaration

pub fn multiplication_operator_nonzeros(&self) -> Vec<usize>

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

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:129 · validation/unit/commalg/test_polynomial_ideal_facade.py:130

commalg.FiniteQuotientAlgebra.multiply

Multiply two standard-basis coordinate vectors.

Detailed contract

Multiply two quotient elements given in the standard basis.

PythonRust

(self, left: Iterable[Coefficient], right: Iterable[Coefficient]) -> list[Coefficient]

noether::commalg::FiniteQuotientAlgebra::multiply · Direct Rust declaration

pub fn multiply( &self, left: &[R::Element], right: &[R::Element], ) -> Result<Vec<R::Element>, GroebnerError>

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

Executable usage: examples/05_sparse_exact_operators.py:3 · validation/unit/commalg/test_polynomial_ideal_facade.py:136 · validation/unit/commalg/test_polynomial_ideal_facade.py:137 · validation/unit/commalg/test_polynomial_ideal_facade.py:138 · validation/unit/commalg/test_polynomial_ideal_facade.py:139 · validation/unit/commalg/test_polynomial_ideal_facade.py:142

commalg.FiniteQuotientAlgebra.multiply_by_variable

Apply multiplication by one source variable to coordinates.

Detailed contract

Apply multiplication by one source variable to quotient coordinates.

PythonRust

(self, variable: int, coordinates: Iterable[Coefficient]) -> list[Coefficient]

noether::commalg::FiniteQuotientAlgebra::multiply_by_variable · Direct Rust declaration

pub fn multiply_by_variable( &self, variable: usize, coordinates: &[R::Element], ) -> Result<Vec<R::Element>, GroebnerError>

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

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:140 · validation/unit/commalg/test_polynomial_ideal_facade.py:419

commalg.FiniteQuotientAlgebra.normal_form_coordinates

Standard-basis coordinates of a source polynomial's normal form.

Detailed contract

Reduce a source polynomial and return its standard-basis coordinates.

PythonRust

(self, polynomial: Polynomial[C]) -> list[Coefficient]

noether::commalg::FiniteQuotientAlgebra::normal_form_coordinates · Direct Rust declaration

pub fn normal_form_coordinates( &self, value: &Polynomial<R>, ) -> Result<Vec<R::Element>, GroebnerError>

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

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:133 · validation/unit/commalg/test_polynomial_ideal_facade.py:134 · validation/unit/commalg/test_polynomial_ideal_facade.py:419

commalg.FiniteQuotientAlgebra.one_coordinates

Coordinates of the multiplicative identity.

Detailed contract

Coordinates of the multiplicative identity in the standard basis.

PythonRust

(self) -> list[Coefficient]

noether::commalg::FiniteQuotientAlgebra::one_coordinates · Direct Rust declaration

pub fn one_coordinates(&self) -> Vec<R::Element>

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

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:132 · validation/unit/commalg/test_polynomial_ideal_facade.py:418 · validation/unit/commalg/test_polynomial_ideal_facade.py:447

commalg.FiniteQuotientAlgebra.source

Source ideal whose quotient is represented.

Detailed contract

Source ideal whose quotient algebra is represented.

PythonRust

(self) -> Ideal[PolynomialRing[C]]

noether::commalg::FiniteQuotientAlgebra::source · Direct Rust declaration

pub fn source(&self) -> &Ideal<PolynomialRing<R>>

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/FiniteQuotientAlgebra@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

commalg.FiniteQuotientAlgebra.to_json

Canonical typed JSON representation.

Detailed contract

Serialize this verified quotient algebra as typed JSON.

PythonRust

(self) -> str

noether::commalg::FiniteQuotientAlgebra::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, module-core, poly-core, resolution-kernel
GIL	attached / bounded
Semantic ID	noether/commalg/FiniteQuotientAlgebra@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.FiniteQuotientAlgebra.verify

Recompute and exactly verify this algebra description.

Detailed contract

Recompute the sparse quotient algebra and check exact identity.

PythonRust

(self) -> None

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

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

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/FiniteQuotientAlgebra@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