Ticket #9541: trac_9541-part10-libsingular_technical_stuff.patch

module_list.py

@@ -1217 +1217 @@
               extra_compile_args=["-std=c99", "-D_XPG6"]
               ),
     
+    Extension('sage.rings.number_field.number_field_fast',
+              sources = ['sage/rings/number_field/number_field_fast.pyx']),
+
     Extension('sage.rings.number_field.number_field_element',
               sources = ['sage/rings/number_field/number_field_element.pyx']),
 

sage/libs/flint/fmpq_poly.c

@@ -3555 +3555 @@
     
     if (fmpq_poly_is_zero(op))
     {
-        str = calloc(2, sizeof(char));
+        str = (char*) calloc(2, sizeof(char));
         str[0] = '0';
         str[1] = '\0';
         return str;
@@ -3581 +3581 @@
     }
     
     mpq_init(q);
-    str = calloc(len, sizeof(char));
+    str = (char*) calloc(len, sizeof(char));
     sprintf(str, "%lu", fmpq_poly_length(op));
     for (j = 0; str[j] != '\0'; j++);
     str[j++] = ' ';
@@ -3625 +3625 @@
     
     if (fmpq_poly_is_zero(op))     /* Zero polynomial                        */
     {
-        str = calloc(2, sizeof(char));
+        str = (char*) calloc(2, sizeof(char));
         str[0] = '0';
         str[1] = '\0';
         return str;
@@ -3674 +3674 @@
     }
     
     mpq_init(q);
-    str = calloc(len, sizeof(char));
+    str = (char*) calloc(len, sizeof(char));
     j = 0;
     
     /* Print the leading term                                                */

sage/rings/integer_ring.pyx

@@ -227 +227 @@
 
     def __init__(self):
         ParentWithGens.__init__(self, self, ('x',), normalize=False, category = EuclideanDomains())
-        self._populate_coercion_lists_(element_constructor=integer.Integer, 
+        self._populate_coercion_lists_(element_constructor=integer.Integer,
                                        init_no_parent=True, 
                                        convert_method_name='_integer_')
         

sage/rings/number_field/implementation.pxd

@@ -15 +15 @@
 cdef class ArithmeticImplementation_flint(ArithmeticImplementation):
     cdef fmpq_poly_t modulus
 
-cdef class ArithmeticImplementation_libsingular(ArithmeticImplementation):
-    cdef object nf_t_wrap
-    cdef object ideal
-    cdef object ring
-
 cdef class ArithmeticImplementation_quadratic(ArithmeticImplementation):
     pass

sage/rings/number_field/implementation.pyx

@@ -178 +178 @@
         """
         return True
 
-from number_field_element_libsingular import nf_t_wrap
-
-cdef class ArithmeticImplementation_libsingular(ArithmeticImplementation):
-    def __init__(self, ideal):
-        """
-        EXAMPLES::
-
-            sage: sage.rings.number_field.implementation.ArithmeticImplementation_libsingular()
-            Arithmetic implementation 'singular'
-        """
-        ArithmeticImplementation.__init__(self, 'singular')
-        self.nf_t_wrap = nf_t_wrap(ideal)
-        self.ideal = ideal
-        self.ring = ideal.ring()
-
 cdef class ArithmeticImplementation_quadratic(ArithmeticImplementation):
     def __init__(self):
         """

sage/rings/number_field/maps.py

@@ -731 +731 @@
         """
         return self.__to_V(self.__to_K(x))
 
+####################################################
+# Maps between relative number fields and towers of
+# univariate quotient polynomial rings. 
+####################################################
+
+class MapRelativeNumberFieldToPolynomialQuotientTower(NumberFieldIsomorphism):
+    def __init__(self, K, Q, base_Q0_to_K0, base_K0_to_Q0):
+        """
+        The isomorphism from a relative number field to a polynomial
+        quotient tower, which sends the generator for the relative number
+        field to the generator for the quotient ring, and sends the bases
+        as specified.
+
+        INPUT:
+            - `K` -- relative number field
+            - `Q` -- quotient of multivariate polynomial ring
+            - ``base_Q0_to_K0`` -- map on base from poly quotient ring to base field
+            - ``base_K0_to_Q0`` -- map on base from base field to poly quotient ring
+
+        EXAMPLES::
+
+            sage: K.<a,b> = NumberField([x^2 + 7, x^3 + 2]); Q, f, t=K.polynomial_quotient_tower()
+            sage: t
+            Isomorphism map:
+              From: Number Field in a with defining polynomial x^2 + 7 over its base field
+              To:   Univariate Quotient Polynomial Ring in a over Univariate Quotient Polynomial Ring in b over Rational Field with modulus x^3 + 2 with modulus x^2 + 7
+        """
+        self._K = K
+        self._Q = Q
+        self._base_Q0_to_K0 = base_Q0_to_K0
+        self._base_K0_to_Q0 = base_K0_to_Q0
+        NumberFieldIsomorphism.__init__(self, Hom(K, Q))
+
+    def __cmp__(self, right):
+        """
+        EXAMPLES::
+        
+            sage: K.<a,b> = NumberField([x^2 + 7, x^3 + 2]); Q, f, t=K.polynomial_quotient_tower()
+            sage: loads(dumps(t)) == t
+            True
+        """
+        c = cmp(type(self),type(right))
+        if c: return c
+        return cmp((self._K,self._Q), (right._K,right._Q))
+    
+    def _call_(self, x):
+        """
+        EXAMPLES::
+        
+            sage: K.<a,b> = NumberField([x^2 + 7, x^3 + 2]); Q,f,t=K.polynomial_quotient_tower()
+            sage: r = K.random_element(); r
+            (79797/95*b^2 + 135*b - 55473/95)*a - 91/2*b^2 + 279184/95*b + 161878/95
+            sage: t(r)
+            (79797/95*b^2 + 135*b - 55473/95)*a - 91/2*b^2 + 279184/95*b + 161878/95
+            sage: f(t(r)) == r
+            True
+        """
+        f = x.relative_polynomial()
+        v = [self._base_K0_to_Q0(a) for a in f.list()]
+        return self._Q(v)
+    
+    def inverse(self):
+        """
+        Return the inverse of this isomorphism.
+                
+        EXAMPLES::
+        
+            sage: K.<a,b> = NumberField([x^2 + 7, x^3 + 2]); Q, f, t = K.polynomial_quotient_tower()
+            sage: t.inverse()
+            Isomorphism map:
+              From: Univariate Quotient Polynomial Ring in a over Univariate Quotient Polynomial Ring in b over Rational Field with modulus x^3 + 2 with modulus x^2 + 7
+              To:   Number Field in a with defining polynomial x^2 + 7 over its base field
+        """
+        return PolynomialQuotientTowerToRelativeNumberField(
+            self._K, self._Q, self._base_Q0_to_K0, self._base_K0_to_Q0)
+
+class PolynomialQuotientTowerToRelativeNumberField(NumberFieldIsomorphism):
+    def __init__(self, K, Q, base_Q0_to_K0, base_K0_to_Q0):
+        """
+        The isomorphism from a polynomial quotient tower to a relative
+        number field, which sends the generator for the quotient ring to
+        the generator for the relative number field, and sends the bases
+        as specified.
+
+        EXAMPLES::
+
+            sage: K.<a,b> = NumberField([x^2 + 7, x^3 + 2]); Q, f, t=K.polynomial_quotient_tower()
+            sage: f
+            Isomorphism map:
+              From: Univariate Quotient Polynomial Ring in a over Univariate Quotient Polynomial Ring in b over Rational Field with modulus x^3 + 2 with modulus x^2 + 7
+              To:   Number Field in a with defining polynomial x^2 + 7 over its base field
+        """
+        self._K = K
+        self._Q = Q
+        self._base_Q0_to_K0 = base_Q0_to_K0
+        self._base_K0_to_Q0 = base_K0_to_Q0
+        NumberFieldIsomorphism.__init__(self, Hom(Q,K))
+    
+    def __cmp__(self, right):
+        """
+        EXAMPLES::
+        
+            sage: K.<a,b> = NumberField([x^2 + 7, x^3 + 2]); Q, f, t=K.polynomial_quotient_tower()
+            sage: loads(dumps(f)) == f
+            True
+        """
+        c = cmp(type(self),type(right))
+        if c: return c
+        return cmp((self._K,self._Q), (right._K,right._Q))
+
+    def _call_(self, x):
+        """
+        EXAMPLES::
+        
+            sage: K.<a,b> = NumberField([x^2 + 7, x^3 + 2]); Q,f,t = K.polynomial_quotient_tower()
+            sage: r = Q.random_element()
+            sage: f(r)
+            (-12*b^2 + 1/2*b - 1/95)*a - 1/2*b^2 - 4
+            sage: t(f(r)) == r
+            True
+        """
+        v = [self._base_Q0_to_K0(a) for a in x.list()]
+        return self._K(v)
+
+    def inverse(self):
+        """
+        Return the inverse of this isomorphism.
+        
+        EXAMPLES::
+
+            sage: K.<a,b> = NumberField([x^2 + 7, x^3 + 2]); Q,f,t = K.polynomial_quotient_tower()        
+            sage: f.inverse()
+            Isomorphism map:
+              From: Number Field in a with defining polynomial x^2 + 7 over its base field
+              To:   Univariate Quotient Polynomial Ring in a over Univariate Quotient Polynomial Ring in b over Rational Field with modulus x^3 + 2 with modulus x^2 + 7
+        """
+        return MapRelativeNumberFieldToPolynomialQuotientTower(
+            self._K, self._Q, self._base_Q0_to_K0, self._base_K0_to_Q0)
+
+
+####################################################
+# Maps between relative number fields and a quotient
+# of a multivariate polynomial ring over QQ.
+####################################################
+
+class MapRelativeNumberFieldToMPolynomialQuotient(NumberFieldIsomorphism):
+    def __init__(self, K, Q, base_Q0_to_K0, base_K0_to_Q0):
+        """
+        The isomorphism from a relative number field to a quotient of a
+        multivariate polynomial ring.
+
+        EXAMPLES::
+
+            sage: K.<a,b> = NumberField([x^2 + 7, x^3 + 2]);  Q, f, t = K.multi_polynomial_quotient_ring()
+            sage: t
+            Isomorphism map:
+              From: Number Field in a with defining polynomial x^2 + 7 over its base field
+              To:   Quotient of Multivariate Polynomial Ring in x, x over Rational Field by the ideal (x^3 + 2, x^2 + 7)
+
+        Notice above that amusingly that there are two distinct variables
+        that both print as x.  Sage should deal with this just fine.
+        """
+        self._K = K
+        self._Q = Q
+        self._base_Q0_to_K0 = base_Q0_to_K0
+        self._base_K0_to_Q0 = base_K0_to_Q0
+        Q0 = base_Q0_to_K0.domain()
+        self._phi = Q0.cover_ring().hom(Q.gens()[1:])
+                    
+        NumberFieldIsomorphism.__init__(self, Hom(K, Q))
+    
+    def _call_(self, x):
+        """
+        EXAMPLES::
+        
+            sage: K.<a,b> = NumberField([x^2 + 7, x^3 + 2]); Q, f, t = K.multi_polynomial_quotient_ring()
+            sage: r = K.random_element(); r
+            (79797/95*b^2 + 135*b - 55473/95)*a - 91/2*b^2 + 279184/95*b + 161878/95
+            sage: t(r)
+            79797/95*a*b^2 + 135*a*b - 91/2*b^2 - 55473/95*a + 279184/95*b + 161878/95
+            sage: f(t(r)) == r
+            True
+        """
+        f = x.relative_polynomial()
+        x = self._Q.gen(0)
+        return sum(self._phi(self._base_K0_to_Q0(a).lift())*x**i for i,a in enumerate(f.list()))
+    
+    def __cmp__(self, right):
+        """
+        EXAMPLES::
+        
+            sage: K.<a,b> = NumberField([x^2 + 7, x^3 + 2]);  Q, f, t = K.multi_polynomial_quotient_ring()
+            sage: loads(dumps(t)) == t
+            True
+        """
+        c = cmp(type(self),type(right))
+        if c: return c
+        return cmp((self._K,self._Q), (right._K,right._Q))
+
+    def inverse(self):
+        """
+        Return the inverse of this isomorphism.
+                
+        EXAMPLES::
+        
+            sage: K.<a,b> = NumberField([x^2 + 7, x^3 + 2]); Q, f, t = K.multi_polynomial_quotient_ring()
+            sage: t.inverse()
+            Isomorphism map:
+              From: Quotient of Multivariate Polynomial Ring in x, x over Rational Field by the ideal (x^3 + 2, x^2 + 7)
+              To:   Number Field in a with defining polynomial x^2 + 7 over its base field
+        """
+        return MPolynomialQuotientToRelativeNumberField(
+            self._K, self._Q, self._base_Q0_to_K0, self._base_K0_to_Q0)
+
+class MPolynomialQuotientToRelativeNumberField(NumberFieldIsomorphism):
+    def __init__(self, K, Q, base_Q0_to_K0, base_K0_to_Q0):
+        """
+        The isomorphism from a quotient of a multivariate polynomial ring
+        to a relative number field. 
+
+        EXAMPLES::
+
+            sage: K.<a,b> = NumberField([x^2 + 7, x^3 + 2]); Q, f, t = K.multi_polynomial_quotient_ring()
+            sage: f
+            Isomorphism map:
+                  From: Quotient of Multivariate Polynomial Ring in x, x over Rational Field by the ideal (x^3 + 2, x^2 + 7)
+                  To:   Number Field in a with defining polynomial x^2 + 7 over its base field
+
+        TESTS::
+            sage: loads(dumps(f)) == f
+        """
+        self._K = K
+        self._Q = Q
+        self._base_Q0_to_K0 = base_Q0_to_K0
+        self._base_K0_to_Q0 = base_K0_to_Q0
+        Q0 = base_Q0_to_K0.domain()
+    
+        NumberFieldIsomorphism.__init__(self, Hom(Q,K))
+
+    def _call_(self, x):
+        """
+        EXAMPLES::
+        
+            sage: K.<a,b> = NumberField([x^2 + 7, x^3 + 2]); Q,f,t = K.polynomial_quotient_tower()
+            sage: r = Q.random_element()
+            sage: f(r)
+            (-12*b^2 + 1/2*b - 1/95)*a - 1/2*b^2 - 4
+            sage: t(f(r)) == r
+            True
+        """
+        # psi has to be initialized outside of __init__, because the __init__ method
+        # above is called *during* the construction of K.
+        if not hasattr(self, '_psi'):
+            self._psi = Q.hom([K.gen()] + [K(base_Q0_to_K0(g)) for g in Q0.gens()])
+        return self._psi(x)
+
+    def __cmp__(self, right):
+        """
+        EXAMPLES::
+        
+            sage: K.<a,b> = NumberField([x^2 + 7, x^3 + 2]);  Q, f, t = K.multi_polynomial_quotient_ring()
+            sage: loads(dumps(f)) == f
+            True
+        """
+        c = cmp(type(self),type(right))
+        if c: return c
+        return cmp((self._K,self._Q), (right._K,right._Q))
+
+    def inverse(self):
+        """
+        Return the inverse of this isomorphism.
+        
+        EXAMPLES::
+
+            sage: K.<a,b> = NumberField([x^2 + 7, x^3 + 2]); Q,f,t = K.polynomial_quotient_tower()        
+            sage: f.inverse()
+            Isomorphism map:
+              From: Number Field in a with defining polynomial x^2 + 7 over its base field
+              To:   Univariate Quotient Polynomial Ring in a over Univariate Quotient Polynomial Ring in b over Rational Field with modulus x^3 + 2 with modulus x^2 + 7
+        """
+        return MapRelativeNumberFieldToPolynomialQuotientTower(
+            self._K, self._Q, self._base_Q0_to_K0, self._base_K0_to_Q0)

sage/rings/number_field/morphism.py

@@ -256 +256 @@
     """
     def __call__(self, im_gen, base_hom=None, check=True):
         """
+        EXAMPLES::
+        
             sage: K.<a,b> = NumberField([x^2 + 1, x^2 + 3]); H = Hom(K,K); H
             Automorphism group of Number Field in a with defining polynomial x^2 + 1 over its base field
             sage: type(H)

sage/rings/number_field/number_field.py

@@ -2 +2 @@
 Number Fields
 
 AUTHORS:
-
-- William Stein (2004, 2005): initial version
-
-- Steven Sivek (2006-05-12): added support for relative extensions
-
-- William Stein (2007-09-04): major rewrite and documentation
-
-- Robert Bradshaw (2008-10): specified embeddings into ambient fields
+    - William Stein (2004, 2005): initial version
+    - Steven Sivek (2006-05-12): added support for relative extensions
+    - William Stein (2007-09-04): major rewrite and documentation
+    - Robert Bradshaw (2008-10): specified embeddings into ambient fields
 
 .. note::
 
@@ -256 +252 @@
 #      - 'generic'
 #      - 'singular'
 #DEFAULT_IMPLEMENTATION = {'relative':'generic', 'absolute':'generic'}
-DEFAULT_IMPLEMENTATION = {'relative':'ntl', 'absolute':'ntl'}
+DEFAULT_IMPLEMENTATION = {'relative':'singular', 'absolute':'flint'}
 
 _nf_cache = {}
 def NumberField(polynomial, name=None, check=True, names=None, cache=True,
@@ -481 +477 @@
 
     R = polynomial.base_ring()
     polynomial = polynomial.change_ring(R.fraction_field())
-
+    
+    implementation = 'flint'
     if implementation == 'default':
+        # disable quadratic for now, since flint is fast and quadratic causes lots of trouble
         if polynomial.degree() == 2 and polynomial.base_ring() == QQ:
             implementation = 'quadratic'
         else:
@@ -502 +500 @@
             _nf_cache[key] = weakref.ref(S)
         return S
 
-    if polynomial.degree() == 2:
+    # TODO -- ??
+    if False and polynomial.degree() == 2:
         K = NumberField_quadratic(polynomial, name, latex_name, check, embedding, implementation=implementation)
     else:
         K = NumberField_absolute(polynomial, name, latex_name, check, embedding, implementation=implementation)
@@ -1014 +1013 @@
         self._integral_basis_dict = {}
         embedding = number_field_morphisms.create_embedding_from_approx(self, embedding)
         self._populate_coercion_lists_(embedding=embedding)
-
+        
     def _element_constructor_(self, x):
         r"""
         Make x into an element of this number field, possibly not canonically.
@@ -1871 +1870 @@
         c = cmp(self.variable_name(), other.variable_name())
         if c: return c
         # compare coefficients so that the polynomial variable does not count
-        c = cmp(list(self.__polynomial), list(other.__polynomial))
+        c = cmp(list(self.relative_polynomial()), list(other.relative_polynomial()))
         if c: return c
         # compare implementations
         c = cmp(self.implementation(), other.implementation())
@@ -3341 +3340 @@
             if implementation == 'quadratic':
                 # extension of quadratic must be represented by ntl
                 implementation = 'ntl'
+        if implementation == 'flint':
+            implementation = 'singular'
         if not isinstance(poly, polynomial_element.Polynomial):
             try:
                 poly = poly.polynomial(self)
@@ -3353 +3354 @@
         if name is None:
             raise TypeError, "the variable name must be specified."
         from sage.rings.number_field.number_field_rel import NumberField_relative
-        return NumberField_relative(self, poly, str(name), check=check,
-                                    embedding=embedding, implementation=implementation)
+        if implementation == 'singular':
+            from number_field_fast import NumberField_libsingular
+            return NumberField_libsingular(self, poly, str(name), check=check,
+                                           embedding=embedding, implementation=implementation)
+        else:
+            return NumberField_relative(self, poly, str(name), check=check,
+                                        embedding=embedding, implementation=implementation)
 
     def factor(self, n):
         r"""
@@ -3470 +3476 @@
             if self.__polynomial != None:
                 X = self.__polynomial.parent().gen()
             else:
+                from sage.rings.all import PolynomialRing
                 X = PolynomialRing(rational_field.RationalField()).gen()
             self.__gen = self._element_class(self, X)
             return self.__gen
@@ -4788 +4795 @@
         """
         return self.pari_nf().dirzetak(n)
 
+    def multi_polynomial_quotient_ring(self):
+        r"""
+        Return a polynomial quotient ring `R/I`, and maps `f` and `t`,
+        where `f: R/I \to K` and `t:K \to R/I` are isomorphisms, where
+        `K` is self.
+
+        OUTPUT:
+            - `Q` -- quotient of a polynomial ring
+            - `f` -- homomorphism Q to self
+            - `t` -- homomorphism self to Q
+
+        EXAMPLES::
+
+        An absolute extension::
+        
+            sage: K.<a> = NumberField(x^3 + x + 3); Q, f, t = K.multi_polynomial_quotient_ring(); Q
+            Quotient of Multivariate Polynomial Ring in x over Rational Field by the ideal (x^3 + x + 3)
+            sage: f(Q.0)
+            a
+            sage: t(a)
+            a
+
+        A relative extension::
+        
+            sage: K.<a> = NumberField(x^3 + x + 3); R.<y> = K[]; L.<b> = K.extension(y^2 + a*y + a^2)
+            sage: Q, f, t = L.multi_polynomial_quotient_ring();  alpha = L.random_element(); alpha
+            (-12*a^2 - 36*a - 3/2)*b - 71/2*a^2 + 1141/95*a + 3043/95
+            sage: Q
+            Quotient of Multivariate Polynomial Ring in y, x over Rational Field by the ideal (x^3 + x + 3, y^2 + y*x + x^2)
+            sage: Q.gens()
+            (b, a)
+            sage: t(alpha)
+            -12*b*a^2 - 36*b*a - 71/2*a^2 - 3/2*b + 1141/95*a + 3043/95
+            sage: f(t(alpha))
+             (-12*a^2 - 36*a - 3/2)*b - 71/2*a^2 + 1141/95*a + 3043/95
+            sage: f(t(alpha))== alpha
+            True
+        """
+        from sage.rings.all import PolynomialRing, QQ
+        p = self.defining_polynomial()
+        var = p.variable_name()
+        if self.is_absolute():
+            R = PolynomialRing(QQ, 1, names=self.variable_name())
+            p2 = R(p.change_variable_name(self.variable_name()))
+            Q = R.quotient(p2, names=self.variable_name())
+            f = Q.hom([self.gen()])
+            t = self.hom([Q.gen()])
+            return Q, f, t
+        else:
+            B = self.base_field()
+            Q0, f0, t0 = B.multi_polynomial_quotient_ring()
+            R = PolynomialRing(QQ, Q0.ngens()+1, self.variable_names())
+            phi = Q0.cover_ring().hom(R.gens()[1:])
+            x = R.gen(0)
+            p2 = sum(phi(t0(a).lift())*x**i for i, a in enumerate(p.list()))
+            I = R.ideal([phi(g) for g in Q0.defining_ideal().gens()] + [p2])
+            Q = R.quotient(I, names = self.variable_names())
+            t = maps.MapRelativeNumberFieldToMPolynomialQuotient(self, Q, f0, t0)
+            f = t.inverse()
+            return Q, f, t
+
+    def polynomial_quotient_tower(self):
+        """
+        EXAMPLES::
+
+        An absolute extension::
+        
+            sage: K.<a> = NumberField(x^2 + 3)
+            sage: Q, f, t = K.polynomial_quotient_tower(); Q
+            Univariate Quotient Polynomial Ring in a over Rational Field with modulus x^2 + 3
+            sage: f(Q.0^2+3)
+            0
+            sage: f(Q.0-2/3)
+            a - 2/3
+            sage: t(a-2/3)
+            a - 2/3
+
+        A relative extension::
+
+            sage: K.<a,b> = NumberField([x^17 + 7, x^3 + 2])
+            sage: Q, f, t = K.polynomial_quotient_tower()
+            sage: Q
+            Univariate Quotient Polynomial Ring in a over Univariate Quotient Polynomial Ring in b over Rational Field with modulus x^3 + 2 with modulus x^17 + 7
+            sage: f
+            Isomorphism map:
+              From: Univariate Quotient Polynomial Ring in a ...
+              To:   Number Field in a with defining polynomial x^17 + 7...
+            sage: t
+            Isomorphism map:
+              From: Number Field in a with defining polynomial x^17 + 7...
+              To:   Univariate Quotient Polynomial Ring in a ...
+
+
+        A more complicated relative extension::
+
+            sage: K.<a> = NumberField(x^3 + x + 3); R.<y> = K[]
+            sage: L.<b> = K.extension(y^2 + a*y + a^2); L
+            Number Field in b with defining polynomial y^2 + a*y + a^2 over its base field
+            sage: Q, f, t = L.polynomial_quotient_tower(); Q
+            Univariate Quotient Polynomial Ring in b over Univariate Quotient Polynomial Ring in a over Rational Field with modulus x^3 + x + 3 with modulus y^2 + a*y + a^2
+            sage: f(Q.0)
+            b
+            sage: t(L.0)
+            b
+            sage: r = L.random_element(); r
+            (-12*a^2 - 36*a - 3/2)*b - 71/2*a^2 + 1141/95*a + 3043/95
+            sage: t(r)
+            (-12*a^2 - 36*a - 3/2)*b - 71/2*a^2 + 1141/95*a + 3043/95
+            sage: f(t(r))
+            (-12*a^2 - 36*a - 3/2)*b - 71/2*a^2 + 1141/95*a + 3043/95
+            sage: f(t(r)) == r
+            True
+        """
+        p = self.defining_polynomial()
+        if self.is_absolute():
+            R = p.parent()
+            Q = R.quotient(p, names=self.variable_name())
+            f = Q.hom([self.gen()])
+            t = self.hom([Q.gen()])
+            return Q, f, t
+        else:
+            B = self.base_field()
+            Q0, f0, t0 = B.polynomial_quotient_tower()
+            R = Q0[p.variable_name()]
+            q = R([t0(z).lift() for z in p.list()])
+            Q = R.quotient(q, names = self.variable_name())
+            t = maps.MapRelativeNumberFieldToPolynomialQuotientTower(self, Q, f0, t0)
+            f = t.inverse()
+            return Q, f, t
+        
 
 class NumberField_absolute(NumberField_generic):
 
@@ -4840 +4977 @@
             self._zero_element = self(0)
             self._one_element =  self(1)
 
+    def _mpoly_ideal(self):
+        """
+        Return the multivariate polynomial ring ideal that we use to
+        implement arithmetic in the relative extension defined by the
+        given polynomial.
+
+        OUTPUT:
+            - an ideal in a multivariate polynomial ring
+
+        EXAMPLES::
+
+            sage: K.<a> = NumberField(x^3 + 7)
+            sage: K._mpoly_ideal()
+            Ideal (x^3 + 7) of Multivariate Polynomial Ring in x over Rational Field
+            sage: R.<T> = QQ[]
+            sage: K.<alpha> = NumberField(T^3 - 5/3)
+            sage: K._mpoly_ideal()
+            Ideal (T^3 - 5/3) of Multivariate Polynomial Ring in T over Rational Field
+        """
+        polynomial = self.polynomial()
+        from sage.rings.all import PolynomialRing, QQ
+        R = PolynomialRing(QQ,1,names=polynomial.variable_name())
+        I = R.ideal([polynomial])
+        return I
+
     def _coerce_from_other_number_field(self, x):
         """
         Coerce a number field element x into this number field.
@@ -4900 +5062 @@
             TypeError: <type 'sage.rings.polynomial.polynomial_zz_pex.Polynomial_ZZ_pEX'>
 
         One can also coerce an element of the polynomial quotient ring
-        that's isomorphic to the number field: 
+        that's isomorphic to the number field::
+        
             sage: K.<a> = NumberField(x^3 + 17)
             sage: b = K.polynomial_quotient_ring().random_element()
             sage: K(b)

sage/rings/number_field/number_field_element_libsingular.pxd

@@ -35 +35 @@
 cdef void nfelt_mul(nfelt_t rop, nfelt_t op1, nfelt_t op2, nf_t K)
 cdef void nfelt_add(nfelt_t rop, nfelt_t op1, nfelt_t op2, nf_t K)
 cdef void nfelt_sub(nfelt_t rop, nfelt_t op1, nfelt_t op2, nf_t K)
+cdef void nfelt_neg(nfelt_t rop, nfelt_t op, nf_t K)
 cdef void nfelt_div(nfelt_t q, nfelt_t n, nfelt_t d, nf_t K)
-cdef void nfelt_div(nfelt_t q, nfelt_t n, nfelt_t d, nf_t K)
+cdef void nfelt_pow_ui(nfelt_t rop, nfelt_t op, unsigned long exp, nf_t K)
 
 cdef void nfelt_canonicalize(nfelt_t rop, nf_t K)
 cdef object nfelt_pystr(nfelt_t op, nf_t K)
@@ -58 +59 @@
     cdef nfelt_t poly
     cdef _new(self)
     cdef MPolynomialRing_libsingular mpoly_ring(self)
+    cdef MPolynomial_libsingular coerce(self, x)
     cdef imp(self)
 
     

sage/rings/number_field/number_field_element_libsingular.pyx

@@ -28 +28 @@
     int unlikely(int)
     int likely(int)
 
+# We do this to force compilation of the file using C++.  Once this is
+# moved to a library, there will be a different solution to including
+# fmpq_poly.
+cdef extern from "../../libs/flint/fmpq_poly.c":
+    pass
+
 include "../../ext/stdsage.pxi"
 
 from sage.structure.element cimport RingElement, ModuleElement, Element
 from number_field_base cimport NumberField
 
 from sage.libs.singular.decl cimport (
-    p_Copy, p_Delete, p_ISet,
+    p_Copy, p_Delete, p_GetCoeff, p_ISet, p_Init, p_SetCoeff,
+    p_GetExp, p_SetExp, pNext, p_Setm, p_Add_q,
     currRing, rChangeCurrRing,
     redNF, redtailBba, 
-    IDELEMS, idInit, idLift, id_Delete)
+    IDELEMS, idInit, idLift, id_Delete,
+    number, nlInit2gmp,
+    pTakeOutComp1)
+
+from sage.libs.gmp.mpq cimport (
+    mpq_t, mpq_init, mpq_clear,
+    mpq_numref, mpq_denref, mpq_sgn)
+
+from sage.libs.gmp.mpz cimport (
+    mpz_t, mpz_init_set_si, mpz_clear)
+
+from sage.libs.flint.fmpq_poly cimport (
+    fmpq_poly_t,
+    fmpq_poly_get_coeff_mpq, fmpq_poly_degree)
 
 # singular poly arith
 from sage.libs.singular.polynomial cimport (
     singular_polynomial_call, singular_polynomial_cmp,
-    singular_polynomial_add, singular_polynomial_sub,
+    singular_polynomial_add, singular_polynomial_sub, singular_polynomial_neg,
     singular_polynomial_neg, singular_polynomial_rmul, singular_polynomial_mul,
     singular_polynomial_div_coeff, singular_polynomial_pow,
     singular_polynomial_str, singular_polynomial_latex,
     singular_polynomial_str_with_changed_varnames,
     singular_polynomial_deg, singular_polynomial_length_bounded)
 
-from implementation cimport ArithmeticImplementation_libsingular
+from sage.rings.integer cimport Integer
+from sage.rings.rational cimport Rational
+
+from implementation cimport ArithmeticImplementation
+
+cdef class ArithmeticImplementation_libsingular(ArithmeticImplementation):
+    cdef object nf_t_wrap
+    cdef object ideal
+    cdef object ring
+    cdef object field_to_ring
+    cdef object base_field
+    def __init__(self, ideal, field_to_ring, base_field):
+        """
+        EXAMPLES::
+
+            sage: sage.rings.number_field.implementation.ArithmeticImplementation_libsingular()
+            Arithmetic implementation 'singular'
+        """
+        ArithmeticImplementation.__init__(self, 'singular')
+        self.nf_t_wrap = nf_t_wrap(ideal)
+        self.ideal = ideal
+        self.ring = ideal.ring()
+        self.field_to_ring = field_to_ring
+        self.base_field = base_field
+
+from number_field_element_flint cimport NumberFieldElement_flint
 
 cdef class NumberFieldElement_libsingular(NumberFieldElement):
 
@@ -127 +172 @@
 
     #### end BENCHMARKING CODE 
 
-    def __init__(self, parent, f):
+    def __init__(self, parent, x):
+        """
+        You can coerce the following types in:
+
+            - MPolynomial_libsingular -- in which case x is supposed to be in the
+              multivariate polynomial ring corresponding to the parent.
+            - NumberFieldElement_libsingular -- in which case x is assumed to be
+              in either the base field or in parent.
+            - NumberFieldElement_flint -- in which x must be in the base field of self.
+            - Integer 
+
+        The above stated assumptions need not be checked.
+        
+        EXAMPLES::
+        """
+        cdef poly *p, *q, *mon
+        cdef number* c
+        cdef ring *R_p, *R_q
+        cdef long exponent
+        cdef fmpq_poly_t f
+        cdef mpq_t t
+        cdef mpz_t z, z2
+        
         self._parent = parent
-        #cdef MPolynomial_libsingular g = self.mpoly_ring()(f)
-        cdef MPolynomial_libsingular g = self.mpoly_ring().gen()
-        nfelt_init_set_poly(self.poly, g._poly, imp(self).nf)
+        if PY_TYPE_CHECK(x, MPolynomial_libsingular):
+            #print "MPolynomial_libsingular --> "
+            # Directly set the pointer.  Note we are assuming here
+            # that the ring containing x is correct.
+            p = (<MPolynomial_libsingular>x)._poly
+            
+        elif PY_TYPE_CHECK(x, NumberFieldElement_libsingular):
+            #print "NumberFieldElement_libsingular --> "
+            # x is an element of the base field, and the base field is
+            # a relative extension.  We construct a multivariate
+            # polynomial from x in the bigger ring (with one more
+            # variable adjoined).
+
+            # Get a pointer to the underlying libsingular polynomial
+            q = (<NumberFieldElement_libsingular>x).poly.poly
+
+            # Get the libsingular rings for both p and q, which are
+            # stored in their implementation nf objects.
+            R_q = imp(x).nf.ring
+            R_p = imp(self).nf.ring
+
+            # Initialize p (which will be the image of q) to 0.
+            p = p_ISet(0, R_p)
+
+            # Now we iterate over each coefficient of q, grabbing
+            # the corresponding monomial.
+            while q:
+                # Switch to the ring R_q and grab the leading coefficient
+                rChangeCurrRing(R_q)
+                c = p_GetCoeff(q, R_q)
+
+                # If the coefficient is nonzero, add the corresponding
+                # coefficient*monomial to p.
+                if c:
+                    rChangeCurrRing(R_p)
+                    mon = p_Init(R_p)      # make a new unitialized monomial (pointer to a poly)
+                    p_SetCoeff(mon, c, R_p)
+                    # iterate over the variables, getting the exponents
+                    for j in range(1, R_p.N):  
+                        exponent = p_GetExp(q, j, R_q)
+                        if exponent:
+                            # We set the exponent of the (j+1)th variable, because the map
+                            # from the smaller field to this one is:
+                            #    Q[y,z] \---> Q[x,y,z], i.e., the first variable is the new one.
+                            p_SetExp(mon, j+1, exponent, R_p)
+                    # Finalize the change (having set p_SetExp).
+                    p_Setm(mon, R_p)
+                    # Replace p by p plus the monomial (with coefficient).
+                    p = p_Add_q(p, mon, R_p)
+                # Move to the next monomial of q.
+                q = pNext(q)
+
+        elif PY_TYPE_CHECK(x, NumberFieldElement_flint):
+            #print "NumberFieldElement_flint --> "
+            
+            # Now x is represented by a flint polynomial.
+            # We iterate through its coefficient, setting
+            # the corresponding monomial of p.
+
+            # Get the ring for self, and initialize p to 0.
+            R_p = imp(self).nf.ring
+            p = p_ISet(0, R_p)
+
+            mpq_init(t)
+
+            # Get C-level access to underlying flint polynomial.
+            f[0] = ((<NumberFieldElement_flint>x).f)[0]
+            #print "    degree =", fmpq_poly_degree(f)
+            for exponent in range(fmpq_poly_degree(f)+1):
+                # Get the i-th coefficient as a GMP integer
+                fmpq_poly_get_coeff_mpq(t, f, exponent)
+                if mpq_sgn(t) != 0:   # if the coefficient is nonzero
+                    # Make a Singular number.
+                    c = nlInit2gmp(mpq_numref(t), mpq_denref(t))
+                    # Set the coefficient, then exponent of the variable.
+                    mon = p_Init(R_p)
+                    p_SetCoeff(mon, c, R_p)
+                    # It must be the last variable, since FLINT is always at bottom of tower
+                    p_SetExp(mon, R_p.N, exponent, R_p)
+                    # Finalize the change (having set p_SetExp).
+                    p_Setm(mon, R_p)
+                    # Now add the monomial to p.
+                    p = p_Add_q(p, mon, R_p)
+                    
+            mpq_clear(t)
+
+        elif PY_TYPE_CHECK(x, Integer):
+
+            # Get the ring for self, and initialize p to 0.
+            R_p = imp(self).nf.ring
+            # Initialize p to 0
+            p = p_Init(R_p)
+            # Create the GMP integer 1, for the denominator below.
+            mpz_init_set_si(z, 1)
+            # Create a singular number from x.
+            c = nlInit2gmp((<Integer>x).value, z)
+            # Set p to that number.
+            p_SetCoeff(p, c, R_p)
+            p_Setm(p, R_p)   # and finalize
+            mpz_clear(z)
+            
+        elif PY_TYPE_CHECK(x, Rational):
+
+            # Get the ring for self, and initialize p to 0.
+            R_p = imp(self).nf.ring
+            # Initialize p to 0
+            p = p_Init(R_p)
+            # Create the GMP integer 1, for the denominator below.
+            # Create a singular number from x.
+            c = nlInit2gmp(mpq_numref((<Rational>x).value), mpq_denref((<Rational>x).value))
+            # Set p to that number.
+            p_SetCoeff(p, c, R_p)
+            p_Setm(p, R_p)   # and finalize
+            mpz_clear(z)
+
+        elif PY_TYPE_CHECK(x, int):
+
+            # TODO -- surely there is a vastly better way to do this.
+            R_p = imp(self).nf.ring
+            p = p_Init(R_p)
+            mpz_init_set_si(z, 1)
+            mpz_init_set_si(z2, x)
+            c = nlInit2gmp(z2, z)
+            p_SetCoeff(p, c, R_p)
+            p_Setm(p, R_p)   
+            mpz_clear(z)
+            mpz_clear(z2)
+            
+        else:
+            raise TypeError
+
+        # Set self to the result of the above. 
+        nfelt_init_set_poly(self.poly, p, imp(self).nf)
+
+    def __dealloc__(self):
+        nfelt_clear(self.poly, imp(self).nf)
 
     cdef imp(self):
         cdef ArithmeticImplementation_libsingular A
         A = <ArithmeticImplementation_libsingular> (<NumberField>self._parent)._implementation
         return A
 
+    cdef MPolynomial_libsingular coerce(self, x):
+        print x, type(x)
+        if isinstance(x, MPolynomial_libsingular): return x
+        cdef ArithmeticImplementation_libsingular A
+        A = <ArithmeticImplementation_libsingular> (<NumberField>self._parent)._implementation
+        # TODO: having to lift here is stupid; but fixing this is going to require even
+        # more maps in maps.py... ugh.
+        return A.field_to_ring(x).lift()
+
     cdef inline MPolynomialRing_libsingular mpoly_ring(self):
         cdef ArithmeticImplementation_libsingular A
         A = <ArithmeticImplementation_libsingular> (<NumberField>self._parent)._implementation
@@ -171 +380 @@
         nfelt_sub(rop.poly, self.poly, (<NumberFieldElement_libsingular>right).poly, imp(self).nf)
         return rop
 
+    def __neg__(self):
+        cdef NumberFieldElement_libsingular rop = self._new()
+        nfelt_neg(rop.poly, self.poly, imp(self).nf)
+        return rop
+
     cpdef RingElement _div_(self, RingElement right):
         if nfelt_is_zero((<NumberFieldElement_libsingular>right).poly):
             raise ZeroDivisionError
@@ -185 +399 @@
         nfelt_invert(rop.poly, self.poly, imp(self).nf)
         return rop
 
+    def __pow__(NumberFieldElement_libsingular self, long exp, dummy):
+        """
+        EXAMPLES::
+        """
+        if exp < 0:
+            return self.__invert__().__pow__(-exp)
+        cdef NumberFieldElement_libsingular rop = self._new()
+        nfelt_pow_ui(rop.poly, self.poly, exp, imp(self).nf)
+        return rop
+
     def __richcmp__(left, right, int op):
         return (<Element>left)._richcmp(right, op)
 
@@ -274 +498 @@
     nfelt_clear(rop, K)
     singular_polynomial_sub(&(rop.poly), op1.poly, op2.poly, K.ring)
     
+cdef void nfelt_neg(nfelt_t rop, nfelt_t op, nf_t K):
+    nfelt_clear(rop, K)
+    singular_polynomial_neg(&(rop.poly), op.poly, K.ring)
+
 cdef void nfelt_div(nfelt_t q, nfelt_t n, nfelt_t d, nf_t K):
     cdef ideal *I, *nI, *res
+
+    # TODO: I did benchmarks, and in some examples this is easily
+    # way slower than magma, say by a factor of 10 or more.  Not good.
+    # E.g., comparing this in Sage:
+    #   K.<a,b> = NumberField([x^6 + 2*x^3 + 7, x^10 +17*x + 152])
+    # with some simple divides to this in Magma
+    #   R<x> := PolynomialRing(RationalField());
+    #   K<a,b> := NumberField([x^6 + 2*x^3 + 7, x^10 +17*x + 152]);
     
     # Initialize the ideal generated by n.
     nI = idInit(1, 1)
     nI.m[0] = p_Copy(n.poly, K.ring)
 
     # Initialize the ideal with generators [d] + K.ideal.gens()
-    I = idInit(IDELEMS(K.ideal)+1, 1)
+    I = idInit(IDELEMS(K.ideal) + 1, 1)
     I.m[0] = p_Copy(d.poly, K.ring)
-    for i in range(1, IDELEMS(K.ideal)+1):
+    for i in range(1, IDELEMS(K.ideal) + 1):
         I.m[i] = p_Copy(K.ideal.m[i-1], K.ring)
 
     # Now compute the lift of nI
     res = idLift(I, nI, NULL, 0, 0, 0)
+
+    # The answer is the first entry in the lift.
     nfelt_clear(q, K)
-    q.poly = p_Copy(res.m[0], K.ring)
+    #q.poly = p_Copy(res.m[0], K.ring)
+    q.poly = pTakeOutComp1(&res.m[0], 1)
+
+    # Clean up.
     id_Delete(&nI, K.ring)
     id_Delete(&I, K.ring)
+    id_Delete(&res, K.ring)
+
+cdef void nfelt_pow_ui(nfelt_t rop, nfelt_t op, unsigned long exp, nf_t K):
+    nfelt_clear(rop, K)
+    singular_polynomial_pow(&(rop.poly), op.poly, exp, K.ring)
+    nfelt_canonicalize(rop, K)
 
 cdef void nfelt_canonicalize(nfelt_t op, nf_t K):
     if unlikely(K.ring != currRing): rChangeCurrRing(K.ring)
     cdef int max_ind
-    op.poly = redNF(p_Copy(op.poly, K.ring), max_ind, 0, K.strategy)
+    op.poly = redNF(op.poly, max_ind, 0, K.strategy)
     if likely(op.poly != NULL):
         op.poly = redtailBba(op.poly, max_ind, K.strategy)
 
@@ -310 +557 @@
 cdef nf_t_wrap imp(NumberFieldElement_libsingular x):
     return (<ArithmeticImplementation_libsingular>(x.imp())).nf_t_wrap
 
-
 cdef class nf_t_wrap:
     def __init__(self, ideal):
         self.ideal = ideal
         nf_init_sage_ideal(self.nf, ideal)
+
         
+        

new file sage/rings/number_field/number_field_fast.pyx

@@ +1 @@
+include "../../ext/stdsage.pxi"
+
+import number_field_rel
+from sage.rings.integer cimport Integer
+from sage.rings.rational cimport Rational
+from number_field_element_libsingular import NumberFieldElement_libsingular
+
+class NumberField_libsingular(number_field_rel.NumberField_libsingular):
+    def _element_constructor_(self, x):
+        if PY_TYPE_CHECK(x, Integer):
+            return NumberFieldElement_libsingular(self, x)            
+        if PY_TYPE_CHECK(x, Rational):
+            return NumberFieldElement_libsingular(self, x)            
+        return super(NumberField_libsingular, self)._element_constructor_(x)
+

sage/rings/number_field/number_field_morphisms.pyx

@@ -103 +103 @@
 
     def __init__(self, K, L, ambient_field=None):
         """
-        EXAMPLES: 
+        EXAMPLES: :
+        
             sage: from sage.rings.number_field.number_field_morphisms import EmbeddedNumberFieldMorphism
             sage: K.<a> = NumberField(x^2-17, embedding=4.1)
             sage: L.<b> = NumberField(x^4-17, embedding=2.0)
@@ -124 +125 @@
               To:   Cyclotomic Field of order 36 and degree 12
               Defn: zeta12 -> zeta36^3
             
-        The embeddings must be compatible:
+        The embeddings must be compatible::
+        
             sage: F1 = NumberField(x^3 + 2, 'a', embedding=2)
             sage: F2 = NumberField(x^3 + 2, 'a', embedding=CC.0)
             sage: F1.gen() + F2.gen()
@@ -143 +145 @@
     
     def section(self):
         """
-        EXAMPLES:
+        EXAMPLES::
+        
             sage: from sage.rings.number_field.number_field_morphisms import EmbeddedNumberFieldMorphism
             sage: K.<a> = NumberField(x^2-700, embedding=25)
             sage: L.<b> = NumberField(x^6-700, embedding=3)

sage/rings/number_field/number_field_rel.py

@@ -276 +276 @@
             polynomial = polynomial.change_ring(base)
 
         #########################################
+        # Trivial initialization that must be done
+        # before constructing implementation object
+        # below.
+        #########################################        
+        self.__base_field = base
+        self.__relative_polynomial = polynomial
+        
+        #########################################
+        # Compute the generators of this field,
+        # going down the tower and coercing in
+        # each generator. 
+        #########################################        
+        self.__gens = [None]
+        v = [None]
+        K = base
+        names = [name]
+        while K != QQ:
+            names.append(K.variable_name())
+            v.append(K.gen())
+            K = K.base_field()
+        self._assign_names(tuple(names), normalize=False)
+
+        #########################################
         # Set the implementation object
-        #########################################        
+        #########################################
+        # TODO
+        implementation = 'singular'
+        
         if implementation == 'default':
             implementation = number_field.DEFAULT_IMPLEMENTATION['relative']
             
@@ -295 +321 @@
             import number_field_element_libsingular
             self._element_class = number_field_element_libsingular.NumberFieldElement_libsingular
             self._order_element_class = number_field_element_libsingular.OrderElement_libsingular
-            ring, ideal = self._libsingular_ring(polynomial)
-            self._set_implementation(arithmetic_implementation.ArithmeticImplementation_libsingular(ideal))
+            Q,_,to_Q = self.multi_polynomial_quotient_ring()
+            ideal = Q.defining_ideal()
+            self._set_implementation(number_field_element_libsingular.ArithmeticImplementation_libsingular(
+                ideal, to_Q, base))
         else:
             raise ValueError, "invalid relative number field implementation '%s'"%implementation
         assert self.implementation() is not None
@@ -318 +346 @@
             from_abs_base = maps.IdentityMap(base)
             to_abs_base = maps.IdentityMap(base)
         self.__absolute_base_field = abs_base, from_abs_base, to_abs_base
-        self.__base_field = base
-        self.__relative_polynomial = polynomial
 
         # Check that defining polynomial for this field is irreducible. 
         if check:
@@ -330 +356 @@
                 # polynomials over number fields -- see ticket #4724
                 raise ValueError, "defining polynomial (%s) must be irreducible"%polynomial
 
-        #########################################
-        # Compute the generators of this field,
-        # going down the tower and coercing in
-        # each generator. 
-        #########################################        
-        self.__gens = [None]
-        v = [None]
-        K = base
-        names = [name]
-        while K != QQ:
-            names.append(K.variable_name())
-            v.append(K.gen())
-            K = K.base_field()
 
         #########################################
         # Generic initialization
         #########################################        
-        self._assign_names(tuple(names), normalize=False)
         NumberField_generic.__init__(self, self.absolute_polynomial(), name=None,
                                      latex_name=latex_name, check=False,
                                      embedding=embedding)
@@ -356 +368 @@
         # Now we can finish our gens initialization
         #########################################        
         v[0] = self._gen_relative()
+        self.__gens = tuple(v)
         v = [self(x) for x in v]
         self.__gens = tuple(v)
         self._zero_element = self(0)
         self._one_element =  self(1)
 
-    def _libsingular_ring(self, polynomial):
-        """
-        Return the libsingular ring that we use to implement arithmetic in
-        the relative extension defined by the given polynomial.
-
-        INPUT:
-            - ``polynomial`` -- a polynomial over a number field
-
-        OUTPUT:
-            - a singular multivariate polynomial ring
-            - an ideal
-        """
-        from sage.rings.all import PolynomialRing, QQ
-        ring = PolynomialRing(QQ, 2, names=('x','y'))
-        x,y = ring.gens()
-        ideal = ring.ideal([x**3+7,y**3+2])
-        return ring, ideal
-
     def change_names(self, names):
         r"""
         Return relative number field isomorphic to self but with the
@@ -776 +771 @@
             sage: type(K.Hom(K))
             <class 'sage.rings.number_field.morphism.RelativeNumberFieldHomset_with_category'>
         """
-
         from number_field import is_NumberFieldHomsetCodomain
         if is_NumberFieldHomsetCodomain(codomain):
             import morphism
@@ -819 +813 @@
         """
         if x.parent() is self.base_ring() or x.parent() == self.base_ring():
             return self.__base_inclusion(x)
+            
         f = x.polynomial()
         if f.degree() <= 0:
             return self._element_class(self, f[0])
@@ -1465 +1460 @@
         if self.implementation().use_absolute_polynomials():
             f = self._absolute_pari_polynomial()
         else:
-            f = self.polynomial_ring().gen()
+            f = self.multi_polynomial_quotient_ring()[0].gen(0).lift()
         return self._element_class(self, f)
 
     @cached_method
@@ -2424 +2419 @@
     return NumberField_relative(base_field, poly, name, latex_name, check=False, embedding=canonical_embedding)
 
 NumberField_extension_v1 = NumberField_relative_v1  # historical reasons only
+
+
+
+#####################
+
+import number_field_element
+import sage.modules.free_module_element
+
+class NumberField_libsingular(NumberField_relative):
+    def _coerce_from_other_number_field(self, x):
+        K = self.base_field()
+        if x.parent() != K: x = K(x)
+        return self._element_class(self, x)
+
+    def _coerce_non_number_field_element_in(self, x):
+        return self._element_class(self, self.base_field()(x))
+
+    def _element_constructor_(self, x):
+        if isinstance(x, integer.Integer):
+            return self._element_class(self, x)
+        
+        if number_field_element.is_NumberFieldElement(x):
+            K = x.parent()
+            if K is self:
+                return x
+            elif K == self:
+                return self._element_class(self, x.polynomial())
+            elif number_field_element.is_OrderElement(x):
+                L = K.number_field()
+                if L == self:
+                    return self._element_class(self, x)
+                x = L(x)
+            return self._coerce_from_other_number_field(x)
+        elif isinstance(x,str):
+            return self._coerce_from_str(x)
+        elif isinstance(x, (tuple, list)) or \
+                (isinstance(x, sage.modules.free_module_element.FreeModuleElement) and
+                 self.base_ring().has_coerce_map_from(x.parent().base_ring())):
+            if len(x) != self.relative_degree():
+                raise ValueError, "Length must be equal to the degree of this number field"
+            result = x[0]
+            for i in xrange(1,self.relative_degree()):
+                result += x[i]*self.gen(0)**i
+            return result
+        return self._coerce_non_number_field_element_in(x)
+        

sage/rings/number_field/todo.txt

@@ -38 +38 @@
    [x] make sure the _cmp_c_impl's are compatible across number field element implementations.
    [x] make default implementation computation be centralized somehow??
 
+   [x] isomorphisms between number fields and univariate poly tower
+
+   [x] isomorphisms between number fields and multi poly ring
+
+   [x] add loads/dumps doctests to all of maps.py, along with __cmp__ methods
+
+   [x] optimize coercion in
+
+   [x] fix division for singular nf elts
+
+
+   [ ] fix construction of towers with more than 2 fields in them.
+   [ ] make it so creation of relative number fields doesn't require computing
+       some stupid absolute polynomial, which takes forever.  that's stupid. 
+
+-------------------------------------
+
+
+   [ ] loads/dumps in maps.py broken due to non-uniqueness of homsets -- see rings/homset.py
+       I tried for about an hour to make this unique in various ways, but got ass kicked.
+   
+   [ ] move the arithmetic implementation objects to the relevant element files, and make
+       sure module_list.py is maximally conservative
+
    [ ] libsingular elements:
        [ ] constructing the corresponding ring
 
-
    [ ] implement OrderElement_singular
 
    [ ] write general implementation of algorithm for computing absolute_field