Ticket #10677: 10677_pari_rnf.patch

sage/libs/pari/decl.pxi

@@ -415 +415 @@
     void    checkrnf(GEN rnf)
     GEN     galoisapply(GEN nf, GEN aut, GEN x)
     GEN     polgalois(GEN x, long prec)
-    GEN     get_bnf(GEN x,int *t)
+    GEN     get_bnf(GEN x, long *t)
     GEN     get_bnfpol(GEN x, GEN *bnf, GEN *nf)
-    GEN     get_nf(GEN x,int *t)
+    GEN     get_nf(GEN x, long *t)
     GEN     get_nfpol(GEN x, GEN *nf)
     GEN     glambdak(GEN nfz, GEN s, long prec)
     GEN     gsmith(GEN x)
@@ -695 +695 @@
 
     # buch4.c
 
-    GEN     bnfisnorm(GEN bnf,GEN x,long flag,long PREC)
+    GEN     bnfisnorm(GEN bnf, GEN x, long flag)
     GEN     rnfisnorm(GEN S, GEN x, long flag)
+    GEN     rnfisnorminit(GEN T, GEN relpol, int galois)
     GEN     bnfissunit(GEN bnf,GEN suni,GEN x)
     GEN     bnfsunit(GEN bnf,GEN s,long PREC)
     long    nfhilbert(GEN bnf,GEN a,GEN b)

sage/libs/pari/gen.pxd

@@ -12 +12 @@
     cdef gen new_gen_noclear(self, GEN x)
     cdef gen pari(self, object x)
     cdef GEN _deepcopy_to_python_heap(self, GEN x, pari_sp* address)
-    cdef int get_var(self, v)
+    cdef long get_var(self, v)
+    cdef GEN get_nf(self) except NULL
 
 cimport sage.structure.parent_base
 
@@ -34 +35 @@
     cdef GEN deepcopy_to_python_heap(self, GEN x, pari_sp* address)
     cdef gen new_ref(self, GEN g, gen parent)
     cdef gen _empty_vector(self, long n)
-    cdef int get_var(self, v)
+    cdef long get_var(self, v)
     cdef GEN toGEN(self, x, int i) except NULL    
     cdef GEN integer_matrix_GEN(self, mpz_t** B, Py_ssize_t nr, Py_ssize_t nc) except <GEN>0
     cdef GEN integer_matrix_permuted_for_hnf_GEN(self, mpz_t** B, Py_ssize_t nr, Py_ssize_t nc) except <GEN>0

sage/libs/pari/gen.pyx

@@ -597 +597 @@
         sig_on()
         return P.new_gen(gaddsg(1, self.g))
 
-    def _mod(gen self, gen other):
-        sig_on()
-        return P.new_gen(gmod(self.g, other.g))
-
     def __mod__(self, other):
-        if isinstance(self, gen) and isinstance(other, gen):
-            return self._mod(other)
+        cdef gen selfgen
+        cdef gen othergen
+        if isinstance(other, gen) and isinstance(self, gen):
+            selfgen = self
+            othergen = other
+            sig_on()
+            return P.new_gen(gmod(selfgen.g, othergen.g))
         return sage.structure.element.bin_op(self, other, operator.mod)
 
     def __pow__(self, n, m):
@@ -643 +644 @@
         t0GEN(str(self) + '.' + str(attr))
         sig_on()
         return self.new_gen(t0)
-    
+
+    def mod(self):
+        """
+        Given an INTMOD or POLMOD ``Mod(a,m)``, return the modulus `m`.
+
+        EXAMPLES::
+
+            sage: pari(4).Mod(5).mod()
+            5
+            sage: pari("Mod(x, x*y)").mod()
+            y*x
+            sage: pari("[Mod(4,5)]").mod()
+            Traceback (most recent call last):
+            ...
+            TypeError: Not an INTMOD or POLMOD in mod()
+        """
+        if typ(self.g) != t_INTMOD and typ(self.g) != t_POLMOD:
+            raise TypeError("Not an INTMOD or POLMOD in mod()")
+        sig_on()
+        # The hardcoded 1 below refers to the position in the internal
+        # representation of a INTMOD or POLDMOD where the modulus is
+        # stored.
+        return self.new_gen(gel(self.g, 1))
+
+    cdef GEN get_nf(self) except NULL:
+        """
+        Given a PARI object `self`, convert it to a proper PARI number
+        field (nf) structure.
+
+        INPUT:
+
+        - ``self`` -- A PARI number field being the output of ``nfinit()``,
+                      ``bnfinit()`` or ``bnrinit()``.
+
+        TESTS:
+
+        We test this indirectly through `nf_get_pol()`::
+
+            sage: x = polygen(QQ)
+            sage: K.<a> = NumberField(x^4 - 4*x^2 + 1)
+            sage: K.pari_nf().nf_get_pol()
+            x^4 - 4*x^2 + 1
+            sage: K.pari_bnf().nf_get_pol()
+            x^4 - 4*x^2 + 1
+            sage: bnr = pari("K = bnfinit(x^4 - 4*x^2 + 1); bnrinit(K, 2*x)")
+            sage: bnr.nf_get_pol()
+            x^4 - 4*x^2 + 1
+
+        It does not work with ``rnfinit()`` or garbage input::
+
+            sage: K.extension(x^2 - 5, 'b').pari_rnf().nf_get_pol()
+            Traceback (most recent call last):
+            ...
+            TypeError: Not a PARI number field
+            sage: pari("[0]").nf_get_pol()
+            Traceback (most recent call last):
+            ...
+            TypeError: Not a PARI number field
+        """
+        cdef GEN nf
+        cdef long nftyp
+        sig_on()
+        nf = get_nf(self.g, &nftyp)
+        sig_off()
+        if not nf:
+            raise TypeError("Not a PARI number field")
+        return nf
+
+    def nf_get_pol(self):
+        """
+        Returns the defining polynomial of this number field.
+
+        INPUT:
+
+        - ``self`` -- A PARI number field being the output of ``nfinit()``,
+                      ``bnfinit()`` or ``bnrinit()``.
+
+        EXAMPLES::
+            
+            sage: K.<a> = NumberField(x^4 - 4*x^2 + 1)
+            sage: pari(K).nf_get_pol()
+            x^4 - 4*x^2 + 1
+            sage: bnr = pari("K = bnfinit(x^4 - 4*x^2 + 1); bnrinit(K, 2*x)")
+            sage: bnr.nf_get_pol()
+            x^4 - 4*x^2 + 1
+
+        For relative extensions, we can only get the absolute polynomial,
+        not the relative one::
+
+            sage: L.<b> = K.extension(x^2 - 5)
+            sage: pari(L).nf_get_pol()   # Absolute polynomial
+            x^8 - 28*x^6 + 208*x^4 - 408*x^2 + 36
+            sage: L.pari_rnf().nf_get_pol()
+            Traceback (most recent call last):
+            ...
+            TypeError: Not a PARI number field
+        """
+        cdef GEN nf = self.get_nf()
+        sig_on()
+        return self.new_gen(nf_get_pol(nf))
+
     def nf_get_diff(self):
         """
         Returns the different of this number field as a PARI ideal.
         
+        INPUT:
+
+        - ``self`` -- A PARI number field being the output of ``nfinit()``,
+                      ``bnfinit()`` or ``bnrinit()``.
+
         EXAMPLES::
             
             sage: K.<a> = NumberField(x^4 - 4*x^2 + 1)
             sage: pari(K).nf_get_diff()
             [12, 0, 0, 0; 0, 12, 8, 0; 0, 0, 4, 0; 0, 0, 0, 4]
         """
+        cdef GEN nf = self.get_nf()
         sig_on()
         # Very bad code, but there doesn't seem to be a better way
-        return self.new_gen(gel(gel(self.g, 5), 5))
+        return self.new_gen(gel(gel(nf, 5), 5))
 
     def nf_get_sign(self):
         """
@@ -664 +771 @@
         Python ints representing the number of real embeddings and pairs
         of complex embeddings of this number field, respectively.
         
+        INPUT:
+
+        - ``self`` -- A PARI number field being the output of ``nfinit()``,
+                      ``bnfinit()`` or ``bnrinit()``.
+
         EXAMPLES::
             
             sage: K.<a> = NumberField(x^4 - 4*x^2 + 1)
@@ -677 +789 @@
         """
         cdef long r1
         cdef long r2
-        sig_on()
-        nf_get_sign(self.g, &r1, &r2)
-        sig_off()
+        cdef GEN nf = self.get_nf()
+        nf_get_sign(nf, &r1, &r2)
         return [r1, r2]
 
     def nf_get_zk(self):
@@ -687 +798 @@
         Returns a vector with a `\ZZ`-basis for the ring of integers of
         this number field. The first element is always `1`.
         
+        INPUT:
+
+        - ``self`` -- A PARI number field being the output of ``nfinit()``,
+                      ``bnfinit()`` or ``bnrinit()``.
+
         EXAMPLES::
             
             sage: K.<a> = NumberField(x^4 - 4*x^2 + 1)
             sage: pari(K).nf_get_zk()
             [1, x, x^3 - 4*x, x^2 - 2]
         """
-        sig_on()
-        return self.new_gen(nf_get_zk(self.g))
+        cdef GEN nf = self.get_nf()
+        sig_on()
+        return self.new_gen(nf_get_zk(nf))
 
     def bnf_get_cyc(self):
         """
@@ -6554 +6671 @@
         sig_on()
         return self.new_gen(bnfisintnorm(self.g, t0))
 
+    def bnfisnorm(self, x, long flag=0):
+        t0GEN(x)
+        sig_on()
+        return self.new_gen(bnfisnorm(t0, self.g, flag))
+
     def bnfisprincipal(self, x, long flag=1):
         t0GEN(x)
         sig_on()
@@ -7206 +7328 @@
     def rnfeltabstorel(self, x):
         t0GEN(x)
         sig_on()
-        polymodmod = self.new_gen(rnfelementabstorel(self.g, t0))
-        return polymodmod.centerlift().centerlift()
+        return self.new_gen(rnfelementabstorel(self.g, t0))
 
     def rnfeltreltoabs(self, x):
         t0GEN(x)
@@ -7626 +7747 @@
         return self.new_gen(thueinit(self.g, flag, prec))
 
 
-
-    
+    def rnfisnorminit(self, polrel, long flag=2):
+        t0GEN(polrel)
+        sig_on()
+        return self.new_gen(rnfisnorminit(self.g, t0, flag))
+
+    def rnfisnorm(self, T, long flag=0):
+        t0GEN(T)
+        sig_on()
+        return self.new_gen(rnfisnorm(t0, self.g, flag))
 
     ###########################################
     # 8: Vectors, matrices, LINEAR ALGEBRA and sets
@@ -8162 +8290 @@
     
     def nextprime(gen self, bint add_one=0):
         """
-        nextprime(x): smallest pseudoprime = x
+        nextprime(x): smallest pseudoprime greater than or equal to `x`.
+        If ``add_one`` is non-zero, return the smallest pseudoprime
+        strictly greater than `x`.
         
         EXAMPLES::
         
             sage: pari(1).nextprime()
             2
+            sage: pari(2).nextprime()
+            2
+            sage: pari(2).nextprime(add_one = 1)
+            3
             sage: pari(2^100).nextprime()
             1267650600228229401496703205653
         """
+        sig_on()        
         if add_one:
-            sig_on()        
             return P.new_gen(gnextprime(gaddsg(1,self.g)))
-        #NOTE: This is much faster than MAGMA's NextPrime with Proof := False.
-        sig_on()        
         return P.new_gen(gnextprime(self.g))
 
-    def subst(self, var, y):
-        """
+    def subst(self, var, z):
+        """
+        In ``self``, replace the variable ``var`` by the expression `z`.
+
         EXAMPLES::
         
             sage: x = pari("x"); y = pari("y")
@@ -8198 +8332 @@
             xyz^6 + 34*xyz^4 + 6*xyz^3 + 289*xyz^2 + 102*xyz + 9
         """
         cdef long n
-        n = P.get_var(var)        
-        t0GEN(y)
-        sig_on()        
+        n = P.get_var(var)
+        t0GEN(z)
+        sig_on()
         return P.new_gen(gsubst(self.g, n, t0))
 
     def substpol(self, y, z):
@@ -8209 +8343 @@
         sig_on()
         return self.new_gen(gsubstpol(self.g, t0, t1))
 
+    def nf_subst(self, z):
+        """
+        Given a PARI number field ``self``, return the same PARI
+        number field but in the variable ``z``.
+
+        INPUT:
+
+        - ``self`` -- A PARI number field being the output of ``nfinit()``,
+                      ``bnfinit()`` or ``bnrinit()``.
+
+        EXAMPLES::
+
+            sage: x = polygen(QQ)
+            sage: K = NumberField(x^2 + 5, 'a')
+
+        We can substitute in a PARI ``nf`` structure::
+
+            sage: Kpari = K.pari_nf()
+            sage: Kpari.nf_get_pol()
+            x^2 + 5
+            sage: Lpari = Kpari.nf_subst('a')
+            sage: Lpari.nf_get_pol()
+            a^2 + 5
+
+        We can also substitute in a PARI ``bnf`` structure::
+
+            sage: Kpari = K.pari_bnf()
+            sage: Kpari.nf_get_pol()
+            x^2 + 5
+            sage: Kpari.bnf_get_cyc()  # Structure of class group
+            [2]
+            sage: Lpari = Kpari.nf_subst('a')
+            sage: Lpari.nf_get_pol()
+            a^2 + 5
+            sage: Lpari.bnf_get_cyc()  # We still have a bnf after substituting
+            [2]
+        """
+        cdef GEN nf = self.get_nf()
+        t0GEN(z)
+        sig_on()
+        return P.new_gen(gsubst(self.g, nf_get_varn(nf), t0))
+
     def taylor(self, v=-1):
         sig_on()
         return self.new_gen(tayl(self.g, self.get_var(v), precdl))
@@ -8519 +8695 @@
 
     def debug(gen self, long depth = -1):
         r"""
-        Show the internal structure of self (like \x in gp).
+        Show the internal structure of self (like the ``\x`` command in gp).
 
         EXAMPLE::
 
@@ -8554 +8730 @@
     cdef GEN _deepcopy_to_python_heap(self, GEN x, pari_sp* address):
         return P.deepcopy_to_python_heap(x, address)
 
-    cdef int get_var(self, v):
+    cdef long get_var(self, v):
         return P.get_var(v)
 
     
@@ -9198 +9374 @@
         
 
 
-    cdef int get_var(self, v):
+    cdef long get_var(self, v):
         """
         Converts a Python string into a PARI variable reference number. Or
         if v = -1, returns -1.

sage/rings/number_field/maps.py

@@ -377 +377 @@
         # internally by an absolute polynomial over QQ.
         alpha = self.__K(alpha)
         
-        # Pari doesn't return a valid relative polynomial from an
-        # absolute one in the case of relative degree one, so we work
-        # around it. (Bug submitted to Pari, fixed in svn unstable as
-        # of 1/22/08 according to Karim Belabas. Trac #1891 is a
-        # reminder to remove this workaround once we update Pari in
-        # Sage.)
-        if self.__K.relative_degree() == 1:
-            # Let K/F be our relative extension, let z be the absolute
-            # polynomial for K (which *need not* be the absolute
-            # polynomial for F!), and let pol be the relative
-            # polynomial for K/F. Then self.__rnf[10] returns a triple
-            # z, a, k, where z is as above, a is a polynomial
-            # representing the absolute generator gamma of F as a
-            # polynomial in a root of z, and k is an integer
-            # satisfying
-            #     theta = beta + k*gamma
-            # where theta is a root of z, and beta is a root of pol.
-            #
-            # Now f is a polynomial representing our element alpha as
-            # a polynomial in theta. However, we need a polynomial g
-            # representing alpha in terms of gamma, so we simply use
-            # the relation above to write theta as a polynomial in
-            # gamma, and then we can simply evaluate f at that
-            # polynomial, and this is our g. The code below does
-            # exactly this -- all the business with subst and
-            # self.__x, self.__y is there to deal with Pari's
-            # frustrating representation of relative number fields and
-            # "variable priority."
-            #
-            f = alpha._pari_().lift()
-            z, a, k = self.__rnf[10]
-            beta = -self.__rnf[0][0] / self.__rnf[0][1]
-            theta = beta + k*self.__y
-            f_in_base = f.subst(self.__x, theta).lift().subst(self.__y, self.__x)
-            return self.__V([self.__K.base_field()(f_in_base)])
-
         # f is the absolute polynomial that defines this number field
         # element
         f = alpha.polynomial('x')
-        g = self.__rnf.rnfeltabstorel(pari(f))
+        g = self.__rnf.rnfeltabstorel(pari(f)).lift().lift()
         # Now g is a relative polynomial that defines this element.
         # This g is a polynomial in a pari variable x with
         # coefficients polynomials in a variable y.  These

sage/rings/number_field/number_field.py

@@ -76 +76 @@
     sage: beta^10
     27*beta0
 """
-
 #*****************************************************************************
 #       Copyright (C) 2004, 2005, 2006, 2007 William Stein <wstein@gmail.com>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
-#
-#    This code is distributed in the hope that it will be useful,
-#    but WITHOUT ANY WARRANTY; without even the implied warranty of
-#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-#    General Public License for more details.
-#
-#  The full text of the GPL is available at:
-#
+#  as published by the Free Software Foundation; either version 2 of
+#  the License, or (at your option) any later version.
 #                  http://www.gnu.org/licenses/
 #*****************************************************************************
 
@@ -3605 +3598 @@
         -  ``type`` - ``none``, ``gap``, or ``pari``. If None (the default),
            return an explicit group of automorphisms of self as a
            ``GaloisGroup_v2`` object.  Otherwise, return a ``GaloisGroup_v1``
-           wrapper object based on a Pari or Gap transitive group object, which
+           wrapper object based on a PARI or Gap transitive group object, which
            is quicker to compute, but rather less useful (in particular, it
            can't be made to act on self).  If type = 'gap', the database_gap
            package should be installed.
@@ -3884 +3877 @@
         .. note::
 
            In the non-totally-real case, the LLL routine we call is
-           currently Pari's qflll(), which works with floating point
+           currently PARI's qflll(), which works with floating point
            approximations, and so the result is only as good as the
-           precision promised by Pari. The matrix returned will always
+           precision promised by PARI. The matrix returned will always
            be integral; however, it may only be only "almost" LLL-reduced
            when the precision is not sufficiently high.
         
@@ -3963 +3956 @@
         .. note::
 
            In the non-totally-real case, the LLL routine we call is
-           currently Pari's qflll(), which works with floating point
+           currently PARI's qflll(), which works with floating point
            approximations, and so the result is only as good as the
-           precision promised by Pari. In particular, in this case,
+           precision promised by PARI. In particular, in this case,
            the returned matrix will *not* be integral, and may not
            have enough precision to recover the correct gram matrix
            (which is known to be integral for theoretical
@@ -4554 +4547 @@
             except AttributeError:
                 pass
 
-        # get Pari to compute the units
+        # get PARI to compute the units
         B = self.pari_bnf(proof).bnfunit()
         if proof:
             # cache the provable results and return them

sage/rings/number_field/number_field_element.pyx

@@ -16 +16 @@
   logarithmic heights.
 
 """
-
 #*****************************************************************************
 #       Copyright (C) 2004, 2007 William Stein <wstein@gmail.com>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
-#
-#    This code is distributed in the hope that it will be useful,
-#    but WITHOUT ANY WARRANTY; without even the implied warranty of
-#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-#    General Public License for more details.
-#
-#  The full text of the GPL is available at:
-#
+#  as published by the Free Software Foundation; either version 2 of
+#  the License, or (at your option) any later version.
 #                  http://www.gnu.org/licenses/
 #*****************************************************************************
 
@@ -301 +294 @@
         else:
             ppr = parent.polynomial_ring()
 
+        cdef long i
         if isinstance(f, pari_gen):
             if f.type() in ["t_INT", "t_FRAC", "t_POL"]:
                 pass
             elif f.type() == "t_POLMOD":
+                # Check whether we are dealing with a *relative*
+                # number field element
+                if parent.is_relative():
+                    # If the modulus is a polynomial with polynomial
+                    # coefficients, then the element is relative.
+                    fmod = f.mod()
+                    for i from 0 <= i <= fmod.poldegree():
+                        if fmod.polcoeff(i).type() in ["t_POL", "t_POLMOD"]:
+                            # Convert relative element to absolute
+                            f = parent.pari_rnf().rnfeltreltoabs(f)
+                            break
                 f = f.lift()
             else:
                 f = self.number_field().pari_nf().nfbasistoalg_lift(f)
@@ -321 +326 @@
         (<Integer>ZZ(den))._to_ZZ(&self.__denominator)
 
         num = f * den
-        cdef long i
         for i from 0 <= i <= num.degree():
             (<Integer>ZZ(num[i]))._to_ZZ(&coeff)
             ZZX_SetCoeff( self.__numerator, i, coeff )
@@ -516 +520 @@
 
     def _pari_(self, var='x'):
         r"""
-        Convert self to a Pari element.
+        Convert self to a PARI element.
         
         EXAMPLE::
         
@@ -1189 +1193 @@
             sage: (a^4 + a^2 - 3*a + 2).sqrt()
             a^3 - a^2
         
-        ALGORITHM: Use Pari to factor `x^2` - ``self``
-        in K.
+        ALGORITHM: Use PARI to factor `x^2` - ``self`` in `K`.
         """
         # For now, use pari's factoring abilities
         R = self.number_field()['t']
@@ -1220 +1223 @@
             sage: K((a-3)^5).nth_root(5)
             a - 3
         
-        ALGORITHM: Use Pari to factor `x^n` - ``self``
-        in K.
+        ALGORITHM: Use PARI to factor `x^n` - ``self`` in `K`.
         """
         R = self.number_field()['t']
         if not self:
@@ -3117 +3119 @@
         this is an element of an absolute extension.
         
         The optional argument algorithm controls how the
-        characteristic polynomial is computed: 'pari' uses Pari,
+        characteristic polynomial is computed: 'pari' uses PARI,
         'sage' uses charpoly for Sage matrices.  The default value
         None means that 'pari' is used for small degrees (up to the
         value of the constant TUNE_CHARPOLY_NF, currently at 25),
@@ -3298 +3300 @@
             sage: L.<a, b> = NumberField([x^2 + 1, x^2 + 2])
             sage: type(a) # indirect doctest
             <type 'sage.rings.number_field.number_field_element.NumberFieldElement_relative'>
+
+        We can create relative number field elements from PARI::
+
+            sage: y = polygen(QQ)
+            sage: K.<a> = NumberField(y^2 + y + 1)
+            sage: x = polygen(K)
+            sage: L.<b> = NumberField(x^4 + a*x + 2)
+            sage: e = pari(a*b); e
+            Mod(-x^4 - 2, x^8 - x^5 + 4*x^4 + x^2 - 2*x + 4)
+            sage: L(e)  # Conversion from PARI absolute number field element
+            a*b
+            sage: e = L.pari_rnf().rnfeltabstorel(e); e
+            Mod(y*x, x^4 + y*x + 2)
+            sage: L(e)  # Conversion from PARI relative number field element
+            a*b
+
+        We test a relative number field element created "by hand"::
+
+            sage: e = pari("Mod(Mod(y, y^2 + y + 1)*x^2 + Mod(1, y^2 + y + 1), x^4 + y*x + 2)")
+            sage: L(e)
+            a*b^2 + 1
         """
         NumberFieldElement.__init__(self, parent, f)
 
@@ -3522 +3545 @@
         polynomial over `\QQ`.
 
         The optional argument algorithm controls how the
-        characteristic polynomial is computed: 'pari' uses Pari,
+        characteristic polynomial is computed: 'pari' uses PARI,
         'sage' uses charpoly for Sage matrices.  The default value
         None means that 'pari' is used for small degrees (up to the
         value of the constant TUNE_CHARPOLY_NF, currently at 25),

sage/rings/number_field/number_field_rel.py

@@ -2147 +2147 @@
             sage: L.<b> = K.extension(y^2 - a)
             sage: L.lift_to_base(b^4)
             a^2
+            sage: L.lift_to_base(b^6)
+            2
+            sage: L.lift_to_base(355/113)
+            355/113
             sage: L.lift_to_base(b)
             Traceback (most recent call last):
             ...
             ValueError: The element b is not in the base field
         """
-        poly_xy = self.pari_rnf().rnfeltabstorel( self(element)._pari_() )
-        str_poly = str(poly_xy)
-        if str_poly.find('x') >= 0:
+        polmodmod_xy = self.pari_rnf().rnfeltabstorel( self(element)._pari_() )
+        # polmodmod_xy is a POLMOD with POLMOD coefficients in general.
+        # These POLMOD coefficients represent elements of the base field K.
+        # We do two lifts so we get a polynomial. We need the simplify() to
+        # make PARI check which variables really appear in the resulting
+        # polynomial (otherwise we always have a polynomial in two variables
+        # even though not all variables actually occur).
+        r = polmodmod_xy.lift().lift().simplify()
+
+        # Special case: check whether the result is simply an integer or rational
+        if r.type() in ["t_INT", "t_FRAC"]:
+            return self.base_field()(r)
+        # Now we should have a polynomial in the variable y.
+        # Otherwise we're not in the base field.
+        if r.type() != "t_POL" or str(r.variable()) != 'y':
             raise ValueError, "The element %s is not in the base field"%element
-        # We convert to a string to avoid some serious nastiness with
-        # PARI polynomials secretely thinkining they are in more variables
-        # than they are.
-        f = QQ['y'](str_poly)
-        return self.base_field()(f.list())
+        return self.base_field()(r)
 
     def relativize(self, alpha, names):
         r"""