trac_9541-part7-generic_elts.patch on Ticket #9541 – Attachment – Sage

sage/rings/number_field/implementation.pyx

# HG changeset patch
# User William Stein <wstein@gmail.com>
# Date 1279753987 -7200
# Node ID 53c4551ed34f4ee655eb78c0b9c87fb3c45a9d51
# Parent  f09d5a19ec34645612cc112d30fa735cc7b77aa0
[mq]: trac_9541-part7-generic_elts.patch

diff -r f09d5a19ec34 -r 53c4551ed34f sage/rings/number_field/implementation.pyx

-                      a
         """
         return cmp(self.name(), right.name())
+    def use_absolute_polynomials(self):
+        """
+        Returns True if in this implementation elements of a relative
+        extension are represented using an absolute polynomial.
+        EXAMPLES::
+             sage: sage.rings.number_field.implementation.ArithmeticImplementation('test').use_absolute_polynomials()
+             False
+        """
+        return False
 cdef class ArithmeticImplementation_generic(ArithmeticImplementation):
     def __init__(self, modulus):
         """
 …
         """
         return self.__class__, (self.modulus, )
+    def use_absolute_polynomials(self):
+        """
+        Returns True if in this implementation elements of a relative
+        extension are represented using an absolute polynomial.
+        EXAMPLES::
+            sage: A = sage.rings.number_field.implementation.ArithmeticImplementation_generic(x^2 + 3)
+            sage: A.use_absolute_polynomials()
+            False
+        """
+        return False
 cdef class ArithmeticImplementation_ntl(ArithmeticImplementation):
     def __init__(self):
         """
 …
         """
         ArithmeticImplementation.__init__(self, 'ntl')
+    def use_absolute_polynomials(self):
+        """
+        Returns True if in this implementation elements of a relative
+        extension are represented using an absolute polynomial.
+        EXAMPLES::
+            sage: sage.rings.number_field.implementation.ArithmeticImplementation_ntl().use_absolute_polynomials()
+            True
+        """
+        return True
 cdef class ArithmeticImplementation_flint(ArithmeticImplementation):
     def __init__(self, modulus):
         """
 …
     def __dealloc__(self):
         fmpq_poly_clear(self.modulus)
+    def use_absolute_polynomials(self):
+        """
+        Returns True if in this implementation elements of a relative
+        extension are represented using an absolute polynomial.
+        EXAMPLES::
+            sage: R.<x> = QQ[]
+            sage: sage.rings.number_field.implementation.ArithmeticImplementation_flint(x-1).use_absolute_polynomials()
+            True
+        """
+        return True
 cdef class ArithmeticImplementation_singular(ArithmeticImplementation):
     def __init__(self):

sage/rings/number_field/maps.py

diff -r f09d5a19ec34 -r 53c4551ed34f sage/rings/number_field/maps.py

-                      a
     def _call_(self, v):
         """
+        INPUT::
+           - `v` -- element
+        INPUT:
+            - `v` -- element
         EXAMPLES::
+            sage: K.<a,b> = NumberField([x^3+2,x^2-2]); phi = K.relative_vector_space()[1]
+            sage: K.<a,b> = NumberField([x^3 + 7, x^3 + 2], implementation='generic')
+            sage: V,f,t = K.relative_vector_space()
+            sage: [f(z) for z in V.basis()]
+            [1, a, a^2]
+            sage: K.<a,b> = NumberField([x^3+2, x^2-2]); phi = K.relative_vector_space()[1]
             sage: V = phi.domain(); phi(V.0 + 3*V.1)
 *a + 1
         """
         # Given a relative vector space element, we have to
         # compute the corresponding number field element, in terms
+        # Given a relative vector space element, this function
+        # computes the corresponding number field element, in terms
         # of an absolute generator.
         w = self.__V(v).list()
+        if self.__K.implementation().use_absolute_polynomials():
+        # First, construct from w a PARI polynomial in x with coefficients
+        # that are polynomials in y:
+        B = self.__B
+        _, to_B = B.structure()
+        # Apply to_B, so now each coefficient is in an absolute field,
+        # and is expressed in terms of a polynomial in y, then make
+        # the PARI poly in x.
+        w = [pari(to_B(a).polynomial('y')) for a in w]
+        h = pari(w).Polrev()
+            # First, construct from w a PARI polynomial in x with coefficients
+            # that are polynomials in y:
+            B = self.__B
+            _, to_B = B.structure()
+        # Next we write the poly in x over a poly in y in terms
+        # of an absolute polynomial for the rnf.
+        g = self.__R(self.__rnf.rnfeltreltoabs(h))
+        return self.__K._element_class(self.__K, g)
+            # Apply to_B, so now each coefficient is in an absolute field,
+            # and is expressed in terms of a polynomial in y, then make
+            # the PARI poly in x.
+            w = [pari(to_B(a).polynomial('y')) for a in w]
+            h = pari(w).Polrev()
+            # Next we write the poly in x over a poly in y in terms
+            # of an absolute polynomial for the rnf.
+            g = self.__R(self.__rnf.rnfeltreltoabs(h))
+            return self.__K._element_class(self.__K, g)
+        else:
+            # much easier case
+            return self.__K._element_class(self.__K, w)
 class MapRelativeNumberFieldToRelativeVectorSpace(NumberFieldIsomorphism):
     def __init__(self, K, V):
 …
         """
         TESTS::
+            sage: K.<a> = NumberField(x^5+2)
+            sage: K.<a,b> = NumberField([x^3 + 7, x^3 + 2], implementation='generic')
+            sage: V,f,t = K.relative_vector_space()
+            sage: t(a)
+            (0, 1, 0)
+            sage: t(b)
+            (b, 0, 0)
+            sage: t(a^2*b + a - 3/4)
+            (-3/4, 1, b)
+        The ntl implementation tests the code in the case when
+        everything is represented using an absolute polynomial::
+            sage: K.<a> = NumberField(x^5+2, implementation='ntl')
             sage: R.<y> = K[]
             sage: D.<x0> = K.extension(y + a + 1)
             sage: D(a)
 …
             (a)
         """
         # An element of a relative number field is represented
+        # internally by an absolute polynomial over QQ.
+        # internally by either a relative or absolute polynomial over QQ.
         alpha = self.__K(alpha)
+        if not self.__K.implementation().use_absolute_polynomials():
+            return self.__V(alpha.relative_polynomial().padded_list(self.__K.relative_degree()))
+        # 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.
+        else:
+            # The case of an absolute polynomial...
+            #
+            # 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)])
+            # 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))
+        # 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
+        # coefficients define the coordinates of the vector we are
+        # constructing.
+        # The list v below has the coefficients that are the
+        # components of the vector we are constructing, but each is
+        # converted into polynomials in a variable x, which we will
+        # use to define elements of the base field.
+        (x, y) = (self.__x, self.__y)
+        v = [g.polcoeff(i).subst(x,y) for i in range(self.__n)]
+        B,from_B, _ = self.__B
+        w = [from_B(B(z)) for z in v]
+            # f is the absolute polynomial that defines this number field
+            # element
+            f = alpha.polynomial('x')
+            g = self.__rnf.rnfeltabstorel(pari(f))
+            # 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
+            # coefficients define the coordinates of the vector we are
+            # constructing.
+        # Now w gives the coefficients.
+        return self.__V(w)
+            # The list v below has the coefficients that are the
+            # components of the vector we are constructing, but each is
+            # converted into polynomials in a variable x, which we will
+            # use to define elements of the base field.
+            (x, y) = (self.__x, self.__y)
+            v = [g.polcoeff(i).subst(x,y) for i in range(self.__n)]
+            B,from_B, _ = self.__B
+            w = [from_B(B(z)) for z in v]
+            # Now w gives the coefficients.
+            return self.__V(w)
 class IdentityMap(NumberFieldIsomorphism):
 …
     EXAMPLES::
         sage: K.<a> = NumberField(x^6 + 4*x^2 + 200)
+        sage: L = K.relativize(K.subfields(3)[0][1], 'b'); L
+        Number Field in b0 with defining polynomial x^2 + a0 over its base field
+        sage: L = K.relativize(K.subfields(3)[0][1], 'b')
         sage: fr, to = L.structure()
         sage: fr
         Relative number field morphism:
 …
         """
         EXAMPLES::
             sage: K.<a,b> = NumberField([x^2+1,x^2+3]); L.<c> = K.absolute_field(); phi = L.structure()[1]
+            sage: K.<a,b> = NumberField([x^2+1, x^2+3]); L.<c> = K.absolute_field(); phi = L.structure()[1]
             sage: phi(a+b)
             -1/2*c^3 - 4*c
             sage: L.structure()[0](phi(a+b))
 …
 /3
             sage: phi(2/3).parent()
             Number Field in c with defining polynomial x^4 + 8*x^2 + 4
+            sage: K.<a,b> = NumberField([x^3+2,x^3+3])
+            sage: L.<c> = K.absolute_field()
+            sage: phi = L.structure()[1]
+            sage: phi(a)
+            -2/45*c^7 + 7/45*c^4 - 311/45*c
+            sage: phi(b)
+            -2/45*c^7 + 7/45*c^4 - 356/45*c
+            sage: phi(a).minpoly()
+            x^3 + 2
+            sage: phi(b).minpoly()
+            x^3 + 3
         """
         f = self.__R(x).polynomial()
+        f = self.__R(x).absolute_polynomial('x')
         return self.__A._element_class(self.__A, f)
 class MapAbsoluteToRelativeNumberField(NumberFieldIsomorphism):

sage/rings/number_field/number_field.py

diff -r f09d5a19ec34 -r 53c4551ed34f sage/rings/number_field/number_field.py

-                      a
 from sage.rings.real_lazy import RLF, CLF
+# Use this dictionary to set the default implementation for relative
+# and absolute number fields.  Choices include:
+#      - 'ntl'
+#      - 'flint'
+#      - 'generic'
+#      - 'singular'
+#DEFAULT_IMPLEMENTATION = {'relative':'generic', 'absolute':'generic'}
+DEFAULT_IMPLEMENTATION = {'relative':'ntl', 'absolute':'ntl'}
 _nf_cache = {}
 def NumberField(polynomial, name=None, check=True, names=None, cache=True,
                 embedding=None, latex_name=None,
 …
         if polynomial.degree() == 2 and polynomial.base_ring() == QQ:
             implementation = 'quadratic'
         else:
             implementation = 'ntl'
+            implementation = DEFAULT_IMPLEMENTATION['absolute']
     if cache:
         key = (polynomial, polynomial.base_ring(), name, latex_name,
 …
             self._order_element_class = number_field_element_generic.OrderElement_generic
             self._set_implementation(arithmetic_implementation.ArithmeticImplementation_generic(polynomial))
         else:
             raise ValueError, "unknown implementation '%s'"%implementation
+            raise ValueError, "invalid number field implementation '%s'"%implementation
         assert self.implementation() is not None
 …
             a = self(elts[i])
             if self.coerce_embedding() is not None:
                 embedding = self.coerce_embedding()(a)
             K = NumberField(f, names=name + str(i), embedding=embedding)
+            K = NumberField(f, names=name + str(i), embedding=embedding, implementation=self.implementation().name())
             from_K = K.hom([a])    # check=False here ??   would be safe unless there are bugs.
 …
             sage: K.<a> = NumberField(x^2 + 17); type(a)
             <type 'sage.rings.number_field.number_field_element_quadratic.NumberFieldElement_quadratic'>
+            sage: K.<a> = NumberField(x^2 + 17, implementation='generic'); type(a)
+            <type 'sage.rings.number_field.number_field_element_generic.NumberFieldElement_generic'>
+            sage: K.<a> = NumberField(x^2 + 17, implementation='flint'); type(a)
+            <type 'sage.rings.number_field.number_field_element_flint.NumberFieldElement_flint'>
+            sage: K.<a> = NumberField(x^2 + 17, implementation='ntl'); type(a)
+            <type 'sage.rings.number_field.number_field_element_ntl.NumberFieldElement_ntl_absolute'>
+        """
+        """
+        # Only 'quadratic' is supported for this field -- get segfaults otherwise, which
+        # I don't yet have time to fully debug.
+        implementation = 'quadratic'
         NumberField_absolute.__init__(self, polynomial, name=name, check=check, embedding=embedding,
                                       latex_name=latex_name, implementation=implementation)

sage/rings/number_field/number_field_element.pyx

diff -r f09d5a19ec34 -r 53c4551ed34f sage/rings/number_field/number_field_element.pyx

-                      a
             # Compute representation of self in terms of relative vector space.
             return self.relative_polynomial()._repr(K.variable_name())
+    def absolute_polynomial(self, var=None):
+        """
+        Return polynomial that represents self in terms of the
+        isomorphic absolute extension.
+        EXAMPLES::
+            sage: K.<a> = NumberField(x^6 + 4*x^2 + 200); a.absolute_polynomial()
+            x
+            sage: L.<b,b2> = K.relativize(K.subfields(3)[0][1])
+            sage: b.absolute_polynomial()
+            x
+        """
+        if self.is_absolute():
+            return self.polynomial(var)
+        else:
+            if self._parent.implementation().use_absolute_polynomials():
+                return self.polynomial(var)
+            else:
+                return self._parent.absolute_field('z').structure()[1](self).polynomial(var)
     def relative_polynomial(self, var=None):
         """
         Return the polynomial in var (default: 'x') over the base
 …
         ::
             sage: y = QQ['y'].gen()
+            sage: R.<y> = QQ[]
             sage: k.<j> = NumberField(y^3 - 2)
             sage: pari(j)
             Mod(x, x^3 - 2)
 …
         ::
             sage: y = QQ['y'].gen()
+            sage: R.<y> = QQ[]
             sage: k.<j> = NumberField([y^2 - 7, y^3 - 2])
             sage: pari(j)
             Mod(42/5515*x^5 - 9/11030*x^4 - 196/1103*x^3 + 273/5515*x^2 + 10281/5515*x + 4459/11030, x^6 - 21*x^4 + 4*x^3 + 147*x^2 + 84*x - 339)
 …
         if var is None:
             var = self.number_field().variable_name()
         if self.is_absolute():
             f = self.polynomial()._pari_().subst('x', var)
+            f = self.polynomial('x')._pari_().subst('x', var)
             g = self.number_field().pari_polynomial().subst('x', var)
             h = f.Mod(g)
             self.__pari[var] = h
             return h
         else:
             g = self.parent().pari_polynomial(var)
             f = self.polynomial()._pari_()
+            f = self.absolute_polynomial('x')._pari_()
             f = f.subst('x', var)
             h = f.Mod(g)
             self.__pari[var] = h
             return h
     def _pari_init_(self, var='x'):
         """
         Return GP/PARI string representation of self. This is used for

sage/rings/number_field/number_field_element_generic.pyx

diff -r f09d5a19ec34 -r 53c4551ed34f sage/rings/number_field/number_field_element_generic.pyx

-                      a
             <type 'sage.rings.number_field.number_field_element_generic.NumberFieldElement_generic'>
             sage: a.is_absolute()
             True
+            sage: K.<a> = NumberField(x^6 + 4*x^2 + 200)
+            sage: L.<b,b2> = K.relativize(K.subfields(3)[0][1])
+            sage: b.is_absolute()
+            False
         """
         return self._parent.is_absolute()
 …
             self._f = (<NumberFieldElement_generic>f)._f
         else:
             self._f = parent.polynomial_ring()(f)
+            g = self.modulus()
+            if self._f.degree() >= g.degree():
+                self._f = self._f % g
+    def __copy__(self):
+        """
+        EXAMPLES::
+            sage: K.<a> = NumberField(x^5 + 5); L.<c> = K.absolute_field()
+            sage: c.__copy__()
+            c
+            sage: t = L.maximal_order().1; t
+            c
+            sage: t.__copy__()
+            c
+            sage: type(t.__copy__())
+            <type 'sage.rings.number_field.number_field_element_generic.OrderElement_generic'>
+            sage: type(c.__copy__())
+            <type 'sage.rings.number_field.number_field_element_generic.NumberFieldElement_generic'>
+            sage: t.__copy__().parent()
+            Maximal Order in Number Field in c with defining polynomial x^5 + 5
+            sage: c.__copy__().parent()
+            Number Field in c with defining polynomial x^5 + 5
+        """
+        return self._new(self._f)
     cdef _new(self, f):
         cdef NumberFieldElement_generic x = PY_NEW(NumberFieldElement_generic)
 …
         return x
     cdef void _randomize(self, num_bound, den_bound, distribution):
+        raise NotImplementedError
+        K = self._parent.base_field()
+        v = [K.random_element(num_bound, den_bound, distribution) for i in self._parent.degree()]
+        f = self._parent.polynomial_ring()(v)
+        self._f = f
+    def relative_polynomial(self, var=None):
+        """
+        Return the relative polynomial that defines self.
+        For elements with the generic representation, this is the same as self.polynomial().
+        EXAMPLES::
+            sage: K.<a,b> = NumberField([x^3+7, x^3 + 2], implementation='generic')
+            sage: a.relative_polynomial()
+            x
+            sage: (a+3).relative_polynomial('T')
+            T + 3
+            sage: (2/3*a^2+3).relative_polynomial('T')
+/3*T^2 + 3
+            sage: (a^2 + 2*b + 3/4).relative_polynomial()
+            x^2 + 2*b + 3/4
+        """
+        return self.polynomial(var=var)
     def polynomial(self, var=None):
         """
         Return polynomial representative for this number field element, in the variable x.
+        For elements with the generic representation, this is the same as self.relative_polynomial().
         EXAMPLES::

sage/rings/number_field/number_field_element_quadratic.pyx

diff -r f09d5a19ec34 -r 53c4551ed34f sage/rings/number_field/number_field_element_quadratic.pyx

-                      a
 computations in quadratic extensions of `\QQ`.
 AUTHORS:
+- Robert Bradshaw (2007-09): Initial version
+- David Harvey (2007-10): fix up a few bugs, polish around the edges
+- David Loeffler (2009-05): add more documentation and tests
+    - Robert Bradshaw (2007-09): Initial version
+    - David Harvey (2007-10): fix up a few bugs, polish around the edges
+    - David Loeffler (2009-05): add more documentation and tests
 TODO:

sage/rings/number_field/number_field_rel.py

diff -r f09d5a19ec34 -r 53c4551ed34f sage/rings/number_field/number_field_rel.py

-                      a
 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
 - Nick Alexander (2009-01): modernize coercion implementation
+    - 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
+    - Nick Alexander (2009-01): modernize coercion implementation
 This example follows one in the Magma reference manual::
 …
 from sage.rings.complex_double import CDF
 from sage.rings.real_lazy import RLF, CLF
+# from sage.rings.number_field.number_field import is_AbsoluteNumberField
+# from sage.rings.number_field.number_field import is_QuadraticField
+# from sage.rings.number_field.number_field import is_CyclotomicField
+import number_field
 def is_RelativeNumberField(x):
     r"""
 …
             ...
             ValueError: defining polynomial (x^2 + 2) must be irreducible
         """
+        #########################################
+        # Check preconditions
+        #########################################
         if embedding is not None:
             raise NotImplementedError, "Embeddings not implemented for relative number fields"
         if not names is None: name = names
 …
             raise ValueError, "Base field and extension cannot have the same name"
         if polynomial.parent().base_ring() != base:
             polynomial = polynomial.change_ring(base)
-            #raise ValueError, "The polynomial must be defined over the base field"
+        # Generate the nf and bnf corresponding to the base field
+        # defined as polynomials in y, e.g. for rnfisfree
+        # Convert the polynomial defining the base field into a
+        # polynomial in y to satisfy PARI's ordering requirements.
+        if base.is_relative():
+            abs_base = base.absolute_field(name+'0')
+            from_abs_base, to_abs_base = abs_base.structure()
+        else:
+            abs_base = base
+            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
+        #########################################
+        # Set the implementation object
+        #########################################
         if implementation == 'default':
             implementation = 'ntl'
+            implementation = number_field.DEFAULT_IMPLEMENTATION['relative']
         if implementation == 'ntl':
             import number_field_element_ntl
             self._element_class = number_field_element_ntl.NumberFieldElement_ntl_relative
 …
             import number_field_element_singular
             self._element_class = number_field_element_singular.NumberFieldElement_singular
             self._order_element_class = number_field_element_singular.OrderElement_singular
             self._set_implementation(arithmetic_implementation.ArithmeticImplementation_singular())
+            self._set_implementation(arithmetic_implementation.ArithmeticImplementation_singular())
         else:
+            raise ValueError, "unknown implementation '%s'"%implementation
+            raise ValueError, "invalid relative number field implementation '%s'"%implementation
         assert self.implementation() is not None
+        ##################################################################################
+        # Compute the absolute field isomorphic to the base field, which we must do since
+        # PARI can *only* deal with 2-step towers of number fields.
+        ##################################################################################
+        # Generate the nf and bnf corresponding to the base field
+        # defined as polynomials in y, e.g. for rnfisfree.
+        # We also convert the polynomial defining the base field into a
+        # polynomial in y to satisfy PARI's ordering requirements.
+        if base.is_relative():
+            abs_base = base.absolute_field(name+'0')
+            from_abs_base, to_abs_base = abs_base.structure()
+        else:
+            abs_base = base
+            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:
             if not self.pari_relative_polynomial().polisirreducible():
                 # this is *much* faster than
                 # polynomial.is_irreducible() at some point in the
+                # polynomial.is_irreducible(); at some point in the
                 # future, is_irreducible should be made faster for
                 # 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]
 …
             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)
+        #########################################
+        # Now we can finish our gens initialization
+        #########################################
         v[0] = self._gen_relative()
         v = [self(x) for x in v]
         self.__gens = tuple(v)
 …
         """
         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])
 …
             sage: K._coerce_(K.base_field().0)^2
             -3
         """
-        abs_base, from_abs_base, to_abs_base = self.absolute_base_field()
-        # Write element in terms of the absolute base field
-        element = self.base_field().coerce(element)
-        element = to_abs_base(element)
-        # Find an expression in terms of the absolute generator for self of element.
-        expr_x = self._rnfeltreltoabs(element)
-        # Convert to a Sage polynomial, then to one in gen(), and return it
         R = self.polynomial_ring()
+        # We do NOT call self(...) because this code is called by
+        # __init__ before we initialize self.gens(), and self(...)
+        # uses self.gens()
+        return self._element_class(self, R(expr_x))
+        if self.implementation().use_absolute_polynomials():
+            abs_base, from_abs_base, to_abs_base = self.absolute_base_field()
+            # Write element in terms of the absolute base field
+            element = self.base_field().coerce(element)
+            element = to_abs_base(element)
+            # Find an expression in terms of the absolute generator for self of element.
+            expr_x = self._rnfeltreltoabs(element)
+            # Convert to a Sage polynomial, then to one in gen(), and return it
+            # We do NOT call self(...) because this code is called by
+            # __init__ before we initialize self.gens(), and self(...)
+            # uses self.gens()
+            return self._element_class(self, R(expr_x))
+        else:
+            return self._element_class(self, R(element))
     def _fractional_ideal_class_(self):
         """
 …
             sage: c^2 + 3
         """
+        if self.implementation().use_absolute_polynomials():
+            f = self._absolute_pari_polynomial()
+        else:
+            f = self.polynomial_ring().gen()
+        return self._element_class(self, f)
+    @cached_method
+    def _absolute_pari_polynomial(self):
+        """
+        Return polynomial that the generator of self satisfies, in
+        terms of some choice of defining polynomial for the absolute
+        extension.
+        EXAMPLES::
+            sage: K.<a,b> = NumberField([x^3+7, x^3 + 2], implementation='generic')
+            sage: f = K._absolute_pari_polynomial(); f
+/405*x^7 + 7/81*x^4 + 1196/405*x
+            sage: type(f)
+            <type 'sage.libs.pari.gen.gen'>
+            sage: pari('polcompositum(x^3+7, x^3 + 2)')
+            [x^9 - 15*x^6 + 453*x^3 - 125]
+            sage: pari('Mod(2/405*x^7 + 7/81*x^4 + 1196/405*x, x^9 + 15*x^6 + 453*x^3 + 125)^3')
+            Mod(-7, x^9 + 15*x^6 + 453*x^3 + 125)
+        """
         rnfeqn = self._pari_rnfequation()
+        f = (pari('x') - rnfeqn[2]*rnfeqn[1]).lift()
+        g = self._element_class(self, f)
+        return g
+        return (pari('x') - rnfeqn[2]*rnfeqn[1]).lift()
     def pari_polynomial(self, name='x'):
         """

sage/rings/number_field/order.py

diff -r f09d5a19ec34 -r 53c4551ed34f sage/rings/number_field/order.py

-                      a
 from sage.structure.element import is_Element
 #TODO: fix this
 from number_field_element_ntl import OrderElement_ntl_absolute, OrderElement_ntl_relative
+from number_field_element_ntl import OrderElement_ntl_relative
 from number_field_element_quadratic import OrderElement_quadratic
 …
         abs_order = self._absolute_order
         to_abs = abs_order._K.structure()[1]
         x = abs_order(to_abs(x)) # will test membership
         return OrderElement_ntl_relative(self, x)
+        return self.number_field()._order_element_class(self, x)
     def _repr_(self):
         """
 …
         O = self._absolute_order
         K = O.number_field()
         from_K, _ = K.structure()
+        self.__basis = [OrderElement_ntl_relative(self, from_K(a)) for a in O.basis()]
+        self.__basis = [self.number_field()._order_element_class(self, from_K(a)) for
+                        a in O.basis()]
         return self.__basis
     def __add__(left, right):

sage/rings/number_field/todo.txt

diff -r f09d5a19ec34 -r 53c4551ed34f sage/rings/number_field/todo.txt

-                      a
    [x] flint elements
    [x] implement OrderElement_flint
+   [ ] rewrite order elements to use implementation, e.g., this line in order.py:
+   [x] rewrite order elements to use implementation, e.g., this line in order.py:
        #TODO: fix this
        from number_field_element_ntl import OrderElement_absolute, OrderElement_relative
+   [x] stabilize ntl-based code
+   [x] make sure the _cmp_c_impl's are compatible across number field element implementations.
+   [x] make default implementation computation be centralized somehow??
+   [ ] libsingular elements
    [ ] implement OrderElement_singular
+   [ ] generic: get to work in the *relative case*
+   [ ] write general implementation of algorithm for computing absolute_field
+       [ ] find random element
+       [ ] compute charpoly
+       [ ] if irred and squarefree, it gens
+       [ ] do linear algebra to write everything in terms of that elements
+       [ ] setup maps:
+       this class MapRelativeToAbsoluteNumberField in maps.py maybe has to change
+   [ ] libsingular elements
+   [ ] rewrite base class "def _lift_cyclotomic_element(self, new_parent, bint check=True, int rel=0):"
+   [ ] fix unpickling of old nf elts
    [ ] get implementation = 'generic' to fully work as another default type
-   [ ] move data out of elements into implementation objects for ntl and quadratic types
-   [ ] fix all INPUT block list formatting
-   [ ] rewrite base class "def _lift_cyclotomic_element(self, new_parent, bint check=True, int rel=0):"
-   [ ] make default implementation computation be centralized somehow??
-   [ ] fix unpickling of old nf elts
-   [ ] change number_field_element_quadratic to derive from
-       number_field_element code (i.e., the abstract base), instead of
-       deriving from number_field_element_ntl.
-   [ ] write generic ver    def _lift_cyclotomic_element(self, new_parent, bint check=True, int rel=0):
-       of this in number_field_element.pyx
-   [ ] make sure the _cmp_c_impl's are compatible across number field element implementations.
-   [ ] format all documentation perfectly
    [ ] make the implementation part of elements into a cython class hierarchy with
        [ ] implementation object needs to get pickled with number field -- test
        [ ] flint implementation object
        [ ] libsingular implementation object
+   [ ] benchmark for comparison with magma
+   [ ] get doctest coverage to 100% for the number_field directory
+   [ ] benchmark *every single operation* with each type of elements... for sanity
+   [ ] benchmark for comparison with magma
+   [ ] get doctest coverage to 100% for the number_field directory
+   [ ] optimization -- make computing an absolute field lazy, and only
+       do it when we really need it for some computation, e.g.,
+       mazimal order.
+   [ ] this warning: "WARNING: Doing arithmetic in towers of relative
+fields that depends on canonical coercions is currently VERY SLOW.  It
+is much better to explicitly coerce all elements into a common field,
+then do arithmetic with them there (which is quite fast)."
    [ ] arithmetic/automatic coercions between isomorphic fields, where
        the only difference is the underlying implementation of
 …
        [ ] quaternion algebra elements -- deal with that they only work for ntl number field elements
        [ ] matrix_cyclo_dense.pyx
-   [ ] write a function that can be included in doctests that
-       guarantees at least a certain amount of speed.  add this to
-       library so that nobody can frack my shizzle up.
    [ ] add proper headers
    [ ] add overview docs to each file
    [ ] overview of everything
 …
    [ ] suspicious bound:
      "   D = (Dpoly.numer() * Dpoly.denom()).squarefree_part(bound=10000) "
 OTHER:
+For LATER:
+[ ] optimize -- creation of the order generated by elements, especially in relative case (use singular?)
+[ ] plug in sebastian's code for QQ['x']?
+[ ] Organize a similar refactoring for function fields.
+[ ] to look into: non-maximal orders and GB's over ZZ???
+   [ ] write a function that can be included in doctests that
+       guarantees at least a certain amount of speed.  add this to
+       library so that nobody can frack my shizzle up.
+   [ ] benchmark *every single operation* with each type of elements... for sanity
+   [ ] change number_field_element_quadratic to derive from
+       number_field_element code (i.e., the abstract base), instead of
+       deriving from number_field_element_ntl.
+   [ ] fix all INPUT block list formatting
+   [ ] move data out of elements into implementation objects for ntl and quadratic types
+   [ ] optimize -- creation of the order generated by elements, especially in relative case (use singular?)
+   [ ] plug in sebastian's code for QQ['x']?
+   [ ] Organize a similar refactoring for function fields.
+   [ ] to look into: non-maximal orders and GB's over ZZ???

Context Navigation

Ticket #9541: trac_9541-part7-generic_elts.patch

sage/rings/number_field/implementation.pyx

sage/rings/number_field/maps.py

sage/rings/number_field/number_field.py

sage/rings/number_field/number_field_element.pyx

sage/rings/number_field/number_field_element_generic.pyx

sage/rings/number_field/number_field_element_quadratic.pyx

sage/rings/number_field/number_field_rel.py

sage/rings/number_field/order.py

sage/rings/number_field/todo.txt

Download in other formats: