Quotient Rings#

AUTHORS:

  • William Stein

  • Simon King (2011-04): Put it into the category framework, use the new coercion model.

  • Simon King (2011-04): Quotients of non-commutative rings by twosided ideals.

Todo

The following skipped tests should be removed once github issue #13999 is fixed:

sage: TestSuite(S).run(skip=['_test_nonzero_equal', '_test_elements', '_test_zero'])

In github issue #11068, non-commutative quotient rings \(R/I\) were implemented. The only requirement is that the two-sided ideal \(I\) provides a reduce method so that I.reduce(x) is the normal form of an element \(x\) with respect to \(I\) (i.e., we have I.reduce(x) == I.reduce(y) if \(x-y \in I\), and x - I.reduce(x) in I). Here is a toy example:

sage: from sage.rings.noncommutative_ideals import Ideal_nc
sage: from itertools import product
sage: class PowerIdeal(Ideal_nc):
....:     def __init__(self, R, n):
....:         self._power = n
....:         self._power = n
....:         Ideal_nc.__init__(self, R, [R.prod(m) for m in product(R.gens(), repeat=n)])
....:     def reduce(self,x):
....:         R = self.ring()
....:         return add([c*R(m) for m,c in x if len(m)<self._power],R(0))
sage: F.<x,y,z> = FreeAlgebra(QQ, 3)                                                # optional - sage.combinat sage.modules
sage: I3 = PowerIdeal(F,3); I3                                                      # optional - sage.combinat sage.modules
Twosided Ideal (x^3, x^2*y, x^2*z, x*y*x, x*y^2, x*y*z, x*z*x, x*z*y,
x*z^2, y*x^2, y*x*y, y*x*z, y^2*x, y^3, y^2*z, y*z*x, y*z*y, y*z^2,
z*x^2, z*x*y, z*x*z, z*y*x, z*y^2, z*y*z, z^2*x, z^2*y, z^3) of
Free Algebra on 3 generators (x, y, z) over Rational Field

Free algebras have a custom quotient method that serves at creating finite dimensional quotients defined by multiplication matrices. We are bypassing it, so that we obtain the default quotient:

sage: Q3.<a,b,c> = F.quotient(I3)                                                   # optional - sage.combinat sage.modules
sage: Q3                                                                            # optional - sage.combinat sage.modules
Quotient of Free Algebra on 3 generators (x, y, z) over Rational Field by
the ideal (x^3, x^2*y, x^2*z, x*y*x, x*y^2, x*y*z, x*z*x, x*z*y, x*z^2,
y*x^2, y*x*y, y*x*z, y^2*x, y^3, y^2*z, y*z*x, y*z*y, y*z^2, z*x^2, z*x*y,
z*x*z, z*y*x, z*y^2, z*y*z, z^2*x, z^2*y, z^3)
sage: (a+b+2)^4                                                                     # optional - sage.combinat sage.modules
16 + 32*a + 32*b + 24*a^2 + 24*a*b + 24*b*a + 24*b^2
sage: Q3.is_commutative()                                                           # optional - sage.combinat sage.modules
False

Even though \(Q_3\) is not commutative, there is commutativity for products of degree three:

sage: a*(b*c)-(b*c)*a==F.zero()                                                     # optional - sage.combinat sage.modules
True

If we quotient out all terms of degree two then of course the resulting quotient ring is commutative:

sage: I2 = PowerIdeal(F,2); I2                                                      # optional - sage.combinat sage.modules
Twosided Ideal (x^2, x*y, x*z, y*x, y^2, y*z, z*x, z*y, z^2) of Free Algebra
on 3 generators (x, y, z) over Rational Field
sage: Q2.<a,b,c> = F.quotient(I2)                                                   # optional - sage.combinat sage.modules
sage: Q2.is_commutative()                                                           # optional - sage.combinat sage.modules
True
sage: (a+b+2)^4                                                                     # optional - sage.combinat sage.modules
16 + 32*a + 32*b

Since github issue #7797, there is an implementation of free algebras based on Singular’s implementation of the Letterplace Algebra. Our letterplace wrapper allows to provide the above toy example more easily:

sage: from itertools import product
sage: F.<x,y,z> = FreeAlgebra(QQ, implementation='letterplace')                     # optional - sage.combinat sage.modules
sage: Q3 = F.quo(F*[F.prod(m) for m in product(F.gens(), repeat=3)]*F)              # optional - sage.combinat sage.modules
sage: Q3                                                                            # optional - sage.combinat sage.modules
Quotient of Free Associative Unital Algebra on 3 generators (x, y, z)
 over Rational Field by the ideal (x*x*x, x*x*y, x*x*z, x*y*x, x*y*y, x*y*z, x*z*x, x*z*y, x*z*z, y*x*x, y*x*y, y*x*z, y*y*x, y*y*y, y*y*z, y*z*x, y*z*y, y*z*z, z*x*x, z*x*y, z*x*z, z*y*x, z*y*y, z*y*z, z*z*x, z*z*y, z*z*z)
sage: Q3.0*Q3.1 - Q3.1*Q3.0                                                         # optional - sage.combinat sage.modules
xbar*ybar - ybar*xbar
sage: Q3.0*(Q3.1*Q3.2) - (Q3.1*Q3.2)*Q3.0                                           # optional - sage.combinat sage.modules
0
sage: Q2 = F.quo(F*[F.prod(m) for m in product(F.gens(), repeat=2)]*F)              # optional - sage.combinat sage.modules
sage: Q2.is_commutative()                                                           # optional - sage.combinat sage.modules
True
sage.rings.quotient_ring.QuotientRing(R, I, names=None, **kwds)#

Creates a quotient ring of the ring \(R\) by the twosided ideal \(I\).

Variables are labeled by names (if the quotient ring is a quotient of a polynomial ring). If names isn’t given, ‘bar’ will be appended to the variable names in \(R\).

INPUT:

  • R – a ring.

  • I – a twosided ideal of \(R\).

  • names – (optional) a list of strings to be used as names for the variables in the quotient ring \(R/I\).

  • further named arguments that will be passed to the constructor of the quotient ring instance.

OUTPUT: \(R/I\) - the quotient ring \(R\) mod the ideal \(I\)

ASSUMPTION:

I has a method I.reduce(x) returning the normal form of elements \(x\in R\). In other words, it is required that I.reduce(x)==I.reduce(y) \(\iff x-y \in I\), and x-I.reduce(x) in I, for all \(x,y\in R\).

EXAMPLES:

Some simple quotient rings with the integers:

sage: R = QuotientRing(ZZ, 7*ZZ); R
Quotient of Integer Ring by the ideal (7)
sage: R.gens()
(1,)
sage: 1*R(3); 6*R(3); 7*R(3)
3
4
0

sage: S = QuotientRing(ZZ,ZZ.ideal(8)); S
Quotient of Integer Ring by the ideal (8)
sage: 2*S(4)
0

With polynomial rings (note that the variable name of the quotient ring can be specified as shown below):

sage: P.<x> = QQ[]
sage: R.<xx> = QuotientRing(P, P.ideal(x^2 + 1))                                # optional - sage.libs.pari
sage: R                                                                         # optional - sage.libs.pari
Univariate Quotient Polynomial Ring in xx over Rational Field
 with modulus x^2 + 1
sage: R.gens(); R.gen()                                                         # optional - sage.libs.pari
(xx,)
xx
sage: for n in range(4): xx^n                                                   # optional - sage.libs.pari
1
xx
-1
-xx

sage: P.<x> = QQ[]
sage: S = QuotientRing(P, P.ideal(x^2 - 2))                                     # optional - sage.libs.pari
sage: S                                                                         # optional - sage.libs.pari
Univariate Quotient Polynomial Ring in xbar over Rational Field
 with modulus x^2 - 2
sage: xbar = S.gen(); S.gen()                                                   # optional - sage.libs.pari
xbar
sage: for n in range(3): xbar^n                                                 # optional - sage.libs.pari
1
xbar
2

Sage coerces objects into ideals when possible:

sage: P.<x> = QQ[]
sage: R = QuotientRing(P, x^2 + 1); R                                           # optional - sage.libs.pari
Univariate Quotient Polynomial Ring in xbar over Rational Field
 with modulus x^2 + 1

By Noether’s homomorphism theorems, the quotient of a quotient ring of \(R\) is just the quotient of \(R\) by the sum of the ideals. In this example, we end up modding out the ideal \((x)\) from the ring \(\QQ[x,y]\):

sage: R.<x,y> = PolynomialRing(QQ, 2)
sage: S.<a,b> = QuotientRing(R, R.ideal(1 + y^2))                               # optional - sage.libs.pari
sage: T.<c,d> = QuotientRing(S, S.ideal(a))                                     # optional - sage.libs.pari
sage: T                                                                         # optional - sage.libs.pari
Quotient of Multivariate Polynomial Ring in x, y over Rational Field
 by the ideal (x, y^2 + 1)
sage: R.gens(); S.gens(); T.gens()                                              # optional - sage.libs.pari
(x, y)
(a, b)
(0, d)
sage: for n in range(4): d^n                                                    # optional - sage.libs.pari
1
d
-1
-d
class sage.rings.quotient_ring.QuotientRingIdeal_generic(ring, gens, coerce=True)#

Bases: Ideal_generic

Specialized class for quotient-ring ideals.

EXAMPLES:

sage: Zmod(9).ideal([-6,9])
Ideal (3, 0) of Ring of integers modulo 9
class sage.rings.quotient_ring.QuotientRingIdeal_principal(ring, gens, coerce=True)#

Bases: Ideal_principal, QuotientRingIdeal_generic

Specialized class for principal quotient-ring ideals.

EXAMPLES:

sage: Zmod(9).ideal(-33)
Principal ideal (3) of Ring of integers modulo 9
class sage.rings.quotient_ring.QuotientRing_generic(R, I, names, category=None)#

Bases: QuotientRing_nc, CommutativeRing

Creates a quotient ring of a commutative ring \(R\) by the ideal \(I\).

EXAMPLES:

sage: R.<x> = PolynomialRing(ZZ)
sage: I = R.ideal([4 + 3*x + x^2, 1 + x^2])
sage: S = R.quotient_ring(I); S
Quotient of Univariate Polynomial Ring in x over Integer Ring
 by the ideal (x^2 + 3*x + 4, x^2 + 1)
class sage.rings.quotient_ring.QuotientRing_nc(R, I, names, category=None)#

Bases: Ring, ParentWithGens

The quotient ring of \(R\) by a twosided ideal \(I\).

This class is for rings that do not inherit from CommutativeRing.

EXAMPLES:

Here is a quotient of a free algebra by a twosided homogeneous ideal:

sage: F.<x,y,z> = FreeAlgebra(QQ, implementation='letterplace')                 # optional - sage.combinat sage.modules
sage: I = F * [x*y + y*z, x^2 + x*y - y*x - y^2]*F                              # optional - sage.combinat sage.modules
sage: Q.<a,b,c> = F.quo(I); Q                                                   # optional - sage.combinat sage.modules
Quotient of Free Associative Unital Algebra on 3 generators (x, y, z) over Rational Field
 by the ideal (x*y + y*z, x*x + x*y - y*x - y*y)
sage: a*b                                                                       # optional - sage.combinat sage.modules
-b*c
sage: a^3                                                                       # optional - sage.combinat sage.modules
-b*c*a - b*c*b - b*c*c

A quotient of a quotient is just the quotient of the original top ring by the sum of two ideals:

sage: J = Q * [a^3 - b^3] * Q                                                   # optional - sage.combinat sage.modules
sage: R.<i,j,k> = Q.quo(J); R                                                   # optional - sage.combinat sage.modules
Quotient of Free Associative Unital Algebra on 3 generators (x, y, z) over Rational Field
 by the ideal (-y*y*z - y*z*x - 2*y*z*z, x*y + y*z, x*x + x*y - y*x - y*y)
sage: i^3                                                                       # optional - sage.combinat sage.modules
-j*k*i - j*k*j - j*k*k
sage: j^3                                                                       # optional - sage.combinat sage.modules
-j*k*i - j*k*j - j*k*k

For rings that do inherit from CommutativeRing, we provide a subclass QuotientRing_generic, for backwards compatibility.

EXAMPLES:

sage: R.<x> = PolynomialRing(ZZ,'x')
sage: I = R.ideal([4 + 3*x + x^2, 1 + x^2])
sage: S = R.quotient_ring(I); S
Quotient of Univariate Polynomial Ring in x over Integer Ring
 by the ideal (x^2 + 3*x + 4, x^2 + 1)

sage: R.<x,y> = PolynomialRing(QQ)
sage: S.<a,b> = R.quo(x^2 + y^2)                                                # optional - sage.libs.singular
sage: a^2 + b^2 == 0                                                            # optional - sage.libs.singular
True
sage: S(0) == a^2 + b^2                                                         # optional - sage.libs.singular
True

Again, a quotient of a quotient is just the quotient of the original top ring by the sum of two ideals.

sage: R.<x,y> = PolynomialRing(QQ, 2)
sage: S.<a,b> = R.quo(1 + y^2)                                                  # optional - sage.libs.singular
sage: T.<c,d> = S.quo(a)                                                        # optional - sage.libs.singular
sage: T                                                                         # optional - sage.libs.singular
Quotient of Multivariate Polynomial Ring in x, y over Rational Field
 by the ideal (x, y^2 + 1)
sage: T.gens()                                                                  # optional - sage.libs.singular
(0, d)
Element#

alias of QuotientRingElement

ambient()#

Returns the cover ring of the quotient ring: that is, the original ring \(R\) from which we modded out an ideal, \(I\).

EXAMPLES:

sage: Q = QuotientRing(ZZ, 7 * ZZ)
sage: Q.cover_ring()
Integer Ring

sage: P.<x> = QQ[]
sage: Q = QuotientRing(P, x^2 + 1)                                          # optional - sage.libs.pari
sage: Q.cover_ring()                                                        # optional - sage.libs.pari
Univariate Polynomial Ring in x over Rational Field
characteristic()#

Return the characteristic of the quotient ring.

Todo

Not yet implemented!

EXAMPLES:

sage: Q = QuotientRing(ZZ,7*ZZ)
sage: Q.characteristic()
Traceback (most recent call last):
...
NotImplementedError
construction()#

Returns the functorial construction of self.

EXAMPLES:

sage: R.<x> = PolynomialRing(ZZ,'x')
sage: I = R.ideal([4 + 3*x + x^2, 1 + x^2])
sage: R.quotient_ring(I).construction()
(QuotientFunctor, Univariate Polynomial Ring in x over Integer Ring)
sage: F.<x,y,z> = FreeAlgebra(QQ, implementation='letterplace')             # optional - sage.combinat sage.modules
sage: I = F * [x*y + y*z, x^2 + x*y - y*x - y^2] * F                        # optional - sage.combinat sage.modules
sage: Q = F.quo(I)                                                          # optional - sage.combinat sage.modules
sage: Q.construction()                                                      # optional - sage.combinat sage.modules
(QuotientFunctor,
 Free Associative Unital Algebra on 3 generators (x, y, z) over Rational Field)
cover()#

The covering ring homomorphism \(R \to R/I\), equipped with a section.

EXAMPLES:

sage: R = ZZ.quo(3 * ZZ)
sage: pi = R.cover()
sage: pi
Ring morphism:
  From: Integer Ring
  To:   Ring of integers modulo 3
  Defn: Natural quotient map
sage: pi(5)
2
sage: l = pi.lift()

sage: R.<x,y>  = PolynomialRing(QQ)
sage: Q = R.quo((x^2, y^2))
sage: pi = Q.cover()                                                        # optional - sage.libs.singular
sage: pi(x^3 + y)                                                           # optional - sage.libs.singular
ybar
sage: l = pi.lift(x + y^3)                                                  # optional - sage.libs.singular
sage: l                                                                     # optional - sage.libs.singular
x
sage: l = pi.lift(); l                                                      # optional - sage.libs.singular
Set-theoretic ring morphism:
  From: Quotient of Multivariate Polynomial Ring in x, y over Rational Field
        by the ideal (x^2, y^2)
  To:   Multivariate Polynomial Ring in x, y over Rational Field
  Defn: Choice of lifting map
sage: l(x + y^3)                                                            # optional - sage.libs.singular
x
cover_ring()#

Returns the cover ring of the quotient ring: that is, the original ring \(R\) from which we modded out an ideal, \(I\).

EXAMPLES:

sage: Q = QuotientRing(ZZ, 7 * ZZ)
sage: Q.cover_ring()
Integer Ring

sage: P.<x> = QQ[]
sage: Q = QuotientRing(P, x^2 + 1)                                          # optional - sage.libs.pari
sage: Q.cover_ring()                                                        # optional - sage.libs.pari
Univariate Polynomial Ring in x over Rational Field
defining_ideal()#

Returns the ideal generating this quotient ring.

EXAMPLES:

In the integers:

sage: Q = QuotientRing(ZZ,7*ZZ)
sage: Q.defining_ideal()
Principal ideal (7) of Integer Ring

An example involving a quotient of a quotient. By Noether’s homomorphism theorems, this is actually a quotient by a sum of two ideals:

sage: R.<x,y> = PolynomialRing(QQ, 2)
sage: S.<a,b> = QuotientRing(R, R.ideal(1 + y^2))                           # optional - sage.libs.singular
sage: T.<c,d> = QuotientRing(S, S.ideal(a))                                 # optional - sage.libs.singular
sage: S.defining_ideal()                                                    # optional - sage.libs.singular
Ideal (y^2 + 1) of Multivariate Polynomial Ring in x, y over Rational Field
sage: T.defining_ideal()                                                    # optional - sage.libs.singular
Ideal (x, y^2 + 1) of Multivariate Polynomial Ring in x, y over Rational Field
gen(i=0)#

Returns the \(i\)-th generator for this quotient ring.

EXAMPLES:

sage: R = QuotientRing(ZZ, 7*ZZ)
sage: R.gen(0)
1

sage: R.<x,y> = PolynomialRing(QQ,2)
sage: S.<a,b> = QuotientRing(R, R.ideal(1 + y^2))                           # optional - sage.libs.singular
sage: T.<c,d> = QuotientRing(S, S.ideal(a))                                 # optional - sage.libs.singular
sage: T                                                                     # optional - sage.libs.singular
Quotient of Multivariate Polynomial Ring in x, y over Rational Field
 by the ideal (x, y^2 + 1)
sage: R.gen(0); R.gen(1)                                                    # optional - sage.libs.singular
x
y
sage: S.gen(0); S.gen(1)                                                    # optional - sage.libs.singular
a
b
sage: T.gen(0); T.gen(1)                                                    # optional - sage.libs.singular
0
d
ideal(*gens, **kwds)#

Return the ideal of self with the given generators.

EXAMPLES:

sage: R.<x,y> = PolynomialRing(QQ)
sage: S = R.quotient_ring(x^2 + y^2)
sage: S.ideal()                                                             # optional - sage.libs.pari
Ideal (0) of Quotient of Multivariate Polynomial Ring in x, y
 over Rational Field by the ideal (x^2 + y^2)
sage: S.ideal(x + y + 1)                                                    # optional - sage.libs.pari
Ideal (xbar + ybar + 1) of Quotient of Multivariate Polynomial Ring in x, y
 over Rational Field by the ideal (x^2 + y^2)
is_commutative()#

Tell whether this quotient ring is commutative.

Note

This is certainly the case if the cover ring is commutative. Otherwise, if this ring has a finite number of generators, it is tested whether they commute. If the number of generators is infinite, a NotImplementedError is raised.

AUTHOR:

EXAMPLES:

Any quotient of a commutative ring is commutative:

sage: P.<a,b,c> = QQ[]
sage: P.quo(P.random_element()).is_commutative()
True

The non-commutative case is more interesting:

sage: F.<x,y,z> = FreeAlgebra(QQ, implementation='letterplace')             # optional - sage.combinat sage.modules
sage: I = F * [x*y + y*z, x^2 + x*y - y*x - y^2] * F                        # optional - sage.combinat sage.modules
sage: Q = F.quo(I)                                                          # optional - sage.combinat sage.modules
sage: Q.is_commutative()                                                    # optional - sage.combinat sage.modules
False
sage: Q.1*Q.2 == Q.2*Q.1                                                    # optional - sage.combinat sage.modules
False

In the next example, the generators apparently commute:

sage: J = F * [x*y - y*x, x*z - z*x, y*z - z*y, x^3 - y^3] * F              # optional - sage.combinat sage.modules
sage: R = F.quo(J)                                                          # optional - sage.combinat sage.modules
sage: R.is_commutative()                                                    # optional - sage.combinat sage.modules
True
is_field(proof=True)#

Returns True if the quotient ring is a field. Checks to see if the defining ideal is maximal.

is_integral_domain(proof=True)#

With proof equal to True (the default), this function may raise a NotImplementedError.

When proof is False, if True is returned, then self is definitely an integral domain. If the function returns False, then either self is not an integral domain or it was unable to determine whether or not self is an integral domain.

EXAMPLES:

sage: R.<x,y> = QQ[]
sage: R.quo(x^2 - y).is_integral_domain()                                   # optional - sage.singular
True
sage: R.quo(x^2 - y^2).is_integral_domain()                                 # optional - sage.singular
False
sage: R.quo(x^2 - y^2).is_integral_domain(proof=False)                      # optional - sage.singular
False
sage: R.<a,b,c> = ZZ[]                                                      # optional - sage.singular
sage: Q = R.quotient_ring([a, b])                                           # optional - sage.singular
sage: Q.is_integral_domain()                                                # optional - sage.singular
Traceback (most recent call last):
...
NotImplementedError
sage: Q.is_integral_domain(proof=False)                                     # optional - sage.singular
False
is_noetherian()#

Return True if this ring is Noetherian.

EXAMPLES:

sage: R = QuotientRing(ZZ, 102 * ZZ)
sage: R.is_noetherian()
True

sage: P.<x> = QQ[]
sage: R = QuotientRing(P, x^2 + 1)                                          # optional - sage.libs.pari
sage: R.is_noetherian()                                                     # optional - sage.libs.pari
True

If the cover ring of self is not Noetherian, we currently have no way of testing whether self is Noetherian, so we raise an error:

sage: R.<x> = InfinitePolynomialRing(QQ)
sage: R.is_noetherian()
False
sage: I = R.ideal([x[1]^2, x[2]])
sage: S = R.quotient(I)                                                     # optional - sage.libs.pari
sage: S.is_noetherian()                                                     # optional - sage.libs.pari
Traceback (most recent call last):
...
NotImplementedError
lift(x=None)#

Return the lifting map to the cover, or the image of an element under the lifting map.

Note

The category framework imposes that Q.lift(x) returns the image of an element \(x\) under the lifting map. For backwards compatibility, we let Q.lift() return the lifting map.

EXAMPLES:

sage: R.<x,y> = PolynomialRing(QQ, 2)
sage: S = R.quotient(x^2 + y^2)
sage: S.lift()                                                              # optional - sage.libs.singular
Set-theoretic ring morphism:
  From: Quotient of Multivariate Polynomial Ring in x, y over Rational Field
        by the ideal (x^2 + y^2)
  To:   Multivariate Polynomial Ring in x, y over Rational Field
  Defn: Choice of lifting map
sage: S.lift(S.0) == x                                                      # optional - sage.libs.singular
True
lifting_map()#

Return the lifting map to the cover.

EXAMPLES:

sage: R.<x,y> = PolynomialRing(QQ, 2)
sage: S = R.quotient(x^2 + y^2)
sage: pi = S.cover(); pi                                                    # optional - sage.libs.singular
Ring morphism:
  From: Multivariate Polynomial Ring in x, y over Rational Field
  To:   Quotient of Multivariate Polynomial Ring in x, y over Rational Field
        by the ideal (x^2 + y^2)
  Defn: Natural quotient map
sage: L = S.lifting_map(); L                                                # optional - sage.libs.singular
Set-theoretic ring morphism:
  From: Quotient of Multivariate Polynomial Ring in x, y over Rational Field
        by the ideal (x^2 + y^2)
  To:   Multivariate Polynomial Ring in x, y over Rational Field
  Defn: Choice of lifting map
sage: L(S.0)                                                                # optional - sage.libs.singular
x
sage: L(S.1)                                                                # optional - sage.libs.singular
y

Note that some reduction may be applied so that the lift of a reduction need not equal the original element:

sage: z = pi(x^3 + 2*y^2); z                                                # optional - sage.libs.singular
-xbar*ybar^2 + 2*ybar^2
sage: L(z)                                                                  # optional - sage.libs.singular
-x*y^2 + 2*y^2
sage: L(z) == x^3 + 2*y^2                                                   # optional - sage.libs.singular
False

Test that there also is a lift for rings that are no instances of Ring (see github issue #11068):

sage: MS = MatrixSpace(GF(5), 2, 2)                                         # optional - sage.modules sage.rings.finite_rings
sage: I = MS * [MS.0*MS.1, MS.2 + MS.3] * MS                                # optional - sage.modules sage.rings.finite_rings
sage: Q = MS.quo(I)                                                         # optional - sage.modules sage.rings.finite_rings
sage: Q.lift()                                                              # optional - sage.modules sage.rings.finite_rings
Set-theoretic ring morphism:
  From: Quotient of Full MatrixSpace of 2 by 2 dense matrices
        over Finite Field of size 5 by the ideal
(
  [0 1]
  [0 0],

  [0 0]
  [1 1]
)

  To:   Full MatrixSpace of 2 by 2 dense matrices over Finite Field of size 5
  Defn: Choice of lifting map
ngens()#

Returns the number of generators for this quotient ring.

Todo

Note that ngens counts 0 as a generator. Does this make sense? That is, since 0 only generates itself and the fact that this is true for all rings, is there a way to “knock it off” of the generators list if a generator of some original ring is modded out?

EXAMPLES:

sage: R = QuotientRing(ZZ, 7*ZZ)
sage: R.gens(); R.ngens()
(1,)
1

sage: R.<x,y> = PolynomialRing(QQ,2)
sage: S.<a,b> = QuotientRing(R, R.ideal(1 + y^2))                           # optional - sage.libs.singular
sage: T.<c,d> = QuotientRing(S, S.ideal(a))                                 # optional - sage.libs.singular
sage: T                                                                     # optional - sage.libs.singular
Quotient of Multivariate Polynomial Ring in x, y over Rational Field
 by the ideal (x, y^2 + 1)
sage: R.gens(); S.gens(); T.gens()                                          # optional - sage.libs.singular
(x, y)
(a, b)
(0, d)
sage: R.ngens(); S.ngens(); T.ngens()                                       # optional - sage.libs.singular
2
2
2
retract(x)#

The image of an element of the cover ring under the quotient map.

INPUT:

  • x – An element of the cover ring

OUTPUT:

The image of the given element in self.

EXAMPLES:

sage: R.<x,y> = PolynomialRing(QQ, 2)
sage: S = R.quotient(x^2 + y^2)
sage: S.retract((x+y)^2)                                                    # optional - sage.libs.singular
2*xbar*ybar
term_order()#

Return the term order of this ring.

EXAMPLES:

sage: P.<a,b,c> = PolynomialRing(QQ)
sage: I = Ideal([a^2 - a, b^2 - b, c^2 - c])
sage: Q = P.quotient(I)
sage: Q.term_order()
Degree reverse lexicographic term order
sage.rings.quotient_ring.is_QuotientRing(x)#

Tests whether or not x inherits from QuotientRing_nc.

EXAMPLES:

sage: from sage.rings.quotient_ring import is_QuotientRing
sage: R.<x> = PolynomialRing(ZZ,'x')
sage: I = R.ideal([4 + 3*x + x^2, 1 + x^2])
sage: S = R.quotient_ring(I)
sage: is_QuotientRing(S)
True
sage: is_QuotientRing(R)
False

sage: F.<x,y,z> = FreeAlgebra(QQ, implementation='letterplace')                 # optional - sage.combinat sage.modules
sage: I = F * [x*y + y*z, x^2 + x*y - y*x - y^2] * F                            # optional - sage.combinat sage.modules
sage: Q = F.quo(I)                                                              # optional - sage.combinat sage.modules
sage: is_QuotientRing(Q)                                                        # optional - sage.combinat sage.modules
True
sage: is_QuotientRing(F)                                                        # optional - sage.combinat sage.modules
False