commalg · Ideal¶

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

Worked example¶

The complete checked program Compute in an exterior algebra and induce a linear map on two-forms uses this API directly.

# SPDX-License-Identifier: MIT
# Copyright (c) 2026 Benjamin Antieau and Deven Manam
"""Compute in an exterior algebra and induce a linear map on two-forms."""

from noether import Q
from noether.commalg import PolynomialRing
from noether.homalg import FreeModule, ModuleElement, ModuleHomomorphism
from noether.linalg import Matrix, Vector


def main() -> None:
    ring = PolynomialRing(Q, ["t"])
    module = FreeModule(ring, 3, basis_labels=["e0", "e1", "e2"])
    exterior = module.exterior_algebra()
    e0, e1, e2 = [exterior.generator(position) for position in range(3)]

    volume = e0 * e1 * e2
    assert volume == exterior.alternating_product(
        [
            ModuleElement(module, Vector.from_values(ring, [1, 0, 0])),
            ModuleElement(module, Vector.from_values(ring, [0, 1, 0])),
            ModuleElement(module, Vector.from_values(ring, [0, 0, 1])),
        ]
    )
    assert e1 * e0 == -(e0 * e1)
    assert e0 * e0 == exterior.zero()

    e0_dual = ModuleElement(module.dual(), Vector.from_values(ring, [1, 0, 0]))
    assert volume.contract(e0_dual) == e1 * e2

    linear_map = ModuleHomomorphism(
        module,
        module,
        Matrix.from_rows(ring, [[1, 1, 0], [0, 1, 0], [0, 0, 2]]),
    )
    on_two_forms = linear_map.exterior_power(2)
    on_two_forms.verify()
    assert on_two_forms.apply_exterior(e1 * e2) == 2 * (e0 * e2 + e1 * e2)
    print(
        "Λ² has basis",
        exterior.basis(2),
        "and the induced map sends e1∧e2 to",
        on_two_forms.apply_exterior(e1 * e2).terms,
    )


if __name__ == "__main__":
    main()

Run it with .venv/bin/python examples/40_exterior_algebra.py.

`commalg.Ideal`¶

A canonical ideal of one accepted commutative-ring context.

PythonRust

class Ideal

noether::commalg::Ideal · Direct Rust declaration

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

Executable usage: validation/unit/commalg/test_acceptance_workload.py:70 · validation/unit/commalg/test_polynomial_ideal_facade.py:181 · validation/unit/commalg/test_polynomial_ideal_facade.py:182 · validation/unit/commalg/test_polynomial_ideal_facade.py:183 · validation/unit/commalg/test_polynomial_ideal_facade.py:188 · validation/unit/commalg/test_polynomial_ideal_facade.py:20

`commalg.Ideal.add`¶

Add another compatible value to this value.

PythonRust

(self: Ideal[C], other: Ideal[C]) -> Ideal[C]

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

Executable usage: validation/unit/infra/test_discovery.py:211 · validation/unit/infra/test_public_api_index.py:293

`commalg.Ideal.contains`¶

Return bool(key in self).

Detailed contract

Decide exact ideal membership by Euclidean strong reduction. Decide ideal membership by exact canonical reduction. Decide divisibility membership in this principal ideal. Whether an exact field element belongs to this integral ideal.

PythonRust

(self, value: int | _Fraction | NumberFieldElement | Polynomial[CoefficientRing]) -> bool

noether::commalg::Ideal::contains · Direct Rust declaration

pub fn contains( &self, value: &Polynomial<IntegerRing>, ) -> Result<bool, GroebnerError>
pub fn contains(&self, value: &Polynomial<R>) -> Result<bool, GroebnerError>
pub fn contains(&self, value: &Integer) -> bool
pub fn contains(&self, element: &NumberFieldElement) -> 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/Ideal@1

Executable usage: validation/unit/infra/test_discovery.py:200

`commalg.Ideal.mul`¶

Multiply this value by another compatible value.

PythonRust

(self: Ideal[C], other: Ideal[C]) -> Ideal[C]

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

Executable usage: validation/unit/infra/test_public_api_index.py:214

`commalg.Ideal.pow`¶

Raise this value to the supplied power.

PythonRust

(self: Ideal[C], exponent: int) -> Ideal[C]

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

`commalg.Ideal.admit_primary_decomposition`¶

Admit independently discovered primary components after exact verification.

PythonRust

(self: Ideal[PolynomialRing[RationalField]], components: Sequence[Ideal[PolynomialRing[RationalField]]]) -> PrimaryDecomposition[RationalField]
(self: Ideal[PolynomialRing[FiniteField]], components: Sequence[Ideal[PolynomialRing[FiniteField]]]) -> PrimaryDecomposition[FiniteField]

noether::commalg::Ideal::admit_primary_decomposition · Direct Rust declaration

pub fn admit_primary_decomposition( &self, components: &[Self], ) -> Result<PrimaryDecomposition<RationalField>, DecompositionError>
pub fn admit_primary_decomposition( &self, components: &[Self], ) -> Result<PrimaryDecomposition<FiniteField>, DecompositionError>

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

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:1320 · validation/unit/commalg/test_polynomial_ideal_facade.py:1330 · validation/unit/commalg/test_polynomial_ideal_facade.py:1332 · validation/unit/infra/test_discovery.py:174 · validation/corpus/commalg/neural-ideal-primary-decomposition.py:27

`commalg.Ideal.arithmetic_fiber_support`¶

Exact arithmetic fiber support with bounded integer factorization.

Detailed contract

Compute the exact coefficient contraction and factor its generator with explicit deterministic work bounds.

PythonRust

(self: Ideal[PolynomialRing[IntegerRing]], trial_bound: int, primality_proof_bits: int) -> ArithmeticFiberSupport

noether::commalg::Ideal::arithmetic_fiber_support · Direct Rust declaration

pub fn arithmetic_fiber_support( &self, trial_bound: u64, primality_proof_bits: u64, ) -> Result<ArithmeticFiberSupport, ArithmeticIdealError>

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

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:316 · validation/unit/commalg/test_polynomial_ideal_facade.py:330

`commalg.Ideal.associated_graded_algebra`¶

Compute associated graded algebra for this Ideal.

Detailed contract

Construct the associated graded algebra gr_I(R).

PythonRust

(self: Ideal[PolynomialRing[RationalField]]) -> AssociatedGradedAlgebra[RationalField]
(self: Ideal[PolynomialRing[FiniteField]]) -> AssociatedGradedAlgebra[FiniteField]

noether::commalg::Ideal::associated_graded_algebra · Direct Rust declaration

pub fn associated_graded_algebra( &self, ) -> Result<AssociatedGradedAlgebra<R>, ConstructionAlgebraError>

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

Executable usage: validation/unit/commalg/test_construction_algebras.py:62 · validation/unit/infra/test_discovery.py:167

`commalg.Ideal.associated_primes`¶

Complete associated primes from verified Ext-annihilator evidence.

Detailed contract

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

PythonRust

(self: Ideal[PolynomialRing[RationalField]]) -> AssociatedPrimeSet[RationalField]
(self: Ideal[PolynomialRing[FiniteField]]) -> AssociatedPrimeSet[FiniteField]

noether::commalg::Ideal::associated_primes · Direct Rust declaration

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

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

`commalg.Ideal.base_change`¶

Extend a finite-field polynomial ideal and recompute its canonical reduced Groebner basis over the target field.

Detailed contract

Extend a finite-field polynomial ideal and recompute its canonical reduced Groebner basis over the target field.

Extend generators coefficientwise and recompute the canonical reduced Groebner basis over the target field. Extend an integral polynomial ideal to an exact field and recompute the target’s canonical reduced Gröbner basis.

PythonRust

(self: Ideal[PolynomialRing[IntegerRing]], map: IntegerRationalEmbedding) -> Ideal[PolynomialRing[RationalField]]
(self: Ideal[PolynomialRing[IntegerRing]], map: IntegerFiniteFieldMap) -> Ideal[PolynomialRing[FiniteField]]
(self: Ideal[PolynomialRing[FiniteField]], map: PrimeSubfieldEmbedding) -> Ideal[PolynomialRing[FiniteField]]
(self: Ideal[PolynomialRing[FiniteField]], map: FiniteFieldEmbedding) -> Ideal[PolynomialRing[FiniteField]]

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

pub fn base_change<M>( &self, map: &M, ) -> Result<Ideal<PolynomialRing<M::Target>>, BaseChangeError>where M: CoefficientMap<Source = R>, M::Target: Field,
pub fn base_change<M>( &self, map: &M, ) -> Result<Ideal<PolynomialRing<M::Target>>, BaseChangeError>where M: CoefficientMap<Source = IntegerRing>, M::Target: Field,

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/Ideal@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.Ideal.base_change_constant_field`¶

Change the finite constant field of an ideal over F_q(c).

Detailed contract

Change only the finite constant field of F_q(c)[x_1,...,x_n]. The native floor accepts identity maps and the canonical prime-subfield embedding F_p -> F_{p^e}. General finite-field embeddings require an explicit future embedding object and fail closed here.

PythonRust

(self, target: FiniteField) -> Ideal[C]

noether::commalg::Ideal::base_change_constant_field · Direct Rust declaration

pub fn base_change_constant_field( &self, target: FiniteField, ) -> Result<Self, DecompositionError>

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

Executable usage: validation/unit/commalg/test_acceptance_workload.py:74 · validation/unit/commalg/test_polynomial_ideal_facade.py:471

`commalg.Ideal.certify_primary`¶

Independently prove that this ideal is primary.

Detailed contract

Independently prove that this rational polynomial ideal is primary. Independently prove that this finite-field polynomial ideal is primary.

PythonRust

(self: Ideal[PolynomialRing[RationalField]]) -> PolynomialPrimaryCertificate[RationalField]
(self: Ideal[PolynomialRing[FiniteField]]) -> PolynomialPrimaryCertificate[FiniteField]

noether::commalg::Ideal::certify_primary · Direct Rust declaration

pub fn certify_primary( &self, ) -> Result<PolynomialPrimaryCertificate<RationalField>, DecompositionError>
pub fn certify_primary( &self, ) -> Result<PolynomialPrimaryCertificate<FiniteField>, DecompositionError>

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

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:1316 · validation/unit/commalg/test_polynomial_ideal_facade.py:1328 · validation/unit/infra/test_discovery.py:173 · validation/corpus/commalg/neural-ideal-primary-decomposition.py:32 · validation/corpus/homalg/determinantal-module-annihilators.py:53

`commalg.Ideal.change_order`¶

Return a polynomial ideal in an otherwise identical context with the requested monomial order.

Detailed contract

Return a polynomial ideal in an otherwise identical context with the requested monomial order.

Return this ideal in an otherwise identical polynomial context with a different monomial order. Zero-dimensional ideals use the coefficient-generic FGLM kernel. Positive-dimensional ideals retain exact direct recomputation as the correctness floor. In either case the returned generators are the canonical reduced basis in target_order.

PythonRust

(self, order: MonomialOrder | Literal['lex', 'grlex', 'grevlex']) -> Ideal[C]

noether::commalg::Ideal::change_order · Direct Rust declaration

pub fn change_order( &self, target_order: MonomialOrder, ) -> Result<Self, 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/Ideal@1

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:81 · validation/unit/commalg/test_polynomial_ideal_facade.py:83 · validation/unit/commalg/test_polynomial_ideal_facade.py:86

`commalg.Ideal.colon`¶

Exact ideal quotient self : other in one polynomial context.

Detailed contract

Exact ideal quotient self : other.

PythonRust

(self, other: Ideal[C]) -> Ideal[C]

noether::commalg::Ideal::colon · Direct Rust declaration

pub fn colon(&self, other: &Self) -> Result<Self, 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	released
Semantic ID	noether/commalg/Ideal@1

Executable usage: validation/unit/commalg/test_monomial_ideal_facade.py:34 · validation/unit/commalg/test_polynomial_ideal_facade.py:346 · validation/unit/commalg/test_polynomial_ideal_facade.py:347 · validation/unit/commalg/test_polynomial_ideal_facade.py:349 · validation/corpus/commalg/monomial-ideal-colon-witnesses.py:22 · validation/corpus/commalg/monomial-ideal-colon-witnesses.py:23

`commalg.Ideal.contract`¶

Contract an integral polynomial ideal into the polynomial ring on the remaining variables.

Detailed contract

Contract an integral polynomial ideal into the polynomial ring on the remaining variables.

Contract after eliminating the indexed variables into the induced polynomial ring on the remaining variables.

PythonRust

(self: Ideal[PolynomialRing[IntegerRing]], variables: Iterable[str | int]) -> Ideal[PolynomialRing[IntegerRing]]

noether::commalg::Ideal::contract · Direct Rust declaration

pub fn contract( &self, variables: &[usize], ) -> Result<Ideal<PolynomialRing<IntegerRing>>, 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	released
Semantic ID	noether/commalg/Ideal@1

Executable usage: examples/40_exterior_algebra.py:29 · validation/unit/combin/test_acceptance_workload.py:77 · validation/unit/combinatorics/test_matroid.py:55 · validation/unit/homalg/test_exterior_algebra.py:129 · validation/unit/homalg/test_exterior_algebra.py:130 · validation/unit/homalg/test_exterior_algebra.py:131

`commalg.Ideal.contract_to_coefficients`¶

Contract an integral polynomial ideal all the way to Z.

Detailed contract

Contract this ideal all the way to its coefficient ring Z.

PythonRust

(self: Ideal[PolynomialRing[IntegerRing]]) -> Ideal[IntegerRing]

noether::commalg::Ideal::contract_to_coefficients · Direct Rust declaration

pub fn contract_to_coefficients( &self, ) -> Result<Ideal<IntegerRing>, 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	released
Semantic ID	noether/commalg/Ideal@1

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

`commalg.Ideal.degree`¶

Standard-graded degree (multiplicity) of a polynomial quotient.

Detailed contract

Standard-graded degree (multiplicity) of R/I.

PythonRust

(self) -> int

noether::commalg::Ideal::degree · Direct Rust declaration

pub fn degree(&self) -> Result<Integer, 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/Ideal@1

Executable usage: examples/14_weighted_polynomials.py:16 · examples/14_weighted_polynomials.py:18 · examples/15_groebner_twisted_cubic.py:15 · examples/15_groebner_twisted_cubic.py:28 · examples/31_local_fields_and_precision.py:37 · examples/33_simplicial_cohomology_operations.py:26

`commalg.Ideal.dimension`¶

Krull dimension of a polynomial quotient (-1 for the unit ideal).

Detailed contract

Krull dimension of the quotient ring R/I (-1 for the unit ideal).

PythonRust

(self) -> int

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

pub fn dimension(&self) -> Result<i64, 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	released
Semantic ID	noether/commalg/Ideal@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.Ideal.eliminate`¶

Eliminate named or indexed variables from a polynomial ideal.

Detailed contract

Eliminate the indexed variables and retain the contraction in this ambient polynomial context. Eliminate the indexed variables and return the elimination ideal in this same polynomial-ring context. The native implementation computes in a private lexicographic context with the eliminated variables first, maps the result back, and verifies that every returned generator is independent of those variables and belongs to the source ideal.

PythonRust

(self, variables: Iterable[str | int]) -> Ideal[C]

noether::commalg::Ideal::eliminate · Direct Rust declaration

pub fn eliminate(&self, variables: &[usize]) -> Result<Self, 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	released
Semantic ID	noether/commalg/Ideal@1

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:254 · validation/unit/commalg/test_polynomial_ideal_facade.py:257 · validation/unit/commalg/test_polynomial_ideal_facade.py:260 · validation/unit/commalg/test_polynomial_ideal_facade.py:262 · validation/unit/commalg/test_polynomial_ideal_facade.py:408 · validation/unit/infra/test_discovery.py:176

`commalg.Ideal.eliminate_with_evidence`¶

Eliminate selected variables and retain a replayable field result.

Detailed contract

Eliminate selected variables and retain a replayable verified result.

PythonRust

(self: Ideal[PolynomialRing[T]], variables: Iterable[str | int]) -> IdealElimination[T]

noether::commalg::Ideal::eliminate_with_evidence · Direct Rust declaration

pub fn eliminate_with_evidence( &self, variables: &[usize], ) -> Result<IdealElimination<R>, 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	released
Semantic ID	noether/commalg/Ideal@1

Executable usage: examples/15_groebner_twisted_cubic.py:21 · validation/unit/commalg/test_polynomial_ideal_facade.py:279 · validation/unit/infra/test_discovery.py:177 · validation/unit/infra/test_math_determinism.py:26 · validation/corpus/commalg/sparse-surface-implicitization.py:27 · validation/corpus/commalg/two-point-secant-elimination.py:28

`commalg.Ideal.equidimensional_hull`¶

Verified scheme-theoretic top-dimensional hull from Ext evidence.

Detailed contract

Compute the scheme-theoretic top-dimensional hull over the rationals. Compute the scheme-theoretic top-dimensional hull over a finite field.

PythonRust

(self: Ideal[PolynomialRing[RationalField]]) -> EquidimensionalHull[RationalField]
(self: Ideal[PolynomialRing[FiniteField]]) -> EquidimensionalHull[FiniteField]

noether::commalg::Ideal::equidimensional_hull · Direct Rust declaration

pub fn equidimensional_hull( &self, ) -> Result<EquidimensionalHull<RationalField>, AssociatedPrimeError>
pub fn equidimensional_hull( &self, ) -> Result<EquidimensionalHull<FiniteField>, AssociatedPrimeError>

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

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:648 · validation/unit/infra/test_discovery.py:164 · validation/unit/infra/test_macaulay2_benchmark_protocol.py:994 · validation/bench/macaulay2_decomposition.py:786 · validation/bench/macaulay2_decomposition.py:930

`commalg.Ideal.equidimensional_radical_decomposition`¶

Verified decomposition of the radical by component dimension.

Detailed contract

Decompose the radical into its equidimensional rational components. Decompose the radical into its equidimensional finite-field components.

PythonRust

(self: Ideal[PolynomialRing[RationalField]]) -> EquidimensionalRadicalDecomposition[RationalField]
(self: Ideal[PolynomialRing[FiniteField]]) -> EquidimensionalRadicalDecomposition[FiniteField]

noether::commalg::Ideal::equidimensional_radical_decomposition · Direct Rust declaration

pub fn equidimensional_radical_decomposition( &self, ) -> Result<EquidimensionalRadicalDecomposition<RationalField>, DecompositionError>
pub fn equidimensional_radical_decomposition( &self, ) -> Result<EquidimensionalRadicalDecomposition<FiniteField>, DecompositionError>

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

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:1012 · validation/unit/commalg/test_polynomial_ideal_facade.py:1227 · validation/unit/infra/test_discovery.py:172 · validation/bench/macaulay2_decomposition.py:783 · validation/bench/macaulay2_decomposition.py:976

`commalg.Ideal.finite_quotient_algebra`¶

Construct the verified finite-dimensional quotient algebra.

Detailed contract

Construct the verified finite-dimensional quotient algebra, including a standard-monomial basis and sparse variable-multiplication operators.

PythonRust

(self: Ideal[PolynomialRing[T]]) -> FiniteQuotientAlgebra[T]

noether::commalg::Ideal::finite_quotient_algebra · Direct Rust declaration

pub fn finite_quotient_algebra( &self, ) -> Result<FiniteQuotientAlgebra<R>, 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	released
Semantic ID	noether/commalg/Ideal@1

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:123 · validation/unit/commalg/test_polynomial_ideal_facade.py:153 · validation/unit/commalg/test_polynomial_ideal_facade.py:416 · validation/unit/commalg/test_polynomial_ideal_facade.py:445 · validation/unit/infra/test_discovery.py:163 · validation/bench/macaulay2_decomposition.py:915

`commalg.Ideal.from_json`¶

Restore and revalidate a canonical ideal.

Detailed contract

Deserialize and recompute a canonical integral polynomial ideal. Deserialize and revalidate a canonical polynomial ideal. Deserialize and revalidate a canonical principal ideal. Restore and revalidate a canonical integral ideal from JSON.

PythonRust

(cls, value: str) -> Ideal[C]

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

pub fn from_json(value: &str) -> Result<Self, NoetherError>
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/Ideal@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.Ideal.generators`¶

Canonical generating family.

Detailed contract

A canonical generating family for this ideal.

PythonRust

(self) -> list[int | NumberFieldElement | Polynomial[CoefficientRing]]

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

pub fn generators(&self) -> &[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/Ideal@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.Ideal.grauert_remmert_step`¶

One verified finite birational Grauert--Remmert end-ring extension.

Detailed contract

Compute one verified Grauert–Remmert end-ring extension. A smooth source returns None. A singular source yields a finite birational target that can be used as the source of a subsequent step; failure to find an admissible target is an explicit unsupported error.

PythonRust

(self: Ideal[PolynomialRing[RationalField]]) -> GrauertRemmertStep[RationalField] | None
(self: Ideal[PolynomialRing[FiniteField]]) -> GrauertRemmertStep[FiniteField] | None

noether::commalg::Ideal::grauert_remmert_step · Direct Rust declaration

pub fn grauert_remmert_step( &self, ) -> Result<Option<GrauertRemmertStep<RationalField>>, AffineNormalizationError>
pub fn grauert_remmert_step( &self, ) -> Result<Option<GrauertRemmertStep<FiniteField>>, AffineNormalizationError>

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

Executable usage: validation/unit/commalg/test_affine_normalization_facade.py:123 · validation/unit/commalg/test_affine_normalization_facade.py:131 · validation/unit/commalg/test_affine_normalization_facade.py:137 · validation/unit/infra/test_discovery.py:168

`commalg.Ideal.groebner_basis`¶

Canonical reduced Groebner basis for polynomial ideals.

Detailed contract

Canonical reduced strong Gröbner basis over Z. The canonical reduced Gröbner basis.

PythonRust

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

noether::commalg::Ideal::groebner_basis · Direct Rust declaration

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

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Dispatch / backing	groebner-kernel
GIL	attached / bounded
Semantic ID	noether/commalg/Ideal@1
Contexts	polynomial rings over exact admitted coefficient contexts
Failures	non-polynomial ideal context

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

`commalg.Ideal.hilbert_numerator`¶

Standard Hilbert-series numerator of a polynomial quotient.

Detailed contract

Numerator K(t) in H(R/I, t) = K(t) / (1-t)^n.

PythonRust

(self) -> list[int]

noether::commalg::Ideal::hilbert_numerator · Direct Rust declaration

pub fn hilbert_numerator(&self) -> Result<Vec<Integer>, 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/Ideal@1

Executable usage: examples/15_groebner_twisted_cubic.py:16 · validation/unit/commalg/test_monomial_ideal_facade.py:47 · validation/unit/commalg/test_monomial_ideal_facade.py:50 · validation/unit/commalg/test_polynomial_ideal_facade.py:203 · validation/unit/commalg/test_polynomial_ideal_facade.py:205 · validation/unit/commalg/test_quotient_facade.py:126

`commalg.Ideal.hilbert_polynomial`¶

Standard Hilbert polynomial in the canonical variable m.

Detailed contract

Standard Hilbert polynomial in the canonical variable m.

PythonRust

(self) -> Polynomial[RationalField]

noether::commalg::Ideal::hilbert_polynomial · Direct Rust declaration

pub fn hilbert_polynomial( &self, ) -> Result<Polynomial<RationalField>, 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	released
Semantic ID	noether/commalg/Ideal@1

Executable usage: validation/unit/commalg/test_monomial_ideal_facade.py:54 · validation/unit/commalg/test_polynomial_ideal_facade.py:212 · validation/unit/commalg/test_polynomial_ideal_facade.py:223 · validation/unit/commalg/test_polynomial_ideal_facade.py:246 · validation/unit/commalg/test_quotient_facade.py:129 · validation/unit/commalg/test_scheme_facade.py:38

`commalg.Ideal.hilbert_series`¶

Exact Hilbert series in the polynomial-ring grading.

Detailed contract

Exact Hilbert series in the group algebra of the ring grading.

PythonRust

(self) -> HilbertSeries

noether::commalg::Ideal::hilbert_series · Direct Rust declaration

pub fn hilbert_series(&self) -> Result<HilbertSeries, 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/Ideal@1

Executable usage: validation/unit/commalg/test_monomial_ideal_facade.py:48 · validation/unit/commalg/test_monomial_ideal_facade.py:86 · validation/unit/commalg/test_polynomial_ideal_facade.py:204 · validation/unit/commalg/test_quotient_facade.py:125 · validation/unit/homalg/test_module_facade.py:261 · validation/unit/homalg/test_module_facade.py:502

`commalg.Ideal.initial_ideal`¶

Leading-monomial ideal of this canonical reduced Groebner basis.

Detailed contract

Canonical monomial ideal generated by the leading monomials of this reduced Groebner basis.

PythonRust

(self: Ideal[PolynomialRing[_ProjectedIdealFieldContext]]) -> MonomialIdeal[_ProjectedIdealFieldContext]

noether::commalg::Ideal::initial_ideal · Direct Rust declaration

pub fn initial_ideal(&self) -> MonomialIdeal<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/Ideal@1

Executable usage: validation/unit/commalg/test_monomial_ideal_facade.py:55 · validation/corpus/commalg/affine-cubic-curve-dimension.py:14 · validation/corpus/commalg/octic-quotient-degree-eight.py:13

`commalg.Ideal.intersection`¶

Exact intersection with another polynomial ideal in the same context.

Detailed contract

Exact intersection with another ideal in this polynomial context.

PythonRust

(self, other: Ideal[C]) -> Ideal[C]

noether::commalg::Ideal::intersection · Direct Rust declaration

pub fn intersection(&self, other: &Self) -> Result<Self, 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	released
Semantic ID	noether/commalg/Ideal@1

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

`commalg.Ideal.minimal_primes`¶

Verified minimal components in the admitted exact coefficient context.

Detailed contract

Split a square-free homogeneous binary principal ideal over its constants. This bounded native case is sufficient for small geometric-component checks such as a conjugate pair of lines over F_9(c). Coefficients must be constant in c, the form must split completely into distinct linear factors, and the field/order and degree caps are fixed. Prove all minimal primes of an admitted rational ideal. Prove all minimal primes of an admitted finite-field ideal.

PythonRust

(self: Ideal[PolynomialRing[RationalField]]) -> MinimalPrimeDecomposition[RationalField]
(self: Ideal[PolynomialRing[FiniteField]]) -> MinimalPrimeDecomposition[FiniteField]
(self: Ideal[PolynomialRing[RationalFunctionField[FiniteField]]]) -> IdealDecomposition[RationalFunctionField[FiniteField]]

noether::commalg::Ideal::minimal_primes · Direct Rust declaration

pub fn minimal_primes( &self, ) -> Result<IdealDecomposition<RationalFunctionField<FiniteField>>, DecompositionError>
pub fn minimal_primes( &self, ) -> Result<MinimalPrimeDecomposition<RationalField>, DecompositionError>
pub fn minimal_primes( &self, ) -> Result<MinimalPrimeDecomposition<FiniteField>, DecompositionError>

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

Executable usage: validation/unit/commalg/test_acceptance_workload.py:69 · validation/unit/commalg/test_acceptance_workload.py:70 · validation/unit/commalg/test_acceptance_workload.py:75 · validation/unit/commalg/test_affine_normalization_facade.py:183 · validation/unit/commalg/test_polynomial_ideal_facade.py:1002 · validation/unit/commalg/test_polynomial_ideal_facade.py:1039

`commalg.Ideal.noether_normalization`¶

Deterministic finite polynomial-subring normalization with exact evidence.

Detailed contract

Compute a deterministic finite polynomial-subring normalization over Q. Compute a deterministic finite polynomial-subring normalization over a finite field.

PythonRust

(self: Ideal[PolynomialRing[RationalField]]) -> NoetherNormalization[RationalField]
(self: Ideal[PolynomialRing[FiniteField]]) -> NoetherNormalization[FiniteField]

noether::commalg::Ideal::noether_normalization · Direct Rust declaration

pub fn noether_normalization( &self, ) -> Result<NoetherNormalization<RationalField>, NoetherNormalizationError>
pub fn noether_normalization( &self, ) -> Result<NoetherNormalization<FiniteField>, NoetherNormalizationError>

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

Executable usage: validation/unit/commalg/test_normalization_facade.py:19 · validation/unit/commalg/test_normalization_facade.py:53 · validation/unit/commalg/test_normalization_facade.py:58 · validation/unit/infra/test_discovery.py:165 · validation/bench/macaulay2_normalization.py:207 · validation/bench/macaulay2_normalization.py:212

`commalg.Ideal.norm`¶

Absolute integral-ideal norm.

PythonRust

(self) -> int

noether::commalg::Ideal::norm · Direct Rust declaration

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

Executable usage: examples/06_shortest_lattice_vectors.py:15 · examples/08_finite_field_extensions.py:13 · examples/08_finite_field_extensions.py:14 · examples/08_finite_field_extensions.py:3 · examples/12_number_field_ideals.py:16 · examples/12_number_field_ideals.py:18

`commalg.Ideal.normal_form`¶

Canonical normal form modulo a polynomial ideal.

Detailed contract

Euclidean strong normal form modulo this integral ideal. Canonical normal form modulo this ideal.

PythonRust

(self, value: Polynomial[CoefficientRing]) -> Polynomial[CoefficientRing]

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

pub fn normal_form( &self, value: &Polynomial<IntegerRing>, ) -> Result<Polynomial<IntegerRing>, GroebnerError>
pub fn normal_form( &self, value: &Polynomial<R>, ) -> Result<Polynomial<R>, 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	released
Semantic ID	noether/commalg/Ideal@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.Ideal.normal_forms`¶

Canonical normal forms of several values modulo a polynomial ideal.

Detailed contract

Euclidean strong normal forms of several values, in input order. Canonical normal forms of several values modulo this ideal. Supported packed contexts share reducer and monomial storage across the complete batch. Results retain the input order.

PythonRust

(self, values: Sequence[Polynomial[CoefficientRing]]) -> list[Polynomial[CoefficientRing]]

noether::commalg::Ideal::normal_forms · Direct Rust declaration

pub fn normal_forms( &self, values: &[Polynomial<IntegerRing>], ) -> Result<Vec<Polynomial<IntegerRing>>, GroebnerError>
pub fn normal_forms( &self, values: &[Polynomial<R>], ) -> Result<Vec<Polynomial<R>>, 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	released
Semantic ID	noether/commalg/Ideal@1

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:53 · validation/unit/infra/test_discovery.py:179 · validation/bench/macaulay2_derived.py:689 · validation/bench/macaulay2_derived.py:692 · validation/bench/macaulay2_derived.py:699

`commalg.Ideal.normalization`¶

Verified integral closure and conductor of an affine domain.

Detailed contract

Compute a verified finite birational normalization when a native route applies.

PythonRust

(self: Ideal[PolynomialRing[RationalField]]) -> AffineNormalization[RationalField]
(self: Ideal[PolynomialRing[FiniteField]]) -> AffineNormalization[FiniteField]

noether::commalg::Ideal::normalization · Direct Rust declaration

pub fn normalization( &self, ) -> Result<AffineNormalization<RationalField>, AffineNormalizationError>
pub fn normalization( &self, ) -> Result<AffineNormalization<FiniteField>, AffineNormalizationError>

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

Executable usage: examples/26_elliptic_descent_functions.py:3 · examples/26_elliptic_descent_functions.py:36 · examples/26_elliptic_descent_functions.py:39 · examples/26_elliptic_descent_functions.py:40 · examples/36_affine_normalization.py:13 · examples/36_affine_normalization.py:14

`commalg.Ideal.normalization_from_smooth_model`¶

Admit an explicit smooth affine complete-intersection normal model.

Detailed contract

Admit a supplied smooth affine complete-intersection model as the normalization after exact finite, birational, normality, and conductor checks.

PythonRust

(self: Ideal[PolynomialRing[RationalField]], normal_ideal: Ideal[PolynomialRing[RationalField]], coordinate_images: list[Polynomial[RationalField]], integral_equations: list[list[Polynomial[RationalField]]], fraction_numerators: list[Polynomial[RationalField]], fraction_denominators: list[Polynomial[RationalField]]) -> AffineNormalization[RationalField]
(self: Ideal[PolynomialRing[FiniteField]], normal_ideal: Ideal[PolynomialRing[FiniteField]], coordinate_images: list[Polynomial[FiniteField]], integral_equations: list[list[Polynomial[FiniteField]]], fraction_numerators: list[Polynomial[FiniteField]], fraction_denominators: list[Polynomial[FiniteField]]) -> AffineNormalization[FiniteField]

noether::commalg::Ideal::normalization_from_smooth_model · Direct Rust declaration

pub fn normalization_from_smooth_model( &self, normal_ideal: Ideal<PolynomialRing<RationalField>>, coordinate_images: Vec<Polynomial<RationalField>>, integral_equations: Vec<Vec<Polynomial<RationalField>>>, fraction_numerators: Vec<Polynomial<RationalField>>, fraction_denominators: Vec<Polynomial<RationalField>>, ) -> Result<AffineNormalization<RationalField>, AffineNormalizationError>
pub fn normalization_from_smooth_model( &self, normal_ideal: Ideal<PolynomialRing<FiniteField>>, coordinate_images: Vec<Polynomial<FiniteField>>, integral_equations: Vec<Vec<Polynomial<FiniteField>>>, fraction_numerators: Vec<Polynomial<FiniteField>>, fraction_denominators: Vec<Polynomial<FiniteField>>, ) -> Result<AffineNormalization<FiniteField>, AffineNormalizationError>

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

Executable usage: validation/unit/commalg/test_affine_normalization_facade.py:154 · validation/unit/infra/test_discovery.py:170

`commalg.Ideal.nullstellensatz_certificate`¶

Exact coefficient-contraction Nullstellensatz identity over Z.

Detailed contract

Produce the exact positive coefficient-contraction generator and multiplier identity when the generic fiber is empty.

PythonRust

(self: Ideal[PolynomialRing[IntegerRing]]) -> ArithmeticNullstellensatzCertificate

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

pub fn nullstellensatz_certificate( &self, ) -> Result<ArithmeticNullstellensatzCertificate, ArithmeticIdealError>

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/Ideal@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.Ideal.pow`¶

Nonnegative ideal power, with I^0 equal to the unit ideal.

Detailed contract

Nonnegative power of this ideal, with exponent zero equal to the unit ideal. Nonnegative power of this principal ideal, with exponent zero equal to (1).

PythonRust

(self: Ideal[IntegerRing], exponent: int) -> Ideal[IntegerRing]
(self: Ideal[PolynomialRing[T]], exponent: int) -> Ideal[PolynomialRing[T]]

noether::commalg::Ideal::pow · Direct Rust declaration

pub fn pow(&self, exponent: u64) -> Result<Self, GroebnerError>
pub fn pow(&self, exponent: u64) -> Self

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

Executable usage: examples/17_weighted_power_series.py:18 · validation/unit/commalg/test_polynomial_ideal_facade.py:368 · validation/unit/commalg/test_polynomial_ideal_facade.py:369 · validation/unit/commalg/test_polynomial_ideal_facade.py:370 · validation/unit/commalg/test_polynomial_ideal_facade.py:373 · validation/unit/commalg/test_polynomial_ideal_facade.py:381

`commalg.Ideal.primary_decomposition`¶

Complete verified primary decomposition in the admitted exact regimes.

Detailed contract

Compute a complete verified primary decomposition in the admitted rational regimes. Compute a complete verified primary decomposition in the admitted finite-field regimes.

PythonRust

(self: Ideal[PolynomialRing[RationalField]]) -> PrimaryDecomposition[RationalField]
(self: Ideal[PolynomialRing[FiniteField]]) -> PrimaryDecomposition[FiniteField]

noether::commalg::Ideal::primary_decomposition · Direct Rust declaration

pub fn primary_decomposition( &self, ) -> Result<PrimaryDecomposition<RationalField>, DecompositionError>
pub fn primary_decomposition( &self, ) -> Result<PrimaryDecomposition<FiniteField>, DecompositionError>

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

`commalg.Ideal.principal_generator`¶

Canonical nonnegative generator of a principal ideal of Z.

Detailed contract

Unique nonnegative generator of this principal ideal.

PythonRust

(self: Ideal[IntegerRing]) -> int

noether::commalg::Ideal::principal_generator · Direct Rust declaration

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

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:300 · validation/unit/commalg/test_polynomial_ideal_facade.py:334

`commalg.Ideal.product`¶

Product of two ideals in the same supported exact context.

Detailed contract

Product of two ideals in this exact integral polynomial context. Product of two ideals in this exact polynomial context. Product of principal ideals.

PythonRust

(self: Ideal[IntegerRing], other: Ideal[IntegerRing]) -> Ideal[IntegerRing]
(self: Ideal[PolynomialRing[T]], other: Ideal[PolynomialRing[T]]) -> Ideal[PolynomialRing[T]]

noether::commalg::Ideal::product · Direct Rust declaration

pub fn product(&self, other: &Self) -> Result<Self, GroebnerError>
pub fn product(&self, other: &Self) -> Self

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

Executable usage: examples/33_simplicial_cohomology_operations.py:27 · validation/unit/combin/test_acceptance_workload.py:41 · validation/unit/combin/test_acceptance_workload.py:43 · validation/unit/combin/test_acceptance_workload.py:44 · validation/unit/combin/test_acceptance_workload.py:45 · validation/unit/commalg/test_polynomial_facade.py:234

`commalg.Ideal.radical`¶

Proved radical of an admitted ideal over Q or a finite field.

Detailed contract

Prove the radical of an admitted rational polynomial ideal. Prove the radical of an admitted finite-field polynomial ideal.

PythonRust

(self: Ideal[PolynomialRing[RationalField]]) -> RadicalIdeal[RationalField]
(self: Ideal[PolynomialRing[FiniteField]]) -> RadicalIdeal[FiniteField]

noether::commalg::Ideal::radical · Direct Rust declaration

pub fn radical(&self) -> Result<RadicalIdeal<RationalField>, DecompositionError>
pub fn radical(&self) -> Result<RadicalIdeal<FiniteField>, DecompositionError>

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

Executable usage: validation/unit/commalg/test_monomial_ideal_facade.py:35 · validation/unit/commalg/test_polynomial_ideal_facade.py:1000 · validation/unit/commalg/test_polynomial_ideal_facade.py:1023 · validation/unit/commalg/test_polynomial_ideal_facade.py:1034 · validation/unit/commalg/test_polynomial_ideal_facade.py:1035 · validation/unit/commalg/test_polynomial_ideal_facade.py:1036

`commalg.Ideal.rational_univariate_representation`¶

Construct a verified rational univariate representation.

Detailed contract

Construct a verified rational univariate representation when the quotient algebra admits a primitive linear form in the bounded native search.

PythonRust

(self) -> RationalUnivariateRepresentation[C]

noether::commalg::Ideal::rational_univariate_representation · Direct Rust declaration

pub fn rational_univariate_representation( &self, ) -> Result<RationalUnivariateRepresentation<R>, 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	released
Semantic ID	noether/commalg/Ideal@1

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:112 · validation/unit/commalg/test_polynomial_ideal_facade.py:1142 · validation/unit/commalg/test_polynomial_ideal_facade.py:1169 · validation/unit/commalg/test_polynomial_ideal_facade.py:1174 · validation/unit/commalg/test_polynomial_ideal_facade.py:1198 · validation/unit/commalg/test_polynomial_ideal_facade.py:151

`commalg.Ideal.reduce`¶

Canonical normal form with exact multiplier evidence.

Detailed contract

Canonical strong normal form with exact multiplier evidence. Canonical normal form together with exact multipliers for this ideal’s canonical generators.

PythonRust

(self: Ideal[PolynomialRing[T]], value: Polynomial[T]) -> IdealReduction[T]

noether::commalg::Ideal::reduce · Direct Rust declaration

pub fn reduce( &self, value: &Polynomial<IntegerRing>, ) -> Result<IdealReduction<IntegerRing>, GroebnerError>
pub fn reduce( &self, value: &Polynomial<R>, ) -> Result<IdealReduction<R>, 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	released
Semantic ID	noether/commalg/Ideal@1

Executable usage: examples/30_modules_and_resolutions.py:28 · validation/unit/commalg/test_local_algebra.py:56 · validation/unit/commalg/test_polynomial_ideal_facade.py:270 · validation/unit/commalg/test_polynomial_ideal_facade.py:304 · validation/unit/homalg/test_local_module.py:28 · validation/unit/homalg/test_module_facade.py:525

`commalg.Ideal.reduced_normalization`¶

Normalize a reduced affine algebra as a product of normal domains.

Detailed contract

Normalize a reduced affine algebra componentwise.

PythonRust

(self: Ideal[PolynomialRing[RationalField]]) -> ReducedAffineNormalization[RationalField]
(self: Ideal[PolynomialRing[FiniteField]]) -> ReducedAffineNormalization[FiniteField]

noether::commalg::Ideal::reduced_normalization · Direct Rust declaration

pub fn reduced_normalization( &self, ) -> Result<ReducedAffineNormalization<RationalField>, ReducedNormalizationError>
pub fn reduced_normalization( &self, ) -> Result<ReducedAffineNormalization<FiniteField>, ReducedNormalizationError>

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

Executable usage: validation/unit/commalg/test_affine_normalization_facade.py:178 · validation/unit/commalg/test_affine_normalization_facade.py:212 · validation/unit/commalg/test_affine_normalization_facade.py:225 · validation/unit/commalg/test_affine_normalization_facade.py:235 · validation/unit/infra/test_discovery.py:171 · validation/bench/macaulay2_affine_normalization.py:239

`commalg.Ideal.rees_algebra`¶

Compute rees algebra for this Ideal.

Detailed contract

Construct the Rees algebra of this ideal.

PythonRust

(self: Ideal[PolynomialRing[RationalField]]) -> ReesAlgebra[RationalField]
(self: Ideal[PolynomialRing[FiniteField]]) -> ReesAlgebra[FiniteField]

noether::commalg::Ideal::rees_algebra · Direct Rust declaration

pub fn rees_algebra(&self) -> Result<ReesAlgebra<R>, ConstructionAlgebraError>

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

Executable usage: validation/unit/commalg/test_construction_algebras.py:61 · validation/unit/commalg/test_construction_algebras.py:69 · validation/unit/infra/test_discovery.py:166

`commalg.Ideal.ring`¶

Coefficient ring of this ideal.

Detailed contract

The coefficient ring of this ideal.

PythonRust

(self) -> C

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

pub fn 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/Ideal@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.Ideal.saturate`¶

Exact saturation self : other^infinity in one polynomial context.

Detailed contract

Exact saturation self : other^infinity, bounded by a fixed number of canonical colon iterations.

PythonRust

(self, other: Ideal[C]) -> Ideal[C]

noether::commalg::Ideal::saturate · Direct Rust declaration

pub fn saturate(&self, other: &Self) -> Result<Self, 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	released
Semantic ID	noether/commalg/Ideal@1

Executable usage: validation/unit/commalg/test_monomial_ideal_facade.py:36 · validation/unit/commalg/test_polynomial_ideal_facade.py:348 · validation/unit/commalg/test_polynomial_ideal_facade.py:350 · validation/corpus/commalg/dingdong-weighted-critical-ideal.py:23 · validation/corpus/commalg/foliation-singular-scheme-saturation.py:33 · validation/corpus/commalg/singular-locus-saturation.py:15

`commalg.Ideal.sum`¶

Sum of two ideals in the same supported exact context.

Detailed contract

Sum of two ideals in this exact integral polynomial context. Sum of two ideals in this exact polynomial context. Sum of principal ideals, whose positive generator is a gcd.

PythonRust

(self: Ideal[IntegerRing], other: Ideal[IntegerRing]) -> Ideal[IntegerRing]
(self: Ideal[PolynomialRing[T]], other: Ideal[PolynomialRing[T]]) -> Ideal[PolynomialRing[T]]

noether::commalg::Ideal::sum · Direct Rust declaration

pub fn sum(&self, other: &Self) -> Result<Self, GroebnerError>
pub fn sum(&self, other: &Self) -> Self

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

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

`commalg.Ideal.to_json`¶

Canonical JSON representation.

Detailed contract

Serialize the polynomial context and canonical strong basis. Serialize the polynomial ring and canonical reduced basis. Serialize the canonical principal ideal as typed JSON. Serialize this canonical integral ideal to JSON.

PythonRust

(self) -> str

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

pub fn to_json(&self) -> Result<String, NoetherError>
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/Ideal@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.Ideal.verify`¶

Recheck the context-specific canonical ideal representation.

Detailed contract

Recompute and verify canonical strong-basis identity. Recompute and verify canonical reduced-basis identity. The independent Buchberger-criterion check budgets each critical pair and the whole verification separately and refuses with GroebnerError::ResourceLimit naming that verification budget when either is exhausted. Recheck the unique nonnegative-generator convention. Recompute and verify the canonical integral lattice basis.

PythonRust

(self) -> None

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

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

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

commalg · Ideal¶

Worked example¶

commalg.Ideal¶

commalg.Ideal.__add__¶

commalg.Ideal.__contains__¶

commalg.Ideal.__mul__¶

commalg.Ideal.__pow__¶

commalg.Ideal.admit_primary_decomposition¶

commalg.Ideal.arithmetic_fiber_support¶

commalg.Ideal.associated_graded_algebra¶

commalg.Ideal.associated_primes¶

commalg.Ideal.base_change¶

commalg.Ideal.base_change_constant_field¶

commalg.Ideal.certify_primary¶

commalg.Ideal.change_order¶

commalg.Ideal.colon¶

commalg.Ideal.contract¶

commalg.Ideal.contract_to_coefficients¶

commalg.Ideal.degree¶

commalg.Ideal.dimension¶

commalg.Ideal.eliminate¶

commalg.Ideal.eliminate_with_evidence¶

commalg.Ideal.equidimensional_hull¶

commalg.Ideal.equidimensional_radical_decomposition¶

commalg.Ideal.finite_quotient_algebra¶

commalg.Ideal.from_json¶

commalg.Ideal.generators¶

commalg.Ideal.grauert_remmert_step¶

commalg.Ideal.groebner_basis¶

commalg.Ideal.hilbert_numerator¶

commalg.Ideal.hilbert_polynomial¶

commalg.Ideal.hilbert_series¶

commalg.Ideal.initial_ideal¶

commalg.Ideal.intersection¶

commalg.Ideal.minimal_primes¶

commalg.Ideal.noether_normalization¶

commalg.Ideal.norm¶

commalg.Ideal.normal_form¶

commalg.Ideal.normal_forms¶

commalg.Ideal.normalization¶

commalg.Ideal.normalization_from_smooth_model¶

commalg.Ideal.nullstellensatz_certificate¶

commalg.Ideal.pow¶

commalg.Ideal.primary_decomposition¶

commalg.Ideal.principal_generator¶

commalg.Ideal.product¶

commalg.Ideal.radical¶

commalg.Ideal.rational_univariate_representation¶

commalg.Ideal.reduce¶

commalg.Ideal.reduced_normalization¶

commalg.Ideal.rees_algebra¶

commalg.Ideal.ring¶

commalg.Ideal.saturate¶

commalg.Ideal.sum¶

commalg.Ideal.to_json¶

commalg.Ideal.verify¶

`commalg.Ideal`¶

`commalg.Ideal.add`¶

`commalg.Ideal.contains`¶

`commalg.Ideal.mul`¶

`commalg.Ideal.pow`¶

`commalg.Ideal.admit_primary_decomposition`¶

`commalg.Ideal.arithmetic_fiber_support`¶

`commalg.Ideal.associated_graded_algebra`¶

`commalg.Ideal.associated_primes`¶

`commalg.Ideal.base_change`¶

`commalg.Ideal.base_change_constant_field`¶

`commalg.Ideal.certify_primary`¶

`commalg.Ideal.change_order`¶

`commalg.Ideal.colon`¶

`commalg.Ideal.contract`¶

`commalg.Ideal.contract_to_coefficients`¶

`commalg.Ideal.degree`¶

`commalg.Ideal.dimension`¶

`commalg.Ideal.eliminate`¶

`commalg.Ideal.eliminate_with_evidence`¶

`commalg.Ideal.equidimensional_hull`¶

`commalg.Ideal.equidimensional_radical_decomposition`¶

`commalg.Ideal.finite_quotient_algebra`¶

`commalg.Ideal.from_json`¶

`commalg.Ideal.generators`¶

`commalg.Ideal.grauert_remmert_step`¶

`commalg.Ideal.groebner_basis`¶

`commalg.Ideal.hilbert_numerator`¶

`commalg.Ideal.hilbert_polynomial`¶

`commalg.Ideal.hilbert_series`¶

`commalg.Ideal.initial_ideal`¶

`commalg.Ideal.intersection`¶

`commalg.Ideal.minimal_primes`¶

`commalg.Ideal.noether_normalization`¶

`commalg.Ideal.norm`¶

`commalg.Ideal.normal_form`¶

`commalg.Ideal.normal_forms`¶

`commalg.Ideal.normalization`¶

`commalg.Ideal.normalization_from_smooth_model`¶

`commalg.Ideal.nullstellensatz_certificate`¶

`commalg.Ideal.pow`¶

`commalg.Ideal.primary_decomposition`¶

`commalg.Ideal.principal_generator`¶

`commalg.Ideal.product`¶

`commalg.Ideal.radical`¶

`commalg.Ideal.rational_univariate_representation`¶

`commalg.Ideal.reduce`¶

`commalg.Ideal.reduced_normalization`¶

`commalg.Ideal.rees_algebra`¶

`commalg.Ideal.ring`¶

`commalg.Ideal.saturate`¶

`commalg.Ideal.sum`¶

`commalg.Ideal.to_json`¶

`commalg.Ideal.verify`¶