commalg · PolynomialRing

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

Worked example

The complete checked program Lift a simple square root from F_5 to fixed-precision Z_5 uses this API directly.

# SPDX-License-Identifier: MIT
# Copyright (c) 2026 Benjamin Antieau and Deven Manam
"""Lift a simple square root from F_5 to fixed-precision Z_5."""

from noether.commalg import PolynomialRing
from noether.numthy import PadicRing


def main() -> None:
    integers = PadicRing(5, absolute_precision=6)
    polynomials = PolynomialRing(integers, ["x"])
    x = polynomials.generator("x")
    equation = x**2 - 6
    root = integers.hensel_lift(equation, integers.residue_field(1))
    assert equation.evaluate([root]) == integers.zero()
    print(f"sqrt(6) in Z_5 mod 5^6 is represented by {int(root)}")


if __name__ == "__main__":
    main()

Run it with .venv/bin/python examples/10_padic_hensel_lifting.py.

commalg.PolynomialRing

A generic sparse polynomial ring over one accepted coefficient context.

PythonRust

PolynomialRing(coefficient_ring: C, variables: Sequence[str], *, order: MonomialOrder | Literal['lex', 'grlex', 'grevlex']=MonomialOrder.GREVLEX, grading: FreeAbelianGrading | WeightedGrading | None=None)

noether::commalg::PolynomialRing · Direct Rust declaration

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

Executable usage: examples/10_padic_hensel_lifting.py:11 · examples/10_padic_hensel_lifting.py:5 · examples/12_number_field_ideals.py:11 · examples/12_number_field_ideals.py:6 · examples/14_weighted_polynomials.py:10 · examples/14_weighted_polynomials.py:6

commalg.PolynomialRing.__call__

Coerce the supplied input through this context or mathematical map.

PythonRust

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

noether::commalg::PolynomialRing · 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/PolynomialRing@1

Executable usage: validation/unit/infra/test_discovery.py:57 · validation/unit/infra/test_public_api_index.py:155 · validation/unit/infra/test_public_api_index.py:169

commalg.PolynomialRing.base_change

Extend coefficients along one checked standard map while preserving the complete polynomial presentation.

Detailed contract

Extend coefficients along one checked standard map while preserving the complete polynomial presentation.

Extend the coefficient context while preserving variables, term order, and grading exactly.

PythonRust

(self: PolynomialRing[IntegerRing], map: IntegerRationalEmbedding) -> PolynomialRing[RationalField]
(self: PolynomialRing[IntegerRing], map: IntegerReduction) -> PolynomialRing[ResidueRing]
(self: PolynomialRing[IntegerRing], map: IntegerFiniteFieldMap) -> PolynomialRing[FiniteField]
(self: PolynomialRing[FiniteField], map: PrimeSubfieldEmbedding) -> PolynomialRing[FiniteField]
(self: PolynomialRing[FiniteField], map: FiniteFieldEmbedding) -> PolynomialRing[FiniteField]
(self: PolynomialRing[RationalFunctionField[FiniteField]], map: RationalFunctionFieldMap) -> PolynomialRing[RationalFunctionField[FiniteField]]

noether::commalg::PolynomialRing::base_change · Direct Rust declaration

pub fn base_change<M>( &self, map: &M, ) -> Result<PolynomialRing<M::Target>, BaseChangeError>where M: CoefficientMap<Source = 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/PolynomialRing@1

Executable usage: validation/unit/commalg/test_base_change.py:108 · validation/unit/commalg/test_base_change.py:110 · validation/unit/commalg/test_base_change.py:111 · validation/unit/commalg/test_base_change.py:112 · validation/unit/commalg/test_base_change.py:113 · validation/unit/commalg/test_base_change.py:114

commalg.PolynomialRing.coefficient_ring

Return the coefficient ring recorded by this PolynomialRing.

Detailed contract

Coefficient-ring context.

PythonRust

(self) -> C

noether::commalg::PolynomialRing::coefficient_ring · Direct Rust declaration

pub fn coefficient_ring(&self) -> &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/PolynomialRing@1

Executable usage: validation/unit/commalg/test_affine_normalization_facade.py:115 · validation/unit/commalg/test_affine_normalization_facade.py:117 · validation/unit/commalg/test_affine_normalization_facade.py:119 · validation/unit/commalg/test_base_change.py:31 · validation/unit/commalg/test_base_change.py:53 · validation/unit/commalg/test_construction_algebras.py:19

commalg.PolynomialRing.constant

Compute constant for this PolynomialRing.

Detailed contract

Embed one coefficient as a constant polynomial.

PythonRust

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

noether::commalg::PolynomialRing::constant · Direct Rust declaration

pub fn constant( &self, coefficient: R::Element, ) -> Result<Polynomial<R>, PolynomialError>

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

Executable usage: validation/unit/commalg/test_curve_facade.py:150 · validation/unit/commalg/test_normalization_facade.py:71 · validation/unit/commalg/test_polynomial_ideal_facade.py:304 · validation/unit/commalg/test_polynomial_ideal_facade.py:409 · validation/unit/commalg/test_polynomial_ideal_facade.py:413 · validation/unit/commalg/test_polynomial_ideal_facade.py:62

commalg.PolynomialRing.cotangent_space_at

Cotangent fiber at an explicit coefficient-field point.

Detailed contract

Cotangent space of this polynomial algebra at an explicit field point.

PythonRust

(self: PolynomialRing[RationalField], point: Sequence[_Fraction | int]) -> CotangentSpace[RationalField]
(self: PolynomialRing[FiniteField], point: Sequence[FiniteFieldElement]) -> CotangentSpace[FiniteField]

noether::commalg::PolynomialRing::cotangent_space_at · Direct Rust declaration

pub fn cotangent_space_at( &self, point: Vec<C::Element>, ) -> Result<CotangentSpace<C>, KahlerDifferentialError>

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	released
Semantic ID	noether/commalg/PolynomialRing@1

Executable usage: examples/39_kahler_differentials.py:22 · examples/39_kahler_differentials.py:23 · validation/unit/commalg/test_kahler_differentials.py:115 · validation/unit/commalg/test_kahler_differentials.py:132 · validation/unit/commalg/test_kahler_differentials.py:134 · validation/unit/commalg/test_kahler_differentials.py:144

commalg.PolynomialRing.from_json

Deserialize and revalidate a supported polynomial-ring context.

Detailed contract

Deserialize and revalidate a complete polynomial-ring context.

PythonRust

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

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

pub fn from_json(value: &str) -> Result<Self, NoetherError>where R: 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/PolynomialRing@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.PolynomialRing.from_terms

Construct a PolynomialRing using terms.

Detailed contract

Construct a sparse polynomial from arbitrary-size exponent vectors. Duplicate monomials are summed and zero coefficients are removed.

PythonRust

(self, terms: Iterable[tuple[Sequence[int], Coefficient]]) -> Polynomial[C]

noether::commalg::PolynomialRing::from_terms · Direct Rust declaration

pub fn from_terms<I>(&self, terms: I) -> Result<Polynomial<R>, PolynomialError>where I: IntoIterator<Item = (Vec<Integer>, 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/PolynomialRing@1

Executable usage: examples/14_weighted_polynomials.py:12 · validation/unit/commalg/test_groebner_verification_budget.py:48 · validation/unit/commalg/test_intersection_theory.py:34 · validation/unit/commalg/test_kahler_differentials.py:172 · validation/unit/commalg/test_polynomial_facade.py:226 · validation/unit/commalg/test_polynomial_facade.py:233

commalg.PolynomialRing.generator

Compute generator for this PolynomialRing.

Detailed contract

Return the variable-th indeterminate.

PythonRust

(self, variable: int | str) -> Polynomial[C]

noether::commalg::PolynomialRing::generator · Direct Rust declaration

pub fn generator( &self, variable: usize, ) -> Result<Polynomial<R>, PolynomialError>

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

Executable usage: examples/08_finite_field_extensions.py:10 · examples/08_finite_field_extensions.py:11 · examples/08_finite_field_extensions.py:12 · examples/08_finite_field_extensions.py:13 · examples/08_finite_field_extensions.py:14 · examples/10_padic_hensel_lifting.py:12

commalg.PolynomialRing.generators

Compute generators for this PolynomialRing.

Detailed contract

All indeterminates in declared order.

PythonRust

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

noether::commalg::PolynomialRing::generators · Direct Rust declaration

pub fn generators(&self) -> Result<Vec<Polynomial<R>>, PolynomialError>

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

commalg.PolynomialRing.grading

Return the grading recorded by this PolynomialRing.

Detailed contract

Free-abelian grading carried by this structured polynomial context.

PythonRust

(self) -> FreeAbelianGrading

noether::commalg::PolynomialRing::grading · Direct Rust declaration

pub fn grading(&self) -> &FreeAbelianGrading

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

Executable usage: examples/14_weighted_polynomials.py:10 · examples/14_weighted_polynomials.py:3 · validation/unit/commalg/test_base_change.py:23 · validation/unit/commalg/test_base_change.py:34 · validation/unit/commalg/test_construction_algebras.py:44 · validation/unit/commalg/test_context_tower_workload.py:42

commalg.PolynomialRing.homogeneous_monomials

Monomials of one exact ordinary or weighted degree, in term order.

Detailed contract

Enumerate the monomials of one exact degree in this ring’s grading. Standard grading gives ordinary homogeneous monomials; an explicit WeightedGrading gives weighted-homogeneous monomials. Results are greatest-to-least in the ring’s term order. The operation fails before retaining more than max_count monomials.

PythonRust

(self, degree: int, *, max_count: int) -> list[Polynomial[C]]

noether::commalg::PolynomialRing::homogeneous_monomials · Direct Rust declaration

pub fn homogeneous_monomials( &self, degree: u64, max_count: usize, ) -> Result<Vec<Polynomial<R>>, PolynomialError>

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

Executable usage: validation/unit/commalg/test_polynomial_facade.py:302 · validation/unit/commalg/test_polynomial_facade.py:307 · validation/unit/commalg/test_polynomial_facade.py:310 · validation/unit/commalg/test_polynomial_facade.py:335

commalg.PolynomialRing.homogeneous_monomials_of_degree

Monomials in one exact free-abelian degree, with finite-piece evidence.

Detailed contract

Enumerate one exact piece of an arbitrary free-abelian grading. positivity is exact evidence that the piece is finite. Its grading must equal this ring’s grading. Candidate enumeration and retained output are both bounded and fail closed.

PythonRust

(self, degree: Degree, positivity: PositiveGrading, *, max_count: int) -> list[Polynomial[C]]

noether::commalg::PolynomialRing::homogeneous_monomials_of_degree · Direct Rust declaration

pub fn homogeneous_monomials_of_degree( &self, degree: &Degree, positivity: &PositiveGrading, max_count: usize, ) -> Result<Vec<Polynomial<R>>, PolynomialError>

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

Executable usage: validation/unit/commalg/test_polynomial_facade.py:326 · validation/unit/commalg/test_polynomial_facade.py:337

commalg.PolynomialRing.homomorphism

Construct a checked homomorphism to a polynomial or coefficient ring.

Detailed contract

Construct a homomorphism to another polynomial ring. coefficient_map lands in the target coefficient ring; Noether composes it with the canonical constant-polynomial inclusion.

PythonRust

(self, target: PolynomialRing[T], images: Sequence[Polynomial[T]], *, coefficient_map: _StandardCoefficientMap | None=None) -> PolynomialHomomorphism[C, Polynomial[T]]
(self, target: CoefficientRing, images: Sequence[Coefficient], *, coefficient_map: _StandardCoefficientMap | None=None) -> PolynomialHomomorphism[C, Coefficient]

noether::commalg::PolynomialRing::homomorphism · Direct Rust declaration

pub fn homomorphism<T, M>( &self, target: &PolynomialRing<T>, coefficient_map: M, images: Vec<Polynomial<T>>, ) -> Result<PolynomialRingHomomorphism<S, T, M>, PolynomialHomomorphismError>where T: CommutativeRing + Display, M: CoefficientMap<Source = S, Target = T>,

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

Executable usage: examples/38_exact_linear_systems.py:63 · examples/38_exact_linear_systems.py:68 · examples/38_exact_linear_systems.py:69 · validation/unit/commalg/test_base_change.py:118 · validation/unit/commalg/test_base_change.py:123 · validation/unit/commalg/test_base_change.py:124

commalg.PolynomialRing.ideal

Construct a canonical polynomial ideal over Z or an accepted field.

Detailed contract

Construct a canonical integral polynomial ideal from its normalized strong Gröbner basis. Construct an ideal with its canonical reduced Gröbner basis. The native correctness floor is deliberately bounded and reports GroebnerError::ResourceLimit instead of running without limit on inputs outside its small exact regime.

PythonRust

(self, generators: Sequence[Polynomial[C]]) -> Ideal[PolynomialRing[C]]

noether::commalg::PolynomialRing::ideal · Direct Rust declaration

pub fn ideal<I>(&self, generators: I) -> Result<Ideal<Self>, GroebnerError>where I: IntoIterator<Item = Polynomial<IntegerRing>>,
pub fn ideal<I>(&self, generators: I) -> Result<Ideal<Self>, GroebnerError>where I: IntoIterator<Item = 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/PolynomialRing@1

Executable usage: examples/12_number_field_ideals.py:17 · examples/12_number_field_ideals.py:18 · examples/12_number_field_ideals.py:19 · examples/12_number_field_ideals.py:3 · examples/15_groebner_twisted_cubic.py:12 · examples/15_groebner_twisted_cubic.py:13

commalg.PolynomialRing.ideal_with_hilbert_series

Construct a field-polynomial ideal with an exact Hilbert-series target.

Detailed contract

Construct the canonical reduced ideal using an exact Hilbert series as a verified completion target. In the standard grading the fixed kernel may stop pair construction once the leading ideal reaches target; an independent Buchberger sweep remains mandatory, and an incorrect target fails closed. Other gradings retain ordinary construction and exact final comparison.

PythonRust

(self, generators: Sequence[Polynomial[C]], target: HilbertSeries) -> Ideal[PolynomialRing[C]]

noether::commalg::PolynomialRing::ideal_with_hilbert_series · Direct Rust declaration

pub fn ideal_with_hilbert_series<I>( &self, generators: I, target: &HilbertSeries, ) -> Result<Ideal<Self>, GroebnerError>where I: IntoIterator<Item = 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/PolynomialRing@1

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:206

commalg.PolynomialRing.kahler_differentials

Exact Kähler differentials over the coefficient field.

Detailed contract

Kähler differentials of this polynomial algebra over its coefficient field. Internally this is the exact zero-ideal quotient presentation.

PythonRust

(self: PolynomialRing[RationalField]) -> KahlerDifferentials[RationalField]
(self: PolynomialRing[FiniteField]) -> KahlerDifferentials[FiniteField]

noether::commalg::PolynomialRing::kahler_differentials · Direct Rust declaration

pub fn kahler_differentials( &self, ) -> Result<KahlerDifferentials<C>, KahlerDifferentialError>

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	released
Semantic ID	noether/commalg/PolynomialRing@1

Executable usage: examples/39_kahler_differentials.py:14 · validation/unit/commalg/test_kahler_differentials.py:110 · validation/unit/commalg/test_kahler_differentials.py:129 · validation/unit/commalg/test_kahler_differentials.py:176 · validation/unit/commalg/test_kahler_differentials.py:30 · validation/unit/commalg/test_kahler_differentials.py:57

commalg.PolynomialRing.monomial_ideal

Construct a canonical monomial ideal from exponent vectors.

PythonRust

(self, generators: Iterable[Sequence[int]]) -> MonomialIdeal[C]

noether::commalg::PolynomialRing::monomial_ideal · Direct Rust declaration

pub fn monomial_ideal<I, E>( &self, generators: I, ) -> Result<MonomialIdeal<R>, MonomialIdealError>where I: IntoIterator<Item = E>, E: IntoIterator<Item = Integer>,

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

Executable usage: validation/unit/commalg/test_monomial_ideal_facade.py:22 · validation/unit/commalg/test_monomial_ideal_facade.py:23 · validation/unit/commalg/test_monomial_ideal_facade.py:43 · validation/unit/commalg/test_monomial_ideal_facade.py:64 · validation/unit/commalg/test_monomial_ideal_facade.py:78 · validation/unit/commalg/test_monomial_ideal_facade.py:91

commalg.PolynomialRing.monomials_in_region

Monomials in one explicit finite truncation region, in term order.

Detailed contract

Enumerate every monomial retained by one explicit finite region. The region uses the same strict univariate, total-degree, box, and weighted-degree shapes as fixed-truncation series. Results are greatest-to-least in this ring’s term order, with an explicit retained output cap.

PythonRust

(self, region: SeriesTruncation, *, max_count: int) -> list[Polynomial[C]]

noether::commalg::PolynomialRing::monomials_in_region · Direct Rust declaration

pub fn monomials_in_region( &self, region: &SeriesTruncation, max_count: usize, ) -> Result<Vec<Polynomial<R>>, PolynomialError>

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

Executable usage: validation/unit/commalg/test_polynomial_facade.py:312 · validation/unit/commalg/test_polynomial_facade.py:314

commalg.PolynomialRing.nullstellensatz_certificate

Compute rational Nullstellensatz multipliers for integral generators without first constructing a strong basis over Z.

Detailed contract

Compute rational Nullstellensatz multipliers for integral generators without first constructing a strong basis over Z.

Compute a rational Nullstellensatz identity for an explicit integral generator family without first constructing a strong basis over Z.

PythonRust

(self: PolynomialRing[IntegerRing], generators: Sequence[Polynomial[IntegerRing]]) -> ArithmeticNullstellensatzCertificate

noether::commalg::PolynomialRing::nullstellensatz_certificate · Direct Rust declaration

pub fn nullstellensatz_certificate<I>( &self, generators: I, ) -> Result<ArithmeticNullstellensatzCertificate, ArithmeticIdealError>where I: IntoIterator<Item = Polynomial<IntegerRing>>,

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	released
Semantic ID	noether/commalg/PolynomialRing@1

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:292 · validation/unit/commalg/test_polynomial_ideal_facade.py:308 · validation/unit/infra/test_discovery.py:128 · validation/unit/infra/test_discovery.py:129

commalg.PolynomialRing.one

Compute one for this PolynomialRing.

PythonRust

(self) -> Polynomial[C]

noether::commalg::PolynomialRing::one · Direct Rust declaration

fn one(&self) -> Self::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/PolynomialRing@1

Executable usage: examples/02_ball_arithmetic.py:13 · examples/11_qadic_witt_vectors.py:11 · examples/24_homology_and_persistence.py:3 · examples/31_local_fields_and_precision.py:27 · validation/unit/combinatorics/test_poset.py:3 · validation/unit/commalg/test_acceptance_workload.py:37

commalg.PolynomialRing.quotient

Form the exact quotient by an ideal in this polynomial ring.

Detailed contract

Form the exact quotient by a canonical ideal in this polynomial ring.

PythonRust

(self: PolynomialRing[_ProjectedIdealFieldContext], ideal: Ideal[PolynomialRing[_ProjectedIdealFieldContext]]) -> QuotientRing[_ProjectedIdealFieldContext]

noether::commalg::PolynomialRing::quotient · Direct Rust declaration

pub fn quotient( &self, ideal: &Ideal<Self>, ) -> Result<QuotientRing<Self>, ContextMismatchError>

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

commalg.PolynomialRing.strong_groebner_basis

Compute a normalized strong Groebner basis over Z.

Detailed contract

Compute a verified normalized strong Gröbner basis over Z.

PythonRust

(self: PolynomialRing[IntegerRing], generators: Sequence[Polynomial[IntegerRing]]) -> StrongGroebnerBasis

noether::commalg::PolynomialRing::strong_groebner_basis · Direct Rust declaration

pub fn strong_groebner_basis<I>( &self, generators: I, ) -> Result<StrongGroebnerBasis, GroebnerError>where I: IntoIterator<Item = Polynomial<IntegerRing>>,

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	released
Semantic ID	noether/commalg/PolynomialRing@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

commalg.PolynomialRing.term_order

Return the term order recorded by this PolynomialRing.

Detailed contract

Monomial order used for leading terms and later Gröbner algorithms.

PythonRust

(self) -> MonomialOrder

noether::commalg::PolynomialRing::term_order · Direct Rust declaration

pub fn term_order(&self) -> MonomialOrder

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

Executable usage: validation/unit/commalg/test_base_change.py:33 · validation/unit/commalg/test_polynomial_facade.py:284 · validation/unit/commalg/test_polynomial_facade.py:43 · validation/unit/commalg/test_polynomial_facade.py:433 · validation/unit/commalg/test_polynomial_facade.py:44 · validation/unit/commalg/test_polynomial_ideal_facade.py:82

commalg.PolynomialRing.to_json

Serialize the complete coefficient, variable, order, and grading context.

PythonRust

(self) -> str

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

pub fn to_json(&self) -> Result<String, NoetherError>where R: 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/PolynomialRing@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.PolynomialRing.variables

Return the variables recorded by this PolynomialRing.

Detailed contract

Ordered indeterminate names.

PythonRust

(self) -> list[str]

noether::commalg::PolynomialRing::variables · Direct Rust declaration

pub fn variables(&self) -> &[String]

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

Executable usage: validation/unit/combinatorics/test_matroid.py:66 · validation/unit/commalg/test_affine_normalization_facade.py:100 · validation/unit/commalg/test_affine_normalization_facade.py:107 · validation/unit/commalg/test_base_change.py:32 · validation/unit/commalg/test_normalization_facade.py:60 · validation/unit/commalg/test_normalization_facade.py:69

commalg.PolynomialRing.weighted_grading

Positive rank-one view of the grading, when one exists.

Detailed contract

Positive rank-one view of this grading, when one exists.

PythonRust

(self) -> WeightedGrading | None

noether::commalg::PolynomialRing::weighted_grading · Direct Rust declaration

pub fn weighted_grading(&self) -> Option<WeightedGrading>

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

Executable usage: validation/unit/commalg/test_polynomial_facade.py:285 · validation/unit/commalg/test_polynomial_facade.py:294 · validation/unit/commalg/test_polynomial_facade.py:329 · validation/unit/commalg/test_polynomial_facade.py:403 · validation/unit/commalg/test_polynomial_facade.py:46

commalg.PolynomialRing.zero

Compute zero for this PolynomialRing.

PythonRust

(self) -> Polynomial[C]

noether::commalg::PolynomialRing::zero · Direct Rust declaration

fn zero(&self) -> Self::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/PolynomialRing@1

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