Struct QuotientRing 

pub struct QuotientRing<S: CommutativeRing> { /* private fields */ }

The exact quotient of one explicit commutative ring by one canonical ideal.

Context identity is the ambient ring presentation together with the exact defining ideal. The first implemented family is a polynomial ring over an exact field, but neither the public context nor element name encodes that specialization.

Implementations

impl<C: Field> QuotientRing<PolynomialRing<C>>

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

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

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

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

pub fn cotangent_complex( &self, ) -> Result<CotangentComplexPresentation<C>, KahlerDifferentialError>

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

pub fn cotangent_complex_from_generators( &self, generators: &[Polynomial<C>], ) -> Result<CotangentComplexPresentation<C>, KahlerDifferentialError>

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.

pub fn conormal_sequence_from_generators( &self, generators: &[Polynomial<C>], ) -> Result<ConormalSequenceEvidence<C>, KahlerDifferentialError>

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.

impl<S: CommutativeRing> QuotientRing<S>

pub fn base_ring(&self) -> &S

Ambient commutative ring before taking the quotient.

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

Canonical defining ideal in the ambient ring.

impl<R: Field> QuotientRing<PolynomialRing<R>>

pub fn element( &self, value: &Polynomial<R>, ) -> Result<QuotientElement<PolynomialRing<R>>, ContextMismatchError>

Project an ambient polynomial to its canonical quotient element.

pub fn is_graded(&self) -> bool

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

pub fn grading(&self) -> Option<&FreeAbelianGrading>

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

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

Exact Hilbert series computed from the canonical defining ideal.

pub fn hilbert_numerator(&self) -> Result<Vec<Integer>, GroebnerError>

Dense standard-graded Hilbert numerator.

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

Krull dimension, with -1 for the zero ring.

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

Standard-graded multiplicity.

pub fn hilbert_polynomial( &self, ) -> Result<Polynomial<RationalField>, GroebnerError>

Standard Hilbert polynomial in the canonical variable m.

pub fn finite_algebra(&self) -> Result<FiniteQuotientAlgebra<R>, GroebnerError>

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

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>>,

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.

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

where R: Serialize, R::Element: Serialize,

Serialize the complete ambient presentation and canonical defining ideal.

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

where R: for<'de> Deserialize<'de>, R::Element: for<'de> Deserialize<'de>,

Deserialize and revalidate the ambient ring and canonical defining ideal.

Trait Implementations

impl<S: Clone + CommutativeRing> Clone for QuotientRing<S>

fn clone(&self) -> QuotientRing<S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: CommutativeRing> Debug for QuotientRing<S>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, R> Deserialize<'de> for QuotientRing<PolynomialRing<R>>

where R: Field + Deserialize<'de>, R::Element: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S: CommutativeRing> Display for QuotientRing<S>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S: CommutativeRing> PartialEq for QuotientRing<S>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R: Field> Ring for QuotientRing<PolynomialRing<R>>

type Element = QuotientElement<PolynomialRing<R>>

Elements manufactured and validated by this context.

fn contains(&self, value: &Self::Element) -> bool

Test whether a value belongs to this exact context.

fn zero(&self) -> Self::Element

The additive identity in this context.

fn is_zero(&self, value: &Self::Element) -> bool

Test whether a value is the additive identity.

fn one(&self) -> Self::Element

The multiplicative identity in this context.

fn add( &self, left: &Self::Element, right: &Self::Element, ) -> Result<Self::Element, ContextMismatchError>

Add two elements after checking their context.

fn sub( &self, left: &Self::Element, right: &Self::Element, ) -> Result<Self::Element, ContextMismatchError>

Subtract two elements after checking their context.

fn mul( &self, left: &Self::Element, right: &Self::Element, ) -> Result<Self::Element, ContextMismatchError>

Multiply two elements after checking their context.

fn sum_products( &self, products: &[(&Self::Element, &Self::Element)], ) -> Result<Self::Element, ContextMismatchError>

Compute a sum of pairwise products in this context.

fn neg( &self, value: &Self::Element, ) -> Result<Self::Element, ContextMismatchError>

Negate an element after checking its context.

impl<S: CommutativeRing> SemanticType for QuotientRing<S>

const TYPE_ID: &'static str = "noether/commalg/QuotientRing@1"

Versioned, language-neutral semantic identity.

fn canonical_bytes(&self) -> Result<Vec<u8>, NoetherError>

Serialize without backend- or language-specific identity.

fn describe() -> &'static TypeDescription

Return static discovery metadata for the type.

impl<R> Serialize for QuotientRing<PolynomialRing<R>>

where R: Field + Serialize, R::Element: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<R: Field> CommutativeRing for QuotientRing<PolynomialRing<R>>

impl<S: CommutativeRing> Eq for QuotientRing<S>