commalg · QuotientRing¶

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

Worked example¶

The complete checked program Normalize the cusp y^2=x^3 with exact conductor evidence uses this API directly.

# SPDX-License-Identifier: MIT
# Copyright (c) 2026 Benjamin Antieau and Deven Manam
"""Normalize the cusp y^2=x^3 with exact conductor evidence."""

from noether import Q
from noether.commalg import PolynomialRing


def main() -> None:
    ring = PolynomialRing(Q, ["x", "y"])
    x, y = ring.generators()
    cusp = ring.ideal([y**2 - x**3])
    normalization = cusp.normalization()
    normalization.verify()

    target = normalization.normal_algebra.base_ring
    t = target.generator(0)
    assert normalization.coordinate_images == [t**2, t**3]
    assert normalization.source_conductor == ring.ideal([x, y])
    assert not normalization.is_normal
    print(
        f"cusp normalization: x -> t^2, y -> t^3; proof={normalization.proof_kind}, conductor=(x,y)"
    )


if __name__ == "__main__":
    main()

Run it with .venv/bin/python examples/36_affine_normalization.py.

`commalg.QuotientRing`¶

An exact polynomial quotient ring with presentation-exact identity.

PythonRust

class QuotientRing

noether::commalg::QuotientRing · Direct Rust declaration

pub struct QuotientRing<S: 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/QuotientRing@1

Executable usage: validation/unit/commalg/test_quotient_facade.py:14 · validation/unit/commalg/test_quotient_facade.py:192 · validation/unit/commalg/test_quotient_facade.py:28 · validation/unit/commalg/test_quotient_facade.py:41 · validation/unit/commalg/test_quotient_facade.py:58 · validation/unit/infra/test_public_api_index.py:192

`commalg.QuotientRing.call`¶

Coerce the supplied input through this context or mathematical map.

PythonRust

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

noether::commalg::QuotientRing · 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/QuotientRing@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.QuotientRing.base_ring`¶

Ambient polynomial ring before taking the quotient.

Detailed contract

Ambient commutative ring before taking the quotient.

PythonRust

(self) -> PolynomialRing[C]

noether::commalg::QuotientRing::base_ring · Direct Rust declaration

pub fn base_ring(&self) -> &S

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

Executable usage: examples/36_affine_normalization.py:16 · validation/unit/commalg/test_affine_normalization_facade.py:100 · validation/unit/commalg/test_affine_normalization_facade.py:107 · validation/unit/commalg/test_affine_normalization_facade.py:25 · validation/unit/commalg/test_affine_normalization_facade.py:68 · validation/unit/commalg/test_affine_normalization_facade.py:71

`commalg.QuotientRing.conormal_sequence_from_generators`¶

Exact conormal sequence for a possibly redundant equation list.

Detailed contract

Present I/I^2 and its conormal map using an explicit equation list. Unlike the complete-intersection constructor this accepts redundant generators: their exact syzygies remain visible in the returned conormal module. The equations must generate this algebra’s defining ideal exactly.

PythonRust

(self: QuotientRing[RationalField], generators: Sequence[Polynomial[RationalField]]) -> ConormalSequenceEvidence[RationalField]
(self: QuotientRing[FiniteField], generators: Sequence[Polynomial[FiniteField]]) -> ConormalSequenceEvidence[FiniteField]

noether::commalg::QuotientRing::conormal_sequence_from_generators · Direct Rust declaration

pub fn conormal_sequence_from_generators( &self, generators: &[Polynomial<C>], ) -> Result<ConormalSequenceEvidence<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/QuotientRing@1

Executable usage: validation/unit/commalg/test_kahler_differentials.py:117 · validation/unit/infra/test_public_api_index.py:245

`commalg.QuotientRing.cotangent_complex`¶

Proved two-term cotangent complex for the canonical equations.

Detailed contract

Construct the complete-intersection cotangent complex using the canonical reduced ideal generators.

PythonRust

(self: QuotientRing[RationalField]) -> CotangentComplexPresentation[RationalField]
(self: QuotientRing[FiniteField]) -> CotangentComplexPresentation[FiniteField]

noether::commalg::QuotientRing::cotangent_complex · Direct Rust declaration

pub fn cotangent_complex( &self, ) -> Result<CotangentComplexPresentation<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/QuotientRing@1

Executable usage: examples/39_kahler_differentials.py:28 · validation/unit/commalg/test_kahler_differentials.py:146 · validation/unit/commalg/test_kahler_differentials.py:92 · validation/unit/infra/test_public_api_index.py:243

`commalg.QuotientRing.cotangent_complex_from_generators`¶

Proved two-term cotangent complex for an explicit equation list.

Detailed contract

Construct the complete-intersection cotangent complex from an explicit chosen equation list. The equations are first proved to generate this algebra’s canonical ideal. Redundant lists then fail the regular-sequence count check rather than producing a falsely free conormal term.

PythonRust

(self: QuotientRing[RationalField], generators: Sequence[Polynomial[RationalField]]) -> CotangentComplexPresentation[RationalField]
(self: QuotientRing[FiniteField], generators: Sequence[Polynomial[FiniteField]]) -> CotangentComplexPresentation[FiniteField]

noether::commalg::QuotientRing::cotangent_complex_from_generators · Direct Rust declaration

pub fn cotangent_complex_from_generators( &self, generators: &[Polynomial<C>], ) -> Result<CotangentComplexPresentation<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/QuotientRing@1

Executable usage: validation/unit/commalg/test_kahler_differentials.py:122 · validation/unit/infra/test_public_api_index.py:244

`commalg.QuotientRing.cotangent_space_at`¶

Cotangent fiber at an explicit coefficient-field point.

Detailed contract

Cotangent fiber at one explicit rational or finite-field point.

PythonRust

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

noether::commalg::QuotientRing::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/QuotientRing@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.QuotientRing.defining_ideal`¶

Canonical defining ideal in the ambient polynomial ring.

Detailed contract

Canonical defining ideal in the ambient ring.

PythonRust

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

noether::commalg::QuotientRing::defining_ideal · Direct Rust declaration

pub fn defining_ideal(&self) -> &Ideal<S>

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

Executable usage: validation/unit/commalg/test_acceptance_workload.py:107 · validation/unit/commalg/test_acceptance_workload.py:114 · validation/unit/commalg/test_affine_normalization_facade.py:108 · validation/unit/commalg/test_affine_normalization_facade.py:163 · validation/unit/commalg/test_affine_normalization_facade.py:182 · validation/unit/commalg/test_affine_normalization_facade.py:89

`commalg.QuotientRing.degree`¶

Compute degree for this QuotientRing.

Detailed contract

Standard-graded multiplicity.

PythonRust

(self) -> int

noether::commalg::QuotientRing::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/QuotientRing@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.QuotientRing.dimension`¶

Compute dimension for this QuotientRing.

Detailed contract

Krull dimension, with -1 for the zero ring.

PythonRust

(self) -> int

noether::commalg::QuotientRing::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	attached / bounded
Semantic ID	noether/commalg/QuotientRing@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.QuotientRing.element`¶

Project one ambient polynomial to its canonical quotient normal form.

Detailed contract

Project an ambient polynomial to its canonical quotient element.

PythonRust

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

noether::commalg::QuotientRing::element · Direct Rust declaration

pub fn element( &self, value: &Polynomial<R>, ) -> Result<QuotientElement<PolynomialRing<R>>, 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/QuotientRing@1

Executable usage: examples/19_permutation_groups.py:17 · examples/19_permutation_groups.py:18 · examples/30_modules_and_resolutions.py:3 · examples/38_exact_linear_systems.py:52 · examples/38_exact_linear_systems.py:56 · examples/38_exact_linear_systems.py:58

`commalg.QuotientRing.finite_algebra`¶

Compute finite algebra for this QuotientRing.

Detailed contract

Verified standard-monomial basis and multiplication operators for a finite quotient.

PythonRust

(self) -> FiniteQuotientAlgebra[C]

noether::commalg::QuotientRing::finite_algebra · Direct Rust declaration

pub fn finite_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	attached / bounded
Semantic ID	noether/commalg/QuotientRing@1

Executable usage: validation/unit/commalg/test_quotient_facade.py:130

`commalg.QuotientRing.from_json`¶

Deserialize and revalidate a QuotientRing from typed JSON.

Detailed contract

Deserialize and revalidate the ambient ring and canonical defining ideal.

PythonRust

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

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

pub fn from_json(value: &str) -> Result<Self, NoetherError>where R: for<'de> Deserialize<'de>, R::Element: for<'de> Deserialize<'de>,

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

Return the grading recorded by this QuotientRing.

Detailed contract

Ambient grading inherited by this quotient, when the defining ideal is homogeneous.

PythonRust

(self) -> FreeAbelianGrading | None

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

pub fn grading(&self) -> Option<&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/QuotientRing@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.QuotientRing.hilbert_numerator`¶

Compute hilbert numerator for this QuotientRing.

Detailed contract

Dense standard-graded Hilbert numerator.

PythonRust

(self) -> list[int]

noether::commalg::QuotientRing::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/QuotientRing@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.QuotientRing.hilbert_polynomial`¶

Compute hilbert polynomial for this QuotientRing.

Detailed contract

Standard Hilbert polynomial in the canonical variable m.

PythonRust

(self) -> Polynomial[RationalField]

noether::commalg::QuotientRing::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	attached / bounded
Semantic ID	noether/commalg/QuotientRing@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.QuotientRing.hilbert_series`¶

Compute hilbert series for this QuotientRing.

Detailed contract

Exact Hilbert series computed from the canonical defining ideal.

PythonRust

(self) -> HilbertSeries

noether::commalg::QuotientRing::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/QuotientRing@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.QuotientRing.induced_map`¶

Descend an ambient polynomial map after checking every source relation.

Detailed contract

Descend a checked ambient-ring map to a target quotient. Construction verifies that every source defining relation maps to zero in target; failure never creates a partially checked map.

PythonRust

(self, target: QuotientRing[T], base_map: PolynomialHomomorphism[C, Polynomial[T]]) -> QuotientRingMap[C, T]

noether::commalg::QuotientRing::induced_map · Direct Rust declaration

pub fn induced_map<Q, M>( &self, target: &QuotientRing<PolynomialRing<Q>>, base_map: M, ) -> Result<QuotientRingMap<PolynomialRing<R>, PolynomialRing<Q>, M>, QuotientRingMapError>where Q: Field, M: CoefficientMap<Source = PolynomialRing<R>, Target = PolynomialRing<Q>>,

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

Executable usage: validation/unit/commalg/test_quotient_facade.py:100 · validation/unit/commalg/test_quotient_facade.py:113 · validation/unit/commalg/test_quotient_facade.py:86 · validation/unit/commalg/test_rational_function_facade.py:123 · validation/unit/commalg/test_rational_function_facade.py:151 · validation/unit/homalg/test_module_facade.py:316

`commalg.QuotientRing.is_graded`¶

Test whether this QuotientRing is graded.

Detailed contract

Whether the defining ideal is homogeneous in the complete ambient grading.

PythonRust

(self) -> bool

noether::commalg::QuotientRing::is_graded · Direct Rust declaration

pub fn is_graded(&self) -> bool

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

Executable usage: validation/unit/commalg/test_construction_algebras.py:72 · validation/unit/commalg/test_quotient_facade.py:140 · validation/unit/commalg/test_quotient_facade.py:145 · validation/unit/commalg/test_quotient_facade.py:31

`commalg.QuotientRing.kahler_differentials`¶

Exact Kähler differentials over the coefficient field.

Detailed contract

Construct the exact module Omega_{A/C} for this affine algebra.

PythonRust

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

noether::commalg::QuotientRing::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
Dispatch / backing	noether, groebner-kernel, module-core
GIL	released
Semantic ID	noether/commalg/QuotientRing@1
Contexts	affine algebras over Q, affine algebras over finite fields
Evidence	KahlerDifferentials.verify, ConormalSequenceEvidence.verify
Failures	unsupported coefficient context, invalid quotient presentation

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.QuotientRing.one`¶

Compute one for this QuotientRing.

PythonRust

(self) -> QuotientElement[C]

noether::commalg::QuotientRing::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/QuotientRing@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.QuotientRing.to_json`¶

Serialize this QuotientRing to its canonical typed JSON representation.

Detailed contract

Serialize the complete ambient presentation and canonical defining ideal.

PythonRust

(self) -> str

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

pub fn to_json(&self) -> Result<String, NoetherError>where R: Serialize, R::Element: Serialize,

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

Compute zero for this QuotientRing.

PythonRust

(self) -> QuotientElement[C]

noether::commalg::QuotientRing::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/QuotientRing@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

commalg · QuotientRing¶

Worked example¶

commalg.QuotientRing¶

commalg.QuotientRing.__call__¶

commalg.QuotientRing.base_ring¶

commalg.QuotientRing.conormal_sequence_from_generators¶

commalg.QuotientRing.cotangent_complex¶

commalg.QuotientRing.cotangent_complex_from_generators¶

commalg.QuotientRing.cotangent_space_at¶

commalg.QuotientRing.defining_ideal¶

commalg.QuotientRing.degree¶

commalg.QuotientRing.dimension¶

commalg.QuotientRing.element¶

commalg.QuotientRing.finite_algebra¶

commalg.QuotientRing.from_json¶

commalg.QuotientRing.grading¶

commalg.QuotientRing.hilbert_numerator¶

commalg.QuotientRing.hilbert_polynomial¶

commalg.QuotientRing.hilbert_series¶

commalg.QuotientRing.induced_map¶

commalg.QuotientRing.is_graded¶

commalg.QuotientRing.kahler_differentials¶

commalg.QuotientRing.one¶

commalg.QuotientRing.to_json¶

commalg.QuotientRing.zero¶

`commalg.QuotientRing`¶

`commalg.QuotientRing.call`¶

`commalg.QuotientRing.base_ring`¶

`commalg.QuotientRing.conormal_sequence_from_generators`¶

`commalg.QuotientRing.cotangent_complex`¶

`commalg.QuotientRing.cotangent_complex_from_generators`¶

`commalg.QuotientRing.cotangent_space_at`¶

`commalg.QuotientRing.defining_ideal`¶

`commalg.QuotientRing.degree`¶

`commalg.QuotientRing.dimension`¶

`commalg.QuotientRing.element`¶

`commalg.QuotientRing.finite_algebra`¶

`commalg.QuotientRing.from_json`¶

`commalg.QuotientRing.grading`¶

`commalg.QuotientRing.hilbert_numerator`¶

`commalg.QuotientRing.hilbert_polynomial`¶

`commalg.QuotientRing.hilbert_series`¶

`commalg.QuotientRing.induced_map`¶

`commalg.QuotientRing.is_graded`¶

`commalg.QuotientRing.kahler_differentials`¶

`commalg.QuotientRing.one`¶

`commalg.QuotientRing.to_json`¶

`commalg.QuotientRing.zero`¶