### Navigation

- index
- modules |
- next |
- previous |
- General Rings, Ideals, and Morphisms »

# 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.

TESTS:

    sage: R.<x> = PolynomialRing(ZZ)
    sage: I = R.ideal([4 + 3*x + x^2, 1 + x^2])
    sage: S = R.quotient_ring(I);

Todo

The following skipped tests should be removed once trac ticket #13999 is fixed:

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

In trac ticket #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: 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 CartesianProduct(*[R.gens()]*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)
    sage: I3 = PowerIdeal(F,3); I3
    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 seves 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)
    sage: Q3
    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
    16 + 32*a + 32*b + 24*a^2 + 24*a*b + 24*b*a + 24*b^2
    sage: Q3.is_commutative()
    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()
    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
    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)
    sage: Q2.is_commutative()
    True
    sage: (a+b+2)^4
    16 + 32*a + 32*b

Since trac ticket #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: F.<x,y,z> = FreeAlgebra(QQ, implementation='letterplace')
    sage: Q3 = F.quo(F*[F.prod(m) for m in CartesianProduct(*[F.gens()]*3)]*F)
    sage: Q3
    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
    xbar*ybar - ybar*xbar
    sage: Q3.0*(Q3.1*Q3.2)-(Q3.1*Q3.2)*Q3.0
    0
    sage: Q2 = F.quo(F*[F.prod(m) for m in CartesianProduct(*[F.gens()]*2)]*F)
    sage: Q2.is_commutative()
    True

`sage.rings.quotient_ring.``QuotientRing`(R, I, names=None)

  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\).

  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: R.<xx> = QuotientRing(QQ[x], QQ[x].ideal(x^2 + 1)); R
      Univariate Quotient Polynomial Ring in xx over Rational Field with modulus x^2 + 1
      sage: R.gens(); R.gen()
      (xx,)
      xx
      sage: for n in range(4): xx^n
      1
      xx
      -1
      -xx

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

  Sage coerces objects into ideals when possible:

      sage: R = QuotientRing(QQ[x], x^2 + 1); R
      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))
      sage: T.<c,d> = QuotientRing(S,S.ideal(a))
      sage: T
      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()
      (x, y)
      (a, b)
      (0, d)
      sage: for n in range(4): d^n
      1
      d
      -1
      -d

  TESTS:

  By trac ticket #11068, the following does not return a generic quotient ring but a usual quotient of the integer ring:

      sage: R = Integers(8)
      sage: I = R.ideal(2)
      sage: R.quotient(I)
      Ring of integers modulo 2

  Here is an example of the quotient of a free algebra by a twosided homogeneous ideal (see trac ticket #7797):

      sage: F.<x,y,z> = FreeAlgebra(QQ, implementation='letterplace')
      sage: I = F*[x*y+y*z,x^2+x*y-y*x-y^2]*F
      sage: Q.<a,b,c> = F.quo(I); Q
      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
      -b*c
      sage: a^3
      -b*c*a - b*c*b - b*c*c
      sage: J = Q*[a^3-b^3]*Q
      sage: R.<i,j,k> = Q.quo(J); R
      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
      -j*k*i - j*k*j - j*k*k
      sage: j^3
      -j*k*i - j*k*j - j*k*k

  Check that trac ticket #5978 is fixed by if we quotient by the zero ideal \((0)\) then we just return `R`:

      sage: R = QQ['x']
      sage: R.quotient(R.zero_ideal())
      Univariate Polynomial Ring in x over Rational Field
      sage: R.<x> = PolynomialRing(ZZ)
      sage: R is R.quotient(R.zero_ideal())
      True
      sage: I = R.ideal(0)
      sage: R is R.quotient(I)
      True

class `sage.rings.quotient_ring.``QuotientRing_generic`(R, I, names, category=None)

  Bases: `sage.rings.quotient_ring.QuotientRing_nc`, `sage.rings.ring.CommutativeRing`

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

  EXAMPLE:

      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: `sage.rings.ring.Ring`, `sage.structure.parent_gens.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')
      sage: I = F*[x*y+y*z,x^2+x*y-y*x-y^2]*F
      sage: Q.<a,b,c> = F.quo(I); Q
      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
      -b*c
      sage: a^3
      -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
      sage: R.<i,j,k> = Q.quo(J); R
      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
      -j*k*i - j*k*j - j*k*k
      sage: j^3
      -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)
      sage: a^2 + b^2 == 0
      True
      sage: S(0) == a^2 + b^2
      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)
      sage: T.<c,d> = S.quo(a)
      sage: T
      Quotient of Multivariate Polynomial Ring in x, y over Rational Field by the ideal (x, y^2 + 1)
      sage: T.gens()
      (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: Q = QuotientRing(QQ[x], x^2 + 1)
        sage: Q.cover_ring()
        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')
        sage: I = F*[x*y+y*z,x^2+x*y-y*x-y^2]*F
        sage: Q = F.quo(I)
        sage: Q.construction()
        (QuotientFunctor, Free Associative Unital Algebra on 3 generators (x, y, z) over Rational Field)

    TESTS:

        sage: F, R = Integers(5).construction()
        sage: F(R)
        Ring of integers modulo 5
        sage: F, R = GF(5).construction()
        sage: F(R)
        Finite Field of size 5

  `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()
        sage: pi(x^3+y)
        ybar
        sage: l = pi.lift(x+y^3)
        sage: l
        x
        sage: l = pi.lift(); l
        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)
        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: Q = QuotientRing(QQ[x], x^2 + 1)
        sage: Q.cover_ring()
        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))
        sage: T.<c,d> = QuotientRing(S,S.ideal(a))
        sage: S.defining_ideal()
        Ideal (y^2 + 1) of Multivariate Polynomial Ring in x, y over Rational Field
        sage: T.defining_ideal()
        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))
        sage: T.<c,d> = QuotientRing(S,S.ideal(a))
        sage: T
        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)
        x
        y
        sage: S.gen(0); S.gen(1)
        a
        b
        sage: T.gen(0); T.gen(1)
        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()
        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)
        Ideal (xbar + ybar + 1) of Quotient of Multivariate Polynomial Ring in x, y over Rational Field by the ideal (x^2 + y^2)

    TESTS:

    We create an ideal of a fairly generic integer ring (see trac ticket #5666):

        sage: R = Integers(10)
        sage: R.ideal(1)
        Principal ideal (1) of Ring of integers modulo 10

  `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:

    - Simon King (2011-03-23): See trac ticket #7797.

    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')
        sage: I = F*[x*y+y*z,x^2+x*y-y*x-y^2]*F
        sage: Q = F.quo(I)
        sage: Q.is_commutative()
        False
        sage: Q.1*Q.2==Q.2*Q.1
        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
        sage: R = F.quo(J)
        sage: R.is_commutative()
        True

  `is_field`(proof=True)

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

    TESTS:

        sage: Q = QuotientRing(ZZ,7*ZZ)
        sage: Q.is_field()
        True

    Requires the `is_maximal` method of the defining ideal to be implemented:

        sage: R.<x, y> = ZZ[]
        sage: R.quotient_ring(R.ideal([2, 4 +x])).is_field()
        Traceback (most recent call last):
        ...
        NotImplementedError

  `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()
        True
        sage: R.quo(x^2 - y^2).is_integral_domain()
        False
        sage: R.quo(x^2 - y^2).is_integral_domain(proof=False)
        False
        sage: R.<a,b,c> = ZZ[]
        sage: Q = R.quotient_ring([a, b])
        sage: Q.is_integral_domain()
        Traceback (most recent call last):
        ...
        NotImplementedError
        sage: Q.is_integral_domain(proof=False)
        False

  `is_noetherian`()

    Return `True` if this ring is Noetherian.

    EXAMPLES:

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

        sage: R = QuotientRing(QQ[x], x^2+1)
        sage: R.is_noetherian()
        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)
        sage: S.is_noetherian()
        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()
        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
        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
        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
        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)
        x
        sage: L(S.1)
        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
        -xbar*ybar^2 + 2*ybar^2
        sage: L(z)
        -x*y^2 + 2*y^2
        sage: L(z) == x^3 + 2*y^2
        False

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

        sage: MS = MatrixSpace(GF(5),2,2)
        sage: I = MS*[MS.0*MS.1,MS.2+MS.3]*MS
        sage: Q = MS.quo(I)
        sage: Q.lift()
        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],
        <BLANKLINE>
          [0 0]
          [1 1]
        )
        <BLANKLINE>
          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))
        sage: T.<c,d> = QuotientRing(S,S.ideal(a))
        sage: T
        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()
        (x, y)
        (a, b)
        (0, d)
        sage: R.ngens(); S.ngens(); T.ngens()
        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`.

    EXAMPLE:

        sage: R.<x,y> = PolynomialRing(QQ, 2)
        sage: S = R.quotient(x^2 + y^2)
        sage: S.retract((x+y)^2)
        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')
      sage: I = F*[x*y+y*z,x^2+x*y-y*x-y^2]*F
      sage: Q = F.quo(I)
      sage: is_QuotientRing(Q)
      True
      sage: is_QuotientRing(F)
      False

### Navigation

- index
- modules |
- next |
- previous |
- General Rings, Ideals, and Morphisms »