commalg · RadicalIdeal

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

Worked example

The complete checked program Split rational primes and factor an ideal in the Gaussian integers uses this API directly.

# SPDX-License-Identifier: MIT
# Copyright (c) 2026 Benjamin Antieau and Deven Manam
"""Split rational primes and factor an ideal in the Gaussian integers."""

from noether import Q
from noether.commalg import PolynomialRing
from noether.numthy import NumberField


def main() -> None:
    polynomials = PolynomialRing(Q, ["x"])
    field = NumberField(polynomials.generator("x") ** 2 + 1, name="i")
    order = field.maximal_order()
    primes = order.prime_ideals_above(5)
    assert len(primes) == 2
    assert all(prime.norm() == 5 for prime in primes)
    ideal = order.fractional_ideal([1 + field.generator])
    assert ideal.norm() == 2
    print(f"(5) splits into norms {[prime.norm() for prime in primes]}; N(1+i)={ideal.norm()}")


if __name__ == "__main__":
    main()

Run it with .venv/bin/python examples/12_number_field_ideals.py.

commalg.RadicalIdeal

A proved polynomial-ideal radical with exact route-specific evidence.

PythonRust

class RadicalIdeal

noether::commalg::RadicalIdeal · Direct Rust declaration

pub struct RadicalIdeal<R: Field> { /* private fields */ }

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

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:1000 · validation/unit/commalg/test_polynomial_ideal_facade.py:1026 · validation/unit/commalg/test_polynomial_ideal_facade.py:1116 · validation/unit/commalg/test_polynomial_ideal_facade.py:30 · validation/unit/commalg/test_polynomial_ideal_facade.py:502 · validation/unit/commalg/test_polynomial_ideal_facade.py:509

commalg.RadicalIdeal.affine_linear_pivots

Sorted pivot variables eliminated by an affine-linear ideal.

Detailed contract

Pivot variables eliminated by an affine-linear prime ideal.

PythonRust

(self) -> list[int] | None

noether::commalg::RadicalIdeal::affine_linear_pivots · Direct Rust declaration

pub fn affine_linear_pivots(&self) -> Option<&[usize]>

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

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

commalg.RadicalIdeal.characteristic_polynomials

Multiplication characteristic polynomial for each source variable.

Detailed contract

Characteristic polynomial of multiplication by each source variable. This is empty when a principal or monomial proof applies.

PythonRust

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

noether::commalg::RadicalIdeal::characteristic_polynomials · Direct Rust declaration

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

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

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

commalg.RadicalIdeal.common_factor_residual

Residual source and recursively certified radical for a common-factor split.

PythonRust

(self) -> tuple[Ideal[PolynomialRing[C]], Ideal[PolynomialRing[C]]] | None

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

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

commalg.RadicalIdeal.common_factors

Common irreducible factors and their multiplicities.

Detailed contract

Common irreducible factors when the common-factor route applies. This is present only when the source was proved to have the exact form hJ; the factors include their multiplicities in h.

PythonRust

(self) -> list[tuple[Polynomial[C], int]] | None

noether::commalg::RadicalIdeal::common_factors · Direct Rust declaration

pub fn common_factors(&self) -> Option<&[(Polynomial<R>, u64)]>

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

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

commalg.RadicalIdeal.complete_intersection_codimension

Complete-intersection codimension retained by a Jacobian proof.

Detailed contract

Codimension certified by a complete-intersection Jacobian proof.

PythonRust

(self) -> int | None

noether::commalg::RadicalIdeal::complete_intersection_codimension · Direct Rust declaration

pub fn complete_intersection_codimension(&self) -> Option<usize>

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

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:1059 · validation/unit/commalg/test_polynomial_ideal_facade.py:1110

commalg.RadicalIdeal.coordinate_certificates

Square-free coordinate polynomials adjoined to the source ideal.

Detailed contract

Square-free coordinate polynomials adjoined to the source ideal. This is empty when a principal or monomial proof applies.

PythonRust

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

noether::commalg::RadicalIdeal::coordinate_certificates · Direct Rust declaration

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

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

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:506 · validation/unit/commalg/test_polynomial_ideal_facade.py:512

commalg.RadicalIdeal.factor_split_branches

Strict branch ideals paired with their recursively certified radicals.

PythonRust

(self) -> list[tuple[Ideal[PolynomialRing[C]], Ideal[PolynomialRing[C]]]] | None

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

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

commalg.RadicalIdeal.factor_split_factors

Irreducible factors and multiplicities of the splitting generator.

Detailed contract

Irreducible factors defining the branches of a recursive factor split.

PythonRust

(self) -> list[tuple[Polynomial[C], int]] | None

noether::commalg::RadicalIdeal::factor_split_factors · Direct Rust declaration

pub fn factor_split_factors(&self) -> Option<&[(Polynomial<R>, u64)]>

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

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

commalg.RadicalIdeal.factor_split_generator

Canonical generator whose irreducible factors define recursive branches.

Detailed contract

Canonical source generator used by a recursive factor split.

PythonRust

(self) -> Polynomial[C] | None

noether::commalg::RadicalIdeal::factor_split_generator · Direct Rust declaration

pub fn factor_split_generator(&self) -> Option<&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/RadicalIdeal@1

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

commalg.RadicalIdeal.from_json

Deserialize and independently recompute the radical evidence.

Detailed contract

Deserialize and independently recompute rational radical evidence. Deserialize and independently recompute finite-field radical evidence.

PythonRust

(cls, value: str) -> RadicalIdeal[RationalField | FiniteField]

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

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

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

Canonical radical ideal in the source context.

Detailed contract

Canonical radical ideal in the same polynomial-ring context.

PythonRust

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

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

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

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

Expected-codimension Jacobian minors retained by the radical proof.

PythonRust

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

noether::commalg::RadicalIdeal::jacobian_minors · Direct Rust declaration

pub fn jacobian_minors(&self) -> Option<&[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/RadicalIdeal@1

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:1060 · validation/unit/commalg/test_polynomial_ideal_facade.py:1111

commalg.RadicalIdeal.monomial_proof

Canonical source and square-free monomial ideals for a monomial proof.

Detailed contract

Canonical monomial source and radical when the monomial route applies.

PythonRust

(self) -> tuple[MonomialIdeal[C], MonomialIdeal[C]] | None

noether::commalg::RadicalIdeal::monomial_proof · Direct Rust declaration

pub fn monomial_proof(&self) -> Option<(&MonomialIdeal<R>, &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/RadicalIdeal@1

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:541 · validation/unit/commalg/test_polynomial_ideal_facade.py:550

commalg.RadicalIdeal.polynomial_graph_pivots

Sorted pivot variables eliminated by a polynomial-graph ideal.

Detailed contract

Pivot variables eliminated by a polynomial-graph prime ideal.

PythonRust

(self) -> list[int] | None

noether::commalg::RadicalIdeal::polynomial_graph_pivots · Direct Rust declaration

pub fn polynomial_graph_pivots(&self) -> Option<&[usize]>

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

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:1036 · validation/unit/commalg/test_polynomial_ideal_facade.py:1043 · validation/unit/commalg/test_polynomial_ideal_facade.py:813 · validation/unit/commalg/test_polynomial_ideal_facade.py:856 · validation/unit/commalg/test_polynomial_ideal_facade.py:900 · validation/unit/commalg/test_polynomial_ideal_facade.py:907

commalg.RadicalIdeal.principal_factors

Irreducible factors and source multiplicities for a principal proof.

Detailed contract

Canonical irreducible factors and source multiplicities for a principal ideal.

PythonRust

(self) -> list[tuple[Polynomial[C], int]] | None

noether::commalg::RadicalIdeal::principal_factors · Direct Rust declaration

pub fn principal_factors(&self) -> Option<&[(Polynomial<R>, u64)]>

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

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:540 · validation/unit/commalg/test_polynomial_ideal_facade.py:549

commalg.RadicalIdeal.proof_kind

Canonical name of the exact proof route.

PythonRust

(self) -> str

noether::commalg::RadicalIdeal::proof_kind · Direct Rust declaration

pub const fn proof_kind(&self) -> &'static str

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

Executable usage: examples/36_affine_normalization.py:22 · validation/unit/commalg/test_affine_normalization_facade.py:128 · validation/unit/commalg/test_affine_normalization_facade.py:162 · validation/unit/commalg/test_affine_normalization_facade.py:216 · validation/unit/commalg/test_affine_normalization_facade.py:31 · validation/unit/commalg/test_affine_normalization_facade.py:60

commalg.RadicalIdeal.saturation_split_branches

Closed and principal-open branch ideals paired with their radicals.

PythonRust

(self) -> tuple[tuple[Ideal[PolynomialRing[C]], Ideal[PolynomialRing[C]]], tuple[Ideal[PolynomialRing[C]], Ideal[PolynomialRing[C]]]] | None

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

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

commalg.RadicalIdeal.saturation_split_witness

Polynomial defining the closed and principal-open saturation branches.

Detailed contract

Polynomial whose vanishing and principal open set define a saturation split.

PythonRust

(self) -> Polynomial[C] | None

noether::commalg::RadicalIdeal::saturation_split_witness · Direct Rust declaration

pub fn saturation_split_witness(&self) -> Option<&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/RadicalIdeal@1

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

commalg.RadicalIdeal.singular_locus_dimension

Krull dimension of the retained singular locus.

Detailed contract

Dimension of the retained singular-locus ideal.

PythonRust

(self) -> int | None

noether::commalg::RadicalIdeal::singular_locus_dimension · Direct Rust declaration

pub fn singular_locus_dimension(&self) -> Option<i64>

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

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

commalg.RadicalIdeal.singular_locus_ideal

Singular-locus ideal retained by a complete-intersection proof.

PythonRust

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

noether::commalg::RadicalIdeal::singular_locus_ideal · Direct Rust declaration

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

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

Executable usage: validation/unit/commalg/test_polynomial_ideal_facade.py:1061 · validation/unit/commalg/test_polynomial_ideal_facade.py:1112

commalg.RadicalIdeal.source

Source ideal before nilpotents are removed.

PythonRust

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

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

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

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

Executable usage: examples/09_finite_field_isomorphisms.py:11 · examples/09_finite_field_isomorphisms.py:13 · examples/09_finite_field_isomorphisms.py:9 · examples/30_modules_and_resolutions.py:34 · examples/30_modules_and_resolutions.py:37 · validation/unit/category/test_acceptance_workload.py:25

commalg.RadicalIdeal.theorem

Exact theorem justifying the radical claim.

Detailed contract

Exact theorem used to turn the retained certificates into a radical claim.

PythonRust

(self) -> str

noether::commalg::RadicalIdeal::theorem · Direct Rust declaration

pub const fn theorem(&self) -> &'static str

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

Executable usage: examples/13_chinese_remainder_theorem.py:3 · validation/unit/commalg/test_polynomial_ideal_facade.py:1150 · validation/unit/commalg/test_polynomial_ideal_facade.py:507 · validation/unit/commalg/test_polynomial_ideal_facade.py:583 · validation/unit/commalg/test_polynomial_ideal_facade.py:659 · validation/unit/homalg/test_module_facade.py:509

commalg.RadicalIdeal.to_json

Serialize the complete radical evidence.

PythonRust

(self) -> str

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

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

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

Independently recompute every retained certificate and the radical.

Detailed contract

Independently recompute the rational radical evidence. Independently recompute the finite-field radical evidence.

PythonRust

(self) -> None

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

pub fn verify(&self) -> Result<(), 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/RadicalIdeal@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