passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/rings/generic.py

@@ -0,0 +1,320 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Generic data structures and algorithms for rings
+
+AUTHORS:
+
+- Lorenz Panny (2022): :class:`ProductTree`, :func:`prod_with_derivative`
+"""
+
+from sage.misc.misc_c import prod
+
+
+class ProductTree:
+    r"""
+    A simple binary product tree, i.e., a tree of ring elements in
+    which every node equals the product of its children.
+    (In particular, the *root* equals the product of all *leaves*.)
+
+    Product trees are a very useful building block for fast computer
+    algebra. For example, a quasilinear-time Discrete Fourier Transform
+    (the famous *Fast* Fourier Transform) can be implemented as follows
+    using the :meth:`remainders` method of this class::
+
+        sage: # needs sage.rings.finite_rings
+        sage: from sage.rings.generic import ProductTree
+        sage: F = GF(65537)
+        sage: a = F(1111)
+        sage: assert a.multiplicative_order() == 1024
+        sage: R.<x> = F[]
+        sage: ms = [x - a^i for i in range(1024)]               # roots of unity
+        sage: ys = [F.random_element() for _ in range(1024)]    # input vector
+        sage: tree = ProductTree(ms)
+        sage: zs = tree.remainders(R(ys))                       # compute FFT!
+        sage: zs == [R(ys) % m for m in ms]
+        True
+
+    Similarly, the :meth:`interpolation` method can be used to implement
+    the inverse Fast Fourier Transform::
+
+        sage: tree.interpolation(zs).padded_list(len(ys)) == ys                         # needs sage.rings.finite_rings
+        True
+
+    This class encodes the tree as *layers*: Layer `0` is just a tuple
+    of the leaves. Layer `i+1` is obtained from layer `i` by replacing
+    each pair of two adjacent elements by their product, starting from
+    the left. (If the length is odd, the unpaired element at the end is
+    simply copied as is.) This iteration stops as soon as it yields a
+    layer containing only a single element (the root).
+
+    .. NOTE::
+
+        Use this class if you need the :meth:`remainders` method.
+        To compute just the product, :func:`prod` is likely faster.
+
+    INPUT:
+
+    - ``leaves`` -- an iterable of elements in a common ring
+
+    EXAMPLES::
+
+        sage: from sage.rings.generic import ProductTree
+        sage: R.<x> = GF(101)[]
+        sage: vs = [x - i for i in range(1,10)]
+        sage: tree = ProductTree(vs)
+        sage: tree.root()
+        x^9 + 56*x^8 + 62*x^7 + 44*x^6 + 47*x^5 + 42*x^4 + 15*x^3 + 11*x^2 + 12*x + 13
+        sage: tree.remainders(x^7 + x + 1)
+        [3, 30, 70, 27, 58, 72, 98, 98, 23]
+        sage: tree.remainders(x^100)
+        [1, 1, 1, 1, 1, 1, 1, 1, 1]
+
+    ::
+
+        sage: # needs sage.libs.pari
+        sage: vs = prime_range(100)
+        sage: tree = ProductTree(vs)
+        sage: tree.root().factor()
+        2 * 3 * 5 * 7 * 11 * 13 * 17 * 19 * 23 * 29 * 31 * 37 * 41 * 43 * 47 * 53 * 59 * 61 * 67 * 71 * 73 * 79 * 83 * 89 * 97
+        sage: tree.remainders(3599)
+        [1, 2, 4, 1, 2, 11, 12, 8, 11, 3, 3, 10, 32, 30, 27, 48, 0, 0, 48, 49, 22, 44, 30, 39, 10]
+
+    We can access the individual layers of the tree::
+
+        sage: tree.layers                                                               # needs sage.libs.pari
+        [(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97),
+         (6, 35, 143, 323, 667, 1147, 1763, 2491, 3599, 4757, 5767, 7387, 97),
+         (210, 46189, 765049, 4391633, 17120443, 42600829, 97),
+         (9699690, 3359814435017, 729345064647247, 97),
+         (32589158477190044730, 70746471270782959),
+         (2305567963945518424753102147331756070,)]
+    """
+    def __init__(self, leaves):
+        r"""
+        Initialize a product tree having the given ring elements
+        as its leaves.
+
+        EXAMPLES::
+
+            sage: from sage.rings.generic import ProductTree
+            sage: vs = prime_range(100)                                                 # needs sage.libs.pari
+            sage: tree = ProductTree(vs)                                                # needs sage.libs.pari
+        """
+        V = tuple(leaves)
+        self.layers = [V]
+        while len(V) > 1:
+            V = tuple(prod(V[i:i+2]) for i in range(0,len(V),2))
+            self.layers.append(V)
+
+    def __len__(self):
+        r"""
+        Return the number of leaves of this product tree.
+
+        EXAMPLES::
+
+            sage: from sage.rings.generic import ProductTree
+            sage: R.<x> = GF(101)[]
+            sage: vs = [x - i for i in range(1,10)]
+            sage: tree = ProductTree(vs)
+            sage: len(tree)
+            9
+            sage: len(tree) == len(vs)
+            True
+            sage: len(tree.remainders(x^2))
+            9
+        """
+        return len(self.layers[0])
+
+    def __iter__(self):
+        r"""
+        Return an iterator over the leaves of this product tree.
+
+        EXAMPLES::
+
+            sage: from sage.rings.generic import ProductTree
+            sage: R.<x> = GF(101)[]
+            sage: vs = [x - i for i in range(1,10)]
+            sage: tree = ProductTree(vs)
+            sage: next(iter(tree)) == vs[0]
+            True
+            sage: list(tree) == vs
+            True
+        """
+        return iter(self.layers[0])
+
+    def root(self):
+        r"""
+        Return the value at the root of this product tree (i.e., the product of all leaves).
+
+        EXAMPLES::
+
+            sage: from sage.rings.generic import ProductTree
+            sage: R.<x> = GF(101)[]
+            sage: vs = [x - i for i in range(1,10)]
+            sage: tree = ProductTree(vs)
+            sage: tree.root()
+            x^9 + 56*x^8 + 62*x^7 + 44*x^6 + 47*x^5 + 42*x^4 + 15*x^3 + 11*x^2 + 12*x + 13
+            sage: tree.root() == prod(vs)
+            True
+        """
+        assert len(self.layers[-1]) == 1
+        return self.layers[-1][0]
+
+    def leaves(self):
+        r"""
+        Return a tuple containing the leaves of this product tree.
+
+        EXAMPLES::
+
+            sage: from sage.rings.generic import ProductTree
+            sage: R.<x> = GF(101)[]
+            sage: vs = [x - i for i in range(1,10)]
+            sage: tree = ProductTree(vs)
+            sage: tree.leaves()
+            (x + 100, x + 99, x + 98, ..., x + 93, x + 92)
+            sage: tree.leaves() == tuple(vs)
+            True
+        """
+        return self.layers[0]
+
+    def remainders(self, x):
+        r"""
+        Given a value `x`, return a list of all remainders of `x`
+        modulo the leaves of this product tree.
+
+        The base ring must support the ``%`` operator for this
+        method to work.
+
+        INPUT:
+
+        - ``x`` -- an element of the base ring of this product tree
+
+        EXAMPLES::
+
+            sage: # needs sage.libs.pari
+            sage: from sage.rings.generic import ProductTree
+            sage: vs = prime_range(100)
+            sage: tree = ProductTree(vs)
+            sage: n = 1085749272377676749812331719267
+            sage: tree.remainders(n)
+            [1, 1, 2, 1, 9, 1, 7, 15, 8, 20, 15, 6, 27, 11, 2, 6, 0, 25, 49, 5, 51, 4, 19, 74, 13]
+            sage: [n % v for v in vs]
+            [1, 1, 2, 1, 9, 1, 7, 15, 8, 20, 15, 6, 27, 11, 2, 6, 0, 25, 49, 5, 51, 4, 19, 74, 13]
+        """
+        X = [x]
+        for V in reversed(self.layers):
+            X = [X[i // 2] % V[i] for i in range(len(V))]
+        return X
+
+    _crt_bases = None
+
+    def interpolation(self, xs):
+        r"""
+        Given a sequence ``xs`` of values, one per leaf, return a
+        single element `x` which is congruent to the `i`\th value in
+        ``xs`` modulo the `i`\th leaf, for all `i`.
+
+        This is an explicit version of the Chinese remainder theorem;
+        see also :meth:`CRT`. Using this product tree is faster for
+        repeated calls since the required CRT bases are cached after
+        the first run.
+
+        The base ring must support the :func:`xgcd` function for this
+        method to work.
+
+        EXAMPLES::
+
+            sage: # needs sage.libs.pari
+            sage: from sage.rings.generic import ProductTree
+            sage: vs = prime_range(100)
+            sage: tree = ProductTree(vs)
+            sage: tree.interpolation([1, 1, 2, 1, 9, 1, 7, 15, 8, 20, 15, 6, 27, 11, 2, 6, 0, 25, 49, 5, 51, 4, 19, 74, 13])
+            1085749272377676749812331719267
+
+        This method is faster than :func:`CRT` for repeated calls with
+        the same moduli::
+
+            sage: # needs sage.libs.pari
+            sage: vs = prime_range(1000,2000)
+            sage: rs = lambda: [randrange(1,100) for _ in vs]
+            sage: tree = ProductTree(vs)
+            sage: %timeit CRT(rs(), vs)             # not tested
+            372 µs ± 3.34 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
+            sage: %timeit tree.interpolation(rs())  # not tested
+            146 µs ± 479 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
+        """
+        if self._crt_bases is None:
+            from sage.arith.misc import CRT_basis
+            self._crt_bases = []
+            for V in self.layers[:-1]:
+                B = tuple(CRT_basis(V[i:i+2]) for i in range(0, len(V), 2))
+                self._crt_bases.append(B)
+        if len(xs) != len(self.layers[0]):
+            raise ValueError('number of given elements must equal the number of leaves')
+        for basis, layer in zip(self._crt_bases, self.layers[1:]):
+            xs = [sum(c*x for c, x in zip(cs, xs[2*i:2*i+2])) % mod
+                  for i, (cs, mod) in enumerate(zip(basis, layer))]
+        assert len(xs) == 1
+        return xs[0]
+
+
+def prod_with_derivative(pairs):
+    r"""
+    Given an iterable of pairs `(f, \partial f)` of ring elements,
+    return the pair `(\prod f, \partial \prod f)`, assuming `\partial`
+    is an operator obeying the standard product rule.
+
+    This function is entirely algebraic, hence still works when the
+    elements `f` and `\partial f` are all passed through some ring
+    homomorphism first. One particularly useful instance of this is
+    evaluating the derivative of a product of polynomials at a point
+    without fully expanding the product; see the second example below.
+
+    INPUT:
+
+    - ``pairs`` -- an iterable of tuples `(f, \partial f)` of elements
+      of a common ring
+
+    ALGORITHM: Repeated application of the product rule.
+
+    EXAMPLES::
+
+        sage: from sage.rings.generic import prod_with_derivative
+        sage: R.<x> = ZZ[]
+        sage: fs = [x^2 + 2*x + 3, 4*x + 5, 6*x^7 + 8*x + 9]
+        sage: prod(fs)
+        24*x^10 + 78*x^9 + 132*x^8 + 90*x^7 + 32*x^4 + 140*x^3 + 293*x^2 + 318*x + 135
+        sage: prod(fs).derivative()
+        240*x^9 + 702*x^8 + 1056*x^7 + 630*x^6 + 128*x^3 + 420*x^2 + 586*x + 318
+        sage: F, dF = prod_with_derivative((f, f.derivative()) for f in fs)
+        sage: F
+        24*x^10 + 78*x^9 + 132*x^8 + 90*x^7 + 32*x^4 + 140*x^3 + 293*x^2 + 318*x + 135
+        sage: dF
+        240*x^9 + 702*x^8 + 1056*x^7 + 630*x^6 + 128*x^3 + 420*x^2 + 586*x + 318
+
+    The main reason for this function to exist is that it allows us to
+    *evaluate* the derivative of a product of polynomials at a point
+    `\alpha` without ever fully expanding the product *as a polynomial*::
+
+        sage: alpha = 42
+        sage: F(alpha)
+        442943981574522759
+        sage: dF(alpha)
+        104645261461514994
+        sage: us = [f(alpha) for f in fs]
+        sage: vs = [f.derivative()(alpha) for f in fs]
+        sage: prod_with_derivative(zip(us, vs))
+        (442943981574522759, 104645261461514994)
+    """
+    class _aux:
+        def __init__(self, f, df):
+            self.f, self.df = f, df
+
+        def __mul__(self, other):
+            return _aux(self.f * other.f, self.df * other.f + self.f * other.df)
+
+        def __iter__(self):
+            yield self.f
+            yield self.df
+
+    return tuple(prod(_aux(*tup) for tup in pairs))

sage/rings/homset.py

@@ -0,0 +1,332 @@
+# sage_setup: distribution = sagemath-categories
+"""
+Space of homomorphisms between two rings
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2006 William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+from sage.categories.homset import HomsetWithBase
+from sage.categories.rings import Rings
+
+_Rings = Rings()
+
+from sage.rings import morphism, quotient_ring
+
+
+def is_RingHomset(H):
+    """
+    Return ``True`` if ``H`` is a space of homomorphisms between two rings.
+
+    EXAMPLES::
+
+        sage: from sage.rings.homset import is_RingHomset as is_RH
+        sage: is_RH(Hom(ZZ, QQ))
+        doctest:warning...
+        DeprecationWarning: the function is_RingHomset is deprecated;
+        use 'isinstance(..., RingHomset_generic)' instead
+        See https://github.com/sagemath/sage/issues/37922 for details.
+        True
+        sage: is_RH(ZZ)
+        False
+        sage: is_RH(Hom(RR, CC))                                                        # needs sage.rings.real_mpfr
+        True
+        sage: is_RH(Hom(FreeModule(ZZ,1), FreeModule(QQ,1)))                            # needs sage.modules
+        False
+    """
+    from sage.misc.superseded import deprecation
+    deprecation(37922, "the function is_RingHomset is deprecated; use 'isinstance(..., RingHomset_generic)' instead")
+    return isinstance(H, RingHomset_generic)
+
+
+def RingHomset(R, S, category=None):
+    """
+    Construct a space of homomorphisms between the rings ``R`` and ``S``.
+
+    For more on homsets, see :func:`Hom()`.
+
+    EXAMPLES::
+
+        sage: Hom(ZZ, QQ) # indirect doctest
+        Set of Homomorphisms from Integer Ring to Rational Field
+    """
+    if isinstance(R, quotient_ring.QuotientRing_nc):
+        from .polynomial.polynomial_quotient_ring import PolynomialQuotientRing_generic
+        if not isinstance(R, PolynomialQuotientRing_generic):  # backwards compatibility
+            return RingHomset_quo_ring(R, S, category=category)
+    return RingHomset_generic(R, S, category=category)
+
+
+class RingHomset_generic(HomsetWithBase):
+    """
+    A generic space of homomorphisms between two rings.
+
+    EXAMPLES::
+
+        sage: Hom(ZZ, QQ)
+        Set of Homomorphisms from Integer Ring to Rational Field
+        sage: QQ.Hom(ZZ)
+        Set of Homomorphisms from Rational Field to Integer Ring
+    """
+
+    Element = morphism.RingHomomorphism
+
+    def __init__(self, R, S, category=None):
+        """
+        Initialize ``self``.
+
+        EXAMPLES::
+
+            sage: Hom(ZZ, QQ)
+            Set of Homomorphisms from Integer Ring to Rational Field
+        """
+        if category is None:
+            category = _Rings
+        HomsetWithBase.__init__(self, R, S, category)
+
+    def _repr_(self):
+        """
+        Return a string representation of ``self``.
+
+        EXAMPLES::
+
+            sage: Hom(ZZ, QQ) # indirect doctest
+            Set of Homomorphisms from Integer Ring to Rational Field
+        """
+        return "Set of Homomorphisms from %s to %s" % (self.domain(), self.codomain())
+
+    def has_coerce_map_from(self, x):
+        """
+        The default for coercion maps between ring homomorphism spaces is
+        very restrictive (until more implementation work is done).
+
+        Currently this checks if the domains and the codomains are equal.
+
+        EXAMPLES::
+
+            sage: H = Hom(ZZ, QQ)
+            sage: H2 = Hom(QQ, ZZ)
+            sage: H.has_coerce_map_from(H2)
+            False
+        """
+        return (x.domain() == self.domain() and x.codomain() == self.codomain())
+
+    def _element_constructor_(self, x, check=True, base_map=None):
+        """
+        Construct an element of ``self`` from ``x``.
+
+        EXAMPLES::
+
+            sage: H = Hom(ZZ, QQ)
+            sage: phi = H([1]); phi
+            Ring morphism:
+              From: Integer Ring
+              To:   Rational Field
+              Defn: 1 |--> 1
+            sage: H2 = Hom(QQ, QQ)
+            sage: phi2 = H2(phi); phi2
+            Ring endomorphism of Rational Field
+              Defn: 1 |--> 1
+            sage: H(phi2)
+            Ring morphism:
+              From: Integer Ring
+              To:   Rational Field
+              Defn: 1 |--> 1
+
+        You can provide a morphism on the base::
+
+            sage: # needs sage.rings.finite_rings
+            sage: k = GF(9)
+            sage: z2 = k.gen()
+            sage: cc = k.frobenius_endomorphism()
+            sage: R.<x> = k[]
+            sage: H = Hom(R, R)
+            sage: phi = H([x^2], base_map=cc); phi
+            Ring endomorphism of Univariate Polynomial Ring in x
+             over Finite Field in z2 of size 3^2
+              Defn: x |--> x^2
+                    with map of base ring
+            sage: phi(z2 * x) == z2^3 * x^2
+            True
+
+            sage: R.<x> = ZZ[]
+            sage: K.<a> = GF(7^2)                                                       # needs sage.rings.finite_rings
+            sage: L.<u> = K.extension(x^3 - 3)                                          # needs sage.rings.finite_rings
+            sage: phi = L.hom([u^7], base_map=K.frobenius_endomorphism())               # needs sage.rings.finite_rings
+            sage: phi(u) == u^7                                                         # needs sage.rings.finite_rings
+            True
+            sage: phi(a) == a^7                                                         # needs sage.rings.finite_rings
+            True
+
+        TESTS::
+
+            sage: H = Hom(ZZ, QQ)
+            sage: H == loads(dumps(H))
+            True
+        """
+        from sage.categories.map import Map
+        # Case 0: the homomorphism is given by images of generators
+        if not (isinstance(x, Map) and x.category_for().is_subcategory(Rings())):
+            return morphism.RingHomomorphism_im_gens(self, x, base_map=base_map, check=check)
+        if base_map is not None:
+            raise ValueError("cannot specify base_map when providing a map")
+        # Case 1: the parent fits
+        if x.parent() == self:
+            if isinstance(x, morphism.RingHomomorphism_im_gens):
+                return morphism.RingHomomorphism_im_gens(self, x.im_gens())
+            elif isinstance(x, morphism.RingHomomorphism_cover):
+                return morphism.RingHomomorphism_cover(self)
+            elif isinstance(x, morphism.RingHomomorphism_from_base):
+                return morphism.RingHomomorphism_from_base(self, x.underlying_map())
+        # Case 2: unique extension via fraction field
+        try:
+            if (isinstance(x, morphism.RingHomomorphism_im_gens)
+                and x.domain().fraction_field().has_coerce_map_from(self.domain())):
+                return morphism.RingHomomorphism_im_gens(self, x.im_gens())
+        except (TypeError, ValueError):
+            pass
+        # Case 3: the homomorphism can be extended by coercion
+        try:
+            return x.extend_codomain(self.codomain()).extend_domain(self.domain())
+        except (TypeError, ValueError):
+            pass
+        # Case 4: the homomorphism is induced from the base ring
+        if (self.domain() != self.domain().base()
+            or self.codomain() != self.codomain().base()):
+            x = self.domain().base().Hom(self.codomain().base())(x)
+            return morphism.RingHomomorphism_from_base(self, x)
+        raise ValueError('cannot convert {} to an element of {}'.format(x, self))
+
+    def natural_map(self):
+        """
+        Return the natural map from the domain to the codomain.
+
+        The natural map is the coercion map from the domain ring to the
+        codomain ring.
+
+        EXAMPLES::
+
+            sage: H = Hom(ZZ, QQ)
+            sage: H.natural_map()
+            Natural morphism:
+              From: Integer Ring
+              To:   Rational Field
+        """
+        f = self.codomain().coerce_map_from(self.domain())
+        if f is None:
+            raise TypeError("natural coercion morphism from %s to %s not defined" % (self.domain(), self.codomain()))
+        return f
+
+    def zero(self):
+        r"""
+        Return the zero element of this homset.
+
+        EXAMPLES:
+
+        Since a ring homomorphism maps 1 to 1, there can only be a zero
+        morphism when mapping to the trivial ring::
+
+            sage: Hom(ZZ, Zmod(1)).zero()
+            Ring morphism:
+              From: Integer Ring
+              To:   Ring of integers modulo 1
+              Defn: 1 |--> 0
+            sage: Hom(ZZ, Zmod(2)).zero()
+            Traceback (most recent call last):
+            ...
+            ValueError: homset has no zero element
+        """
+        if not self.codomain().is_zero():
+            raise ValueError("homset has no zero element")
+        # there is only one map in this homset
+        return self.an_element()
+
+
+class RingHomset_quo_ring(RingHomset_generic):
+    """
+    Space of ring homomorphisms where the domain is a (formal) quotient
+    ring.
+
+    EXAMPLES::
+
+        sage: R.<x,y> = PolynomialRing(QQ, 2)
+        sage: S.<a,b> = R.quotient(x^2 + y^2)                                           # needs sage.libs.singular
+        sage: phi = S.hom([b,a]); phi                                                   # needs sage.libs.singular
+        Ring endomorphism of Quotient of Multivariate Polynomial Ring in x, y
+         over Rational Field by the ideal (x^2 + y^2)
+          Defn: a |--> b
+                b |--> a
+        sage: phi(a)                                                                    # needs sage.libs.singular
+        b
+        sage: phi(b)                                                                    # needs sage.libs.singular
+        a
+
+    TESTS:
+
+    We test pickling of a homset from a quotient.
+
+    ::
+
+        sage: # needs sage.libs.singular
+        sage: R.<x,y> = PolynomialRing(QQ, 2)
+        sage: S.<a,b> = R.quotient(x^2 + y^2)
+        sage: H = S.Hom(R)
+        sage: H == loads(dumps(H))
+        True
+
+    We test pickling of actual homomorphisms in a quotient::
+
+        sage: phi = S.hom([b,a])                                                        # needs sage.libs.singular
+        sage: phi == loads(dumps(phi))                                                  # needs sage.libs.singular
+        True
+    """
+
+    Element = morphism.RingHomomorphism_from_quotient
+
+    def _element_constructor_(self, x, base_map=None, check=True):
+        """
+        Construct an element of ``self`` from ``x``.
+
+        EXAMPLES::
+
+            sage: # needs sage.libs.singular
+            sage: R.<x,y> = PolynomialRing(QQ, 2)
+            sage: S.<a,b> = R.quotient(x^2 + y^2)
+            sage: H = S.Hom(R)
+            sage: phi = H([b, a]); phi
+            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: a |--> b
+                    b |--> a
+            sage: R2.<x,y> = PolynomialRing(ZZ, 2)
+            sage: H2 = Hom(R2, S)
+            sage: H2(phi)
+            Composite map:
+              From: Multivariate Polynomial Ring in x, y over Integer Ring
+              To:   Quotient of Multivariate Polynomial Ring in x, y over Rational Field by the ideal (x^2 + y^2)
+              Defn:   Coercion map:
+                      From: Multivariate Polynomial Ring in x, y over Integer Ring
+                      To:   Quotient of Multivariate Polynomial Ring in x, y over Rational Field by the ideal (x^2 + y^2)
+                    then
+                      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: a |--> b
+                            b |--> a
+                    then
+                      Coercion map:
+                      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)
+        """
+        if isinstance(x, morphism.RingHomomorphism_from_quotient):
+            phi = x._phi()
+        else:
+            pi = self.domain().cover()
+            phi = pi.domain().hom(x, base_map=base_map, check=check)
+        return self.element_class(self, phi)