Ticket #5508: sage-5508.2.patch

doc/en/bordeaux_2008/nf_orders.rst

@@ -135 +135 @@
 Sage, we do this by typing ``R.<X> = K[]``. Here ``R.<X>`` means
 "create the object :math:`R` with generator :math:`X`" and ``K[]``
 means a "polynomial ring over :math:`K`", where the generator is named
-based on the afformentioned :math:`X` (to create a polynomial ring in
+based on the aformentioned :math:`X` (to create a polynomial ring in
 two variables :math:`X,Y` simply replace ``R.<X>`` by ``R.<X,Y>``).
 
 .. link
@@ -180 +180 @@
 -----------------------------------
 
 The relative number field :math:`L` also has numerous functions, many
-of which are by default relative. For example the ``degree`` function
-on :math:`L` returns the relative degree of :math:`L` over :math:`K`;
-for the degree of :math:`L` over :math:`\mathbb{Q}` use the
-``absolute_degree`` function.
+of which have both relative and absolute version. For example the 
+``relative_degree`` function on :math:`L` returns the relative degree 
+of :math:`L` over :math:`K`; the degree of :math:`L` over 
+:math:`\mathbb{Q}` is given by the ``absolute_degree`` function.  To
+avoid possible ambiguity ``degree`` is not implemented for relative 
+number fields.
 
 .. link
 
 ::
 
-    sage: L.degree()
+    sage: L.relative_degree()
     3
     sage: L.absolute_degree()
     6
@@ -260 +262 @@
 defining polynomial, and in some cases this can be very slow (much
 slower than Magma). Perhaps this could be fixed by using Singular's
 multivariate polynomials modulo an appropriate ideal, since
-Singular polynomial arithmetic is extremely flast. Also, Sage has
+Singular polynomial arithmetic is extremely fast. Also, Sage has
 very little direct support for constructive class field theory,
 which is a major motivation for explicit computation with relative
 orders; it would be good to expose more of Pari's functionality in

sage/rings/number_field/all.py

@@ -1 +1 @@
 from number_field_base import is_NumberField
 
-from number_field import (NumberField, CyclotomicField, QuadraticField,
+from number_field import (NumberField, NumberFieldTower, CyclotomicField, QuadraticField,
                           is_CyclotomicField, is_QuadraticField,
                           is_AbsoluteNumberField,
                           is_fundamental_discriminant)

sage/rings/number_field/class_group.py

@@ -301 +301 @@
         Return generators for a representative ideal in this
         ideal class.
 
-        EXAMPLE:
+        EXAMPLES:
         sage: K.<w>=QuadraticField(-23)
         sage: OK=K.ring_of_integers()
         sage: C=OK.class_group()

sage/rings/number_field/maps.py

@@ -45 +45 @@
 
 class NumberFieldIsomorphism(Map):
     r"""
-    A base class for various isomorphisms betweeen number fields and
+    A base class for various isomorphisms between number fields and
     vector spaces.
     """
     def _repr_type(self):
@@ -145 +145 @@
         sage: L.<b> = NumberField(x^4 + 3*x^2 + 1)
         sage: K = L.relativize(L.subfields(2)[0][1], 'a'); K
         Number Field in a0 with defining polynomial x^2 - b0*x + 1 over its base field
-        sage: V, fr, to = K.vector_space()
+        sage: V, fr, to = K.relative_vector_space()
         sage: V
         Vector space of dimension 2 over Number Field in b0 with defining polynomial x^2 + 1
         sage: fr
@@ -206 +206 @@
         self.__K = K
         self.__rnf = K.pari_rnf()
         self.__zero = QQ(0)
-        self.__n = K.degree()
+        self.__n = K.relative_degree()
         self.__x = pari('x')
         self.__y = pari('y')
         self.__B = K.absolute_base_field()
@@ -218 +218 @@
         alpha = self.__K(alpha)
         f = alpha.polynomial('x')
         # f is the absolute polynomial that defines this number field element
-        if self.__K.degree() == 1:
+        if self.__K.relative_degree() == 1:
             # Pari doesn't return a valid relative polynomial from an
             # absolute one in the case of relative degree one. (Bug
             # submitted to Pari, fixed in svn unstable as of 1/22/08

sage/rings/number_field/number_field.py

@@ -943 +943 @@
         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.degree():
+            if len(x) != self.relative_degree():
                 raise ValueError, "Length must be equal to the degree of this number field"
-            return sum([ x[i]*self.gen(0)**i for i in range(self.degree()) ])
+            return sum([ x[i]*self.gen(0)**i for i in range(self.relative_degree()) ])
         return self._coerce_non_number_field_element_in(x)
 
-
     def _coerce_from_str(self, x):
         """
         Coerce a string representation of an element of this
@@ -1212 +1211 @@
             sage: to_K(L.0)
             2*i0 - 6
         
-        Note that he image is indeed a square root of -1.
+        Note that the image is indeed a square root of -1.
         
         ::
         
@@ -1876 +1875 @@
         OUTPUT: A list of prime ideals of self lying over x. If degree is
         specified and no such ideal exists, returns the empty list.
         
-        .. warning::
-
-           At this time we factor the ideal x, which may not be
-           supported for relative number fields.
-        
         EXAMPLES::
         
             sage: x = ZZ['x'].gen()
@@ -1933 +1927 @@
             [Fractional ideal (t^2 - 2*t - 1)]
             sage: P5_2 = P5_2s[0]; P5_2.residue_class_degree()
             2
+
+        Works in relative extensions too::
+
+            sage: PQ.<X> = QQ[]
+            sage: F.<a, b> = NumberField([X^2 - 2, X^2 - 3])
+            sage: PF.<Y> = F[]
+            sage: K.<c> = F.extension(Y^2 - (1 + a)*(a + b)*a*b)
+            sage: I = F.ideal(a + 2*b)
+            sage: K.primes_above(I)
+            [Fractional ideal (2, ((-13*b - 45/2)*a - 37/2*b - 63/2)*c + 1),
+             Fractional ideal (5, (5/2*b + 7/2)*a + 2*b + 10)]
+            sage: K.primes_above(I, degree=1)
+            [Fractional ideal (2, ((-13*b - 45/2)*a - 37/2*b - 63/2)*c + 1)]
+            sage: K.primes_above(I, degree=4)
+            [Fractional ideal (5, (5/2*b + 7/2)*a + 2*b + 10)]
         
         TESTS:
 
@@ -1943 +1952 @@
             ...
             AttributeError: 'NumberFieldIdeal' object has no attribute 'factor'
         
-        Sage can't factor ideals over extension fields yet::
-        
-            sage: G = F.extension(x^2 - 11, 'b')
-            sage: G.primes_above(13)
-            Traceback (most recent call last):
-            ...
-            NotImplementedError
         """
         if degree is not None:
             degree = ZZ(degree)
@@ -2040 +2042 @@
             sage: P5_2.residue_class_degree()
             2
         
+        Relative number fields are ok::
+
+            sage: G = F.extension(x^2 - 11, 'b')
+            sage: G.prime_above(7)
+            Fractional ideal (7, (3*t^2 + 2*t + 9)*b - t^2 - 31*t - 10)
+
         TESTS:
 
         It doesn't make sense to factor the ideal (0)::
@@ -2049 +2057 @@
             ...
             AttributeError: 'NumberFieldIdeal' object has no attribute 'factor'
         
-        Sage can't factor ideals over extension fields yet::
-        
-            sage: G = F.extension(x^2 - 11, 'b')
-            sage: G.prime_above(13)
-            Traceback (most recent call last):
-            ...
-            NotImplementedError
         """
         ids = self.primes_above(x, degree)
         if not ids:
@@ -2242 +2243 @@
             ...
             TypeError: Unable to coerce number field defined by non-integral polynomial to PARI.
         """
-        if self.defining_polynomial().denominator() != 1:
+        if self.absolute_polynomial().denominator() != 1:
             raise TypeError, "Unable to coerce number field defined by non-integral polynomial to PARI."
         try:
             return self.__pari_nf
@@ -2738 +2739 @@
         r"""
         Compute the different fractional ideal of this number field.
         
-        The different is the set of all `x` in `K` such
-        that the trace of `xy` is an integer for all
-        `y \in O_K`.
+        The codifferent is the fractional ideal of all `x` in `K` 
+        such that the the trace of `xy` is an integer for 
+        all `y \in O_K`.  
+
+        The different is the integral ideal which is the inverse of 
+        the codifferent.
         
         EXAMPLES::
         
@@ -3148 +3152 @@
             [1, zeta15, zeta15^2, zeta15^3, zeta15^4, zeta15^5, zeta15^6, zeta15^7]
         """
         g = self.gen()
-        return [ g**i for i in range(self.degree()) ]
+        return [ g**i for i in range(self.relative_degree()) ]
 
     def integral_basis(self, v=None):
         """
@@ -3670 +3674 @@
             sage: M.polynomial_ring()
             Univariate Polynomial Ring in y over Number Field in a1 with defining polynomial y^2 + 1
         """
-        return self.polynomial().parent()
+        return self.relative_polynomial().parent()
 
     def polynomial_quotient_ring(self):
         """
@@ -3683 +3687 @@
             sage: K.polynomial_quotient_ring()
             Univariate Quotient Polynomial Ring in alpha over Rational Field with modulus x^3 + 2*x - 5
         """
-        return self.polynomial_ring().quotient(self.polynomial(), self.variable_name())
+        return self.polynomial_ring().quotient(self.relative_polynomial(), self.variable_name())
         
     def regulator(self, proof=None):
         """
@@ -5339 +5343 @@
                 
         assert False, "bug in relativize"
 
+    # Synonyms so that terminology appropriate to relative number fields
+    # can be applied to an absolute number field:
+
+    def absolute_degree(self):
+        """
+        A synonym for degree.
+
+        EXAMPLES::
+
+            sage: K.<i> = NumberField(x^2 + 1)
+            sage: K.absolute_degree()
+            2
+        """
+        return self.degree()
+
+    def relative_degree(self):
+        """
+        A synonym for degree.
+
+        EXAMPLES::
+
+            sage: K.<i> = NumberField(x^2 + 1)
+            sage: K.relative_degree()
+            2
+        """
+        return self.degree()
+
+    def absolute_polynomial(self):
+        """
+        A synonym for polynomial.
+
+        EXAMPLES::
+
+            sage: K.<i> = NumberField(x^2 + 1)
+            sage: K.absolute_polynomial()
+            x^2 + 1
+        """
+        return self.polynomial()
+
+    def relative_polynomial(self):
+        """
+        A synonym for polynomial.
+
+        EXAMPLES::
+
+            sage: K.<i> = NumberField(x^2 + 1)
+            sage: K.relative_polynomial()
+            x^2 + 1
+        """
+        return self.polynomial()
+
+    def absolute_vector_space(self):
+        """
+        A synonym for vector_space.
+
+        EXAMPLES::
+
+            sage: K.<i> = NumberField(x^2 + 1)
+            sage: K.absolute_vector_space()
+            (Vector space of dimension 2 over Rational Field,
+             Isomorphism map:
+              From: Vector space of dimension 2 over Rational Field
+              To:   Number Field in i with defining polynomial x^2 + 1,
+             Isomorphism map:
+              From: Number Field in i with defining polynomial x^2 + 1
+              To:   Vector space of dimension 2 over Rational Field)
+        """
+        return self.vector_space()
+
+    def relative_vector_space(self):
+        """
+        A synonym for vector_space.
+
+        EXAMPLES::
+
+            sage: K.<i> = NumberField(x^2 + 1)
+            sage: K.relative_vector_space()
+            (Vector space of dimension 2 over Rational Field,
+             Isomorphism map:
+              From: Vector space of dimension 2 over Rational Field
+              To:   Number Field in i with defining polynomial x^2 + 1,
+             Isomorphism map:
+              From: Number Field in i with defining polynomial x^2 + 1
+              To:   Vector space of dimension 2 over Rational Field)
+        """
+        return self.vector_space()
+
+    def absolute_discriminant(self):
+        """
+        A synonym for discriminant.
+
+        EXAMPLES::
+
+            sage: K.<i> = NumberField(x^2 + 1)
+            sage: K.absolute_discriminant()
+            -4
+        """
+        return self.discriminant()
+
+    def relative_discriminant(self):
+        """
+        A synonym for discriminant.
+
+        EXAMPLES::
+
+            sage: K.<i> = NumberField(x^2 + 1)
+            sage: K.relative_discriminant()
+            -4
+        """
+        return self.discriminant()
+
+    def absolute_different(self):
+        """
+        A synonym for different.
+
+        EXAMPLES::
+
+            sage: K.<i> = NumberField(x^2 + 1)
+            sage: K.absolute_different()
+            Fractional ideal (2)
+        """
+        return self.different()
+
+    def relative_different(self):
+        """
+        A synonym for different.
+
+        EXAMPLES::
+
+            sage: K.<i> = NumberField(x^2 + 1)
+            sage: K.relative_different()
+            Fractional ideal (2)
+        """
+        return self.different()
+
+
 class NumberField_cyclotomic(NumberField_absolute):
     """
     Create a cyclotomic extension of the rational field.
@@ -6049 +6189 @@
         else:
             return (ZZ(0), ZZ(m/2))
 
+    def different(self):
+        """
+        Returns the different ideal of the cyclotomic field self.
+
+        EXAMPLES::
+
+            sage: C20 = CyclotomicField(20)
+            sage: C20.different()
+            Fractional ideal (-4*zeta20^7 + 8*zeta20^5 - 12*zeta20^3 + 6*zeta20)
+            sage: C18 = CyclotomicField(18)
+            sage: D = C18.different().norm()
+            sage: D == C18.discriminant().abs()
+            True
+        """
+        try:
+            return self.__different
+        
+        except AttributeError:
+            
+            z = self.gen()
+            n = self._n()
+            D = self.ideal(1)
+            factors = n.factor()
+            for f in factors:
+                p = f[0]
+                r = f[1]
+                e = (r*p - r - 1)*p**(r-1)
+                D *= self.ideal(z**(n/p**r) - 1)**e
+            self.__different = D
+            return self.__different
+
     def discriminant(self, v=None):
         """
         Returns the discriminant of the ring of integers of the cyclotomic
@@ -6324 +6495 @@
         if n%2:
             v += [-x for x in v]    
         return v
-   
+
+
 class NumberField_quadratic(NumberField_absolute):
     """
     Create a quadratic extension of the rational field.

sage/rings/number_field/number_field_element.pyx

@@ -567 +567 @@
             ...
             IndexError: index must be between 0 and degree minus 1.
         
-        The list method implicitly calls __getitem__::
+        The list method implicitly calls ``__getitem__``::
         
             sage: list(c)
             [8/27, -16/15, 32/25, -64/125]
@@ -1791 +1791 @@
             sage: (O.2).vector()
             (1, -b)
         """
-        return self.number_field().vector_space()[2](self)
+        return self.number_field().relative_vector_space()[2](self)
 
     def charpoly(self, var='x'):
         raise NotImplementedError, "Subclasses of NumberFieldElement must override charpoly()"
@@ -1951 +1951 @@
             v = []
             x = K.gen()
             a = K(1)
-            d = K.degree()
+            d = K.relative_degree()
             for n in range(d):
                 v += (a*self).list()
                 a *= x
@@ -2410 +2410 @@
     def __init__(self, parent, f):
         NumberFieldElement.__init__(self, parent, f)
 
+    def __getitem__(self, n):
+        """
+        Return the n-th coefficient of this relative number field element, written
+        as a polynomial in the generator.
+        
+        Note that `n` must be between 0 and `d-1`, where
+        `d` is the relative degree of the number field.
+        
+        EXAMPLES::
+        
+            sage: K.<a, b> = NumberField([x^3 - 5, x^2 + 3])
+            sage: c = (a + b)^3; c
+            3*b*a^2 - 9*a - 3*b + 5
+            sage: c[0]
+            -3*b + 5
+        
+        We illustrate bounds checking::
+        
+            sage: c[-1]
+            Traceback (most recent call last):
+            ...
+            IndexError: index must be between 0 and the relative degree minus 1.
+            sage: c[4]
+            Traceback (most recent call last):
+            ...
+            IndexError: index must be between 0 and the relative degree minus 1.
+        
+        The list method implicitly calls ``__getitem__``::
+        
+            sage: list(c)
+            [-3*b + 5, -9, 3*b]
+            sage: K(list(c)) == c
+            True
+        """
+        if n < 0 or n >= self.parent().relative_degree():
+            raise IndexError, "index must be between 0 and the relative degree minus 1."
+        return self.vector()[n]
+
     def list(self):
         """
         Return the list of coefficients of self written in terms of a power

sage/rings/number_field/number_field_ideal.py

@@ -224 +224 @@
             sage: I   # random sign in output
             Fractional ideal (-2*a^2 - 1)
         """
-        # The first method does not work for ideals in relative extensions
-        try:
-            return self.coordinates(self.number_field()(x)).denominator() == 1
-        except NotImplementedError:
-            x_ideal = self.number_field().ideal(x)
-            return self + x_ideal == self
+        return self.coordinates(self.number_field()(x)).denominator() == 1
 
     def __elements_from_hnf(self, hnf):
         """
@@ -508 +503 @@
         uses \code{bnfisprincipal}, so set \code{proof=True} if you
         want to prove correctness (which \emph{is} the default).
 
-        EXAMPLE:
+        EXAMPLES:
             sage: R.<x> = PolynomialRing(QQ)
             sage: K.<i> = NumberField(x^2+1, 'i')
             sage: J = K.ideal([i+1, 2])
@@ -561 +556 @@
         r"""
         Return a list of generators for this ideal as a $\mathbb{Z}$-module.
 
-        EXAMPLE:
+        EXAMPLES:
             sage: R.<x> = PolynomialRing(QQ)        
             sage: K.<i> = NumberField(x^2 + 1)
             sage: J = K.ideal(i+1)
@@ -576 +571 @@
         Return a tuple (I, d), where I is an integral ideal, and d is the
         smallest positive integer such that this ideal is equal to I/d.
 
-        EXAMPLE:
+        EXAMPLES:
             sage: R.<x> = PolynomialRing(QQ)
             sage: K.<a> = NumberField(x^2-5)
             sage: I = K.ideal(2/(5+a))
@@ -747 +742 @@
         self._norm = QQ(self.number_field().pari_nf().idealnorm(self.pari_hnf()))
         return self._norm
 
+    # synonyms (using terminology of relative number fields)
+
+    def absolute_norm(self):
+        """
+        A synonym for norm.
+
+        EXAMPLES:
+            sage: K.<i> = NumberField(x^2 + 1)
+            sage: K.ideal(1 + 2*i).absolute_norm()
+            5
+        """
+        return self.norm()
+
+    def relative_norm(self):
+        """
+        A synonym for norm.
+
+        EXAMPLES:
+            sage: K.<i> = NumberField(x^2 + 1)
+            sage: K.ideal(1 + 2*i).relative_norm()
+            5
+        """
+        return self.norm()
+
+    def absolute_ramification_index(self):
+        """
+        A synonym for ramification_index.
+
+        EXAMPLES:
+            sage: K.<i> = NumberField(x^2 + 1)
+            sage: K.ideal(1 + i).absolute_ramification_index()
+            2
+        """
+        return self.ramification_index()
+
+    def relative_ramification_index(self):
+        """
+        A synonym for ramification_index.
+
+        EXAMPLES:
+            sage: K.<i> = NumberField(x^2 + 1)
+            sage: K.ideal(1 + i).relative_ramification_index()
+            2
+        """
+        return self.ramification_index()
+
     def number_field(self):
         """
         Return the number field that this is a fractional ideal in.
@@ -763 +804 @@
 
     def smallest_integer(self):
         r"""
-        Return the smallest nonnegative integer in $I \cap \mathbb{Z}$,
+        Return the smallest non-negative integer in $I \cap \mathbb{Z}$,
         where $I$ is this ideal.  If $I = 0$, returns $0$.
         
-        EXAMPLE:
+        EXAMPLES:
             sage: R.<x> = PolynomialRing(QQ)
             sage: K.<a> = NumberField(x^2+6)
             sage: I = K.ideal([4,a])/7
@@ -1110 +1151 @@
         assuming it is prime.  Otherwise, raise a ValueError.
 
         The ramification index is the power of this prime appearing in
-        the factorization of the prime in $\ZZ$ that this primes lies
+        the factorization of the prime in $\ZZ$ that this prime lies
         over.
 
         EXAMPLES:
@@ -1317 +1358 @@
             False
             sage: (j/k).is_coprime(j/k)
             False
+
+            sage: F.<a, b> = NumberField([x^2 - 2, x^2 - 3])
+            sage: F.ideal(3 - a*b).is_coprime(F.ideal(3))
+            False
         """
         # Catch invalid inputs by making sure that we can make an ideal out of other.
         K = self.number_field()
         one = K.unit_ideal()
         other = K.ideal(other)
         if self.is_integral() and other.is_integral():            
-            if arith.gcd(ZZ(self.norm()), ZZ(other.norm())) == 1:
+            if arith.gcd(ZZ(self.absolute_norm()), ZZ(other.absolute_norm())) == 1:
                 return True
             else:
                 return self+other == one
         # This special case is necessary since the zero ideal is not a
         # fractional ideal!
-        if other.norm() == 0:
+        if other.absolute_norm() == 0:
             return self == one
         D1 = self.denominator()
         N1 = self.numerator()
@@ -1404 +1449 @@
             M_self = MatrixSpace(ZZ,n)([R.coordinates(y) for y in self_b])
             M_other = MatrixSpace(ZZ,n)([R.coordinates(y) for y in other_b])
         except TypeError:
-            raise TypeError, "element_1_mod only defined for integral ideals"
+            raise TypeError, "element_1_mod only defined for integral ideals"
  
         #hnf for matrix representing C = self+other:
         C = M_self.stack(M_other)
@@ -1448 +1493 @@
             True
             sage: I.euler_phi()*J.euler_phi() == (I*J).euler_phi()
             True
+            sage: L.<b> = K.extension(x^2 - 7)
+            sage: L.ideal(3).euler_phi()
+            64
         """
         if not self.is_integral():
             raise ValueError, "euler_phi only defined for integral ideals"
         return prod([(np-1)*np**(e-1) \
-                     for np,e in [(p.norm(),e) \
+                     for np,e in [(p.absolute_norm(),e) \
                                   for p,e in self.factor()]])
+
     def prime_to_idealM_part(self, M):
         """
         Version for integral ideals of the prime_to_m_part function over ZZ.

sage/rings/number_field/number_field_ideal_rel.py

@@ -6 +6 @@
    -- William Stein (2007-09-06)
    -- Nick Alexander (2009-01)
 
-EXAMPLEES:
+EXAMPLES:
     sage: K.<a,b> = NumberField([x^2 + 1, x^2 + 2])
     sage: A = K.absolute_field('z')
     sage: I = A.factor(3)[0][0]
@@ -15 +15 @@
     [3, (-2*b - 1)*a + b - 1]
     sage: K.fractional_ideal(G)
     Fractional ideal ((-b + 1)*a - b - 2)
-    sage: K.fractional_ideal(G).absolute_ideal().norm().factor()
+    sage: K.fractional_ideal(G).absolute_norm().factor()
     3^2
 """
 
@@ -35 +35 @@
 #*****************************************************************************
 
 from number_field_ideal import NumberFieldFractionalIdeal, convert_from_zk_basis
+from sage.structure.factorization import Factorization
 
 import sage.rings.rational_field as rational_field
+import sage.rings.integer_ring as integer_ring
 QQ = rational_field.RationalField()
+ZZ = integer_ring.IntegerRing()
 
 class NumberFieldFractionalIdeal_rel(NumberFieldFractionalIdeal):
     """
@@ -61 +64 @@
         sage: ((a0 + 1) / g).is_integral()
         True
     """
+    def __cmp__(self, other):
+        """
+        Compare an ideal of a relative number field to something else.
+
+        EXAMPLES:
+            sage: K.<a, b> = NumberField([x^2 + 23, x^2 - 7])
+            sage: I = K.ideal(2, (a + 2*b + 3)/2)
+            sage: J = K.ideal(2, a - b)
+            sage: I == J
+            False
+        """
+        if not isinstance(other, NumberFieldFractionalIdeal):
+            return cmp(type(self), type(other))
+        return cmp(self.pari_rhnf(), other.pari_rhnf())
+
+    def _contains_(self, x):
+        """
+        Return True if x is an element of this ideal.
+
+        This function is called (indirectly) when the \code{in}
+        operator is used.
+
+        EXAMPLES:
+            sage: K.<a, b> = NumberField([x^2 + 23, x^2 - 7])
+            sage: I = K.ideal(2, (a + 2*b + 3)/2)
+            sage: [z in I for z in [a, b, 2, a + b]]
+            [False, False, True, True]
+        """
+        abs_ideal = self.absolute_ideal()
+        to_abs = abs_ideal.number_field().structure()[1]
+        return to_abs(x) in abs_ideal
+
     def pari_rhnf(self):
         """
         Return PARI's representation of this relative ideal in Hermite
@@ -104 +139 @@
             Fractional ideal (b)
             sage: J.absolute_ideal()
             Fractional ideal (a^2)
-            sage: J.norm()
+            sage: J.relative_norm()
             Fractional ideal (2)
-            sage: J.norm().norm()
+            sage: J.absolute_norm()
             4
             sage: J.absolute_ideal().norm()
             4
@@ -117 +152 @@
             Fractional ideal (c)
             sage: J.absolute_ideal()
             Fractional ideal (a)
-            sage: J.absolute_ideal().norm()
+            sage: J.absolute_norm()
             2
             sage: J.ideal_below()
             Fractional ideal (b)
@@ -148 +183 @@
             Fractional ideal (22584817, a - b - 120132)
             sage: (2*a + b) in J
             True
-            sage: (- b - 120132).minpoly()
-            x + b + 120132
-            sage: J.norm().norm()
+            sage: J.absolute_norm()
             22584817
             sage: J.absolute_ideal()
             Fractional ideal (188/812911*a^5 - 1/812911*a^4 + 45120/812911*a^3 - 56/73901*a^2 + 3881638/812911*a + 50041/812911)
@@ -162 +195 @@
         """
         L = self.number_field()
         K = L.absolute_field('a')
-        K_to_L, L_to_K = K.structure()
-        rnf = L.pari_rnf()
-        nf_zk = id.number_field().pari_nf().getattr('zk')
-        gens_in_K = [ QQ['x'](x) for x in nf_zk * id.pari_hnf()]
-        # each gen is now a polynomial giving an element of the absolute number field
-        gens_in_L = [ L(K(x)) for x in gens_in_K ]
-        return L.ideal( gens_in_L )
+        to_L = K.structure()[0]
+        return L.ideal([to_L(g) for g in id.gens()])
 
     def free_module(self):
         return self.absolute_ideal().free_module()
@@ -179 +207 @@
         except AttributeError:
             L = self.number_field()
             K = L.base_field()
-            R = L.polynomial().parent()
+            R = L.relative_polynomial().parent()
             S = L['x']
             gens = L.pari_rnf().rnfidealtwoelt(self.pari_rhnf())
             gens = [ L(R(x.lift().lift())) for x in gens ]
@@ -215 +243 @@
         zero = self.number_field().pari_rnf().rnfidealhnf(0)
         return self.pari_rhnf() == zero
 
-    def norm(self):
+    def absolute_norm(self):
         """
-        Compute the relative norm of this extension L/K as an ideal of K.
+        Compute the absolute norm of this fractional ideal in a relative number
+        field, returning a positive integer.
 
-        EXAMPLE:
+        EXAMPLES:
+            sage: L.<a, b, c> = QQ.extension([x^2 - 23, x^2 - 5, x^2 - 7])
+            sage: I = L.ideal(a + b)
+            sage: I.absolute_norm()
+            104976
+            sage: I.relative_norm().relative_norm().relative_norm()
+            104976
+        """
+        return self.absolute_ideal().norm()
+
+    def relative_norm(self):
+        """
+        Compute the relative norm of this fractional ideal in a relative number
+        field, returning an ideal in the base field.
+
+        EXAMPLES:
             sage: R.<x> = QQ[]
             sage: K.<a> = NumberField(x^2+6)
             sage: L.<b> = K.extension(K['x'].gen()^4 + a)
-            sage: N = L.ideal(b).norm(); N
+            sage: N = L.ideal(b).relative_norm(); N
             Fractional ideal (-a)
             sage: N.parent()
             Monoid of ideals of Number Field in a with defining polynomial x^2 + 6
             sage: N.ring()
             Number Field in a with defining polynomial x^2 + 6
+            sage: PQ.<X> = QQ[]
+            sage: F.<a, b> = NumberField([X^2 - 2, X^2 - 3])
+            sage: PF.<Y> = F[]
+            sage: K.<c> = F.extension(Y^2 - (1 + a)*(a + b)*a*b)
+            sage: K.ideal(1).relative_norm()
+            Fractional ideal (1)
+            sage: K.ideal(13).relative_norm().relative_norm()
+            Fractional ideal (28561)
+            sage: K.ideal(13).relative_norm().relative_norm().relative_norm()
+            815730721
+            sage: K.ideal(13).absolute_norm()
+            815730721
         """
         L = self.number_field()
         K = L.base_field()
-        R = K.polynomial().parent()
+        K_abs = K.absolute_field('a')
+        to_K = K_abs.structure()[0]
+        R = K_abs.polynomial().parent()
         hnf = L.pari_rnf().rnfidealnormrel(self.pari_rhnf())
-        return K.ideal([ K(R(x)) for x in convert_from_zk_basis(K, hnf) ])
+        return K.ideal([ to_K(K_abs(R(x))) for x in convert_from_zk_basis(K, hnf) ])
+
+    def norm(self):
+        """
+        The norm of a fractional ideal in a relative number field is deliberately
+        unimplemented, so that a user cannot mistake the absolute norm
+        for the relative norm, or vice versa.
+        """
+        raise NotImplementedError, "For a fractional ideal in a relative number field you must use relative_norm or absolute_norm as appropriate"
 
     def ideal_below(self):
         """
         Compute the ideal of K below this ideal of L.
 
-        EXAMPLE:
+        EXAMPLES:
             sage: R.<x> = QQ[]
             sage: K.<a> = NumberField(x^2+6)
             sage: L.<b> = K.extension(K['x'].gen()^4 + a)
@@ -307 +373 @@
             True
             sage: K0.ideal([-a0 + 1]) == K0.ideal([-a0 + 5])
             False
+
+            It works when the base_field is itself a relative number field
+            sage: PQ.<X> = QQ[]
+            sage: F.<a, b> = NumberFieldTower([X^2 - 2, X^2 - 3])
+            sage: PF.<Y> = F[]
+            sage: K.<c> = F.extension(Y^2 - (1 + a)*(a + b)*a*b)
+            sage: I = K.ideal(3, c)
+            sage: J = I.ideal_below(); J
+            Fractional ideal (-b*a + 3)
+            sage: J.number_field() == F
+            True
         """
         L = self.number_field()
         K = L.base_field()
-        R = K.polynomial().parent()
+        K_abs = K.absolute_field('a')
+        to_K = K_abs.structure()[0]
+        R = K_abs.polynomial().parent()
         hnf = L.pari_rnf().rnfidealdown(self.pari_rhnf())
-        return K.ideal([ K(R(x)) for x in convert_from_zk_basis(K, hnf) ])
+        return K.ideal([ to_K(K_abs(R(x))) for x in convert_from_zk_basis(K, hnf) ])
 
     def factor(self):
-        raise NotImplementedError
+        """
+        Factor the ideal by factoring the corresponding ideal 
+        in the absolute number field.
+
+        EXAMPLES:
+            sage: K.<a, b> = QQ.extension([x^2 + 11, x^2 - 5])
+            sage: K.factor(5)
+            (Fractional ideal (5, 1/2*a - 1/2*b - 1))^2 * (Fractional ideal (5, 1/2*a - 1/2*b + 1))^2
+            sage: K.ideal(5).factor()
+            (Fractional ideal (5, 1/2*a - 1/2*b - 1))^2 * (Fractional ideal (5, 1/2*a - 1/2*b + 1))^2
+            sage: K.ideal(5).prime_factors()
+            [Fractional ideal (5, 1/2*a - 1/2*b - 1),
+             Fractional ideal (5, 1/2*a - 1/2*b + 1)]
+
+            sage: PQ.<X> = QQ[]
+            sage: F.<a, b> = NumberFieldTower([X^2 - 2, X^2 - 3])
+            sage: PF.<Y> = F[]
+            sage: K.<c> = F.extension(Y^2 - (1 + a)*(a + b)*a*b)
+            sage: K.ideal(c)
+            Fractional ideal (6, -2*c + (171/2*b + 291/2)*a + 117*b + 216)
+            sage: K.ideal(c).factor()
+            (Fractional ideal (2, ((-13*b - 45/2)*a - 37/2*b - 63/2)*c + 1))^2 * (Fractional ideal (3, c))
+        """
+        F = self.number_field()
+        abs_ideal = self.absolute_ideal()
+        to_F = abs_ideal.number_field().structure()[0]
+        factor_list = [(F.ideal([to_F(g) for g in p.gens()]), e) for p, e in abs_ideal.factor()]
+        # sorting and simplification will already have been done
+        return Factorization(factor_list, sort=False, simplify=False)
+
     def integral_basis(self):
         raise NotImplementedError
+
     def integral_split(self):
-        raise NotImplementedError
-    def is_maximal(self):
-        raise NotImplementedError
+        """
+        Return a tuple (I, d), where I is an integral ideal, and d is the
+        smallest positive integer such that this ideal is equal to I/d.
+
+        EXAMPLES:
+            sage: K.<a, b> = NumberFieldTower([x^2 - 23, x^2 + 1])
+            sage: I = K.ideal([a + b/3])
+            sage: J, d = I.integral_split()
+            sage: J.is_integral()
+            True
+            sage: J == d*I
+            True
+
+        """
+        d = self.absolute_ideal().integral_split()[1]
+        return (d*self, d)
+    
     def is_prime(self):
-        raise NotImplementedError
-    def ramification(self):
-        raise NotImplementedError
+        """
+        Return True if this ideal of a relative number field is prime.
+
+        EXAMPLES:
+            sage: K.<a, b> = NumberField([x^2 - 17, x^3 - 2])
+            sage: K.ideal(a + b).is_prime()
+            True
+            sage: K.ideal(13).is_prime()
+            False
+        """
+        return self.absolute_ideal().is_prime()
+
+    def is_integral(self):
+        """
+        Return True if this ideal is integral.
+
+        EXAMPLES:
+           sage: K.<a, b> = QQ.extension([x^2 + 11, x^2 - 5])
+           sage: I = K.ideal(7).prime_factors()[0]
+           sage: I.is_integral()
+           True
+           sage: (I/2).is_integral()
+           False
+        """
+        return self.absolute_ideal().is_integral()
+
+    def absolute_ramification_index(self):
+        """
+        Return the absolute ramification index of this fractional ideal,
+        assuming it is prime.  Otherwise, raise a ValueError.
+
+        The absolute ramification index is the power of this prime 
+        appearing in the factorization of the rational prime that 
+        this prime lies over.
+
+        Use relative_ramification_index to obtain the power of this
+        prime occurring in the factorization of the prime ideal
+        of the  base field that this prime lies over.
+
+        EXAMPLES:
+            sage: PQ.<X> = QQ[]
+            sage: F.<a, b> = NumberFieldTower([X^2 - 2, X^2 - 3])
+            sage: PF.<Y> = F[]
+            sage: K.<c> = F.extension(Y^2 - (1 + a)*(a + b)*a*b)
+            sage: I = K.ideal(3, c)
+            sage: I.absolute_ramification_index()
+            4
+            sage: I.smallest_integer()
+            3
+            sage: K.ideal(3) == I^4
+            True
+        """
+        if self.is_prime():
+            return self.absolute_ideal().ramification_index()
+        raise ValueError, "the fractional ideal (= %s) is not prime"%self
+
+    def relative_ramification_index(self):
+        """
+        Return the relative ramification index of this fractional ideal,
+        assuming it is prime.  Otherwise, raise a ValueError.
+
+        The relative ramification index is the power of this prime 
+        appearing in the factorization of the prime ideal of the  
+        base field that this prime lies over.
+
+        Use absolute_ramification_index to obtain the power of this
+        prime occurring in the factorization of the rational prime
+        that this prime lies over.
+
+        EXAMPLES:
+            sage: PQ.<X> = QQ[]
+            sage: F.<a, b> = NumberFieldTower([X^2 - 2, X^2 - 3])
+            sage: PF.<Y> = F[]
+            sage: K.<c> = F.extension(Y^2 - (1 + a)*(a + b)*a*b)
+            sage: I = K.ideal(3, c)
+            sage: I.relative_ramification_index()
+            2
+            sage: I.ideal_below()
+            Fractional ideal (-b*a + 3)
+            sage: K.ideal(-b*a + 3) == I^2
+            True
+        """
+        if self.is_prime():
+            abs_index = self.absolute_ramification_index()
+            base_ideal = self.ideal_below()
+            return ZZ(abs_index/base_ideal.absolute_ramification_index())
+        raise ValueError, "the fractional ideal (= %s) is not prime"%self
+
+    def ramification_index(self):
+        """
+        For ideals in relative number fields ramification_index is
+        deliberately not implemented in order to avoid ambiguity.  Either
+        relative_ramification_index or absolute_ramification_index should
+        be used instead.
+        """
+        raise NotImplementedError, "For an ideal in a relative number field you must use relative_ramification_index or absolute_ramification_index as appropriate"
+
     def residue_class_degree(self):
-        raise NotImplementedError
+        """
+        EXAMPLES:
+            sage: PQ.<X> = QQ[]
+            sage: F.<a, b> = NumberFieldTower([X^2 - 2, X^2 - 3])
+            sage: PF.<Y> = F[]
+            sage: K.<c> = F.extension(Y^2 - (1 + a)*(a + b)*a*b)
+            sage: [I.residue_class_degree() for I in K.ideal(c).prime_factors()]
+            [1, 2]
+         """
+        if self.is_prime():
+            return self.absolute_ideal().residue_class_degree()
+        raise ValueError, "the ideal (= %s) is not prime"%self
+
+    def residues(self):
+        """
+        Returns a iterator through a complete list of residues modulo this integral ideal.
+
+        An error is raised if this fractional ideal is not integral.
+
+        EXAMPLES:
+            sage: K.<a, w> = NumberFieldTower([x^2 - 3, x^2 + x + 1])
+            sage: I = K.ideal(6, -w*a - w + 4)
+            sage: list(I.residues())[:5]
+            [(-10/3*w - 8/3)*a,
+             (-10/3*w - 8/3)*a + 1,
+             (-10/3*w - 8/3)*a + 2,
+             (-10/3*w - 8/3)*a + 3,
+             (-10/3*w - 8/3)*a + 4]
+        """
+        abs_ideal = self.absolute_ideal()
+        from_abs = abs_ideal.number_field().structure()[0]
+        from sage.misc.mrange import xmrange_iter
+        abs_residues = abs_ideal.residues()
+        return xmrange_iter(abs_residues.iter_list, lambda c: from_abs(abs_residues.typ(c)))
+
+    def element_1_mod(self, other):
+        """
+        Returns an element r in this ideal such that 1-r is in other.
+
+        An error is raised if either ideal is not integral of if they
+        are not coprime.
+                      
+        INPUT:
+            other -- another ideal of the same field, or generators of an ideal.
+        OUTPUT:
+            r -- an element of the ideal self such that 1-r is in the ideal other.
+
+        EXAMPLES:
+            sage: K.<a, b> = NumberFieldTower([x^2 - 23, x^2 + 1])
+            sage: I = Ideal(2, (a - 3*b + 2)/2)
+            sage: J = K.ideal(a)
+            sage: z = I.element_1_mod(J); z
+            -21/2*b*a - 21/2
+            sage: z in I
+            True
+            sage: 1 - z in J
+            True
+        """
+        # Catch invalid inputs by making sure that we can make an ideal out of other.
+        K = self.number_field()
+        if not self.is_integral():
+            raise TypeError, "%s is not an integral ideal"%self
+ 
+        other = K.ideal(other)
+        if not other.is_integral():
+            raise TypeError, "%s is not an integral ideal"%other
+     
+        if not self.is_coprime(other):
+            raise TypeError, "%s and %s are not coprime ideals"%(self, other)
+
+        to_K = K.absolute_field('a').structure()[0]
+        return to_K(self.absolute_ideal().element_1_mod(other.absolute_ideal()))
+
     def smallest_integer(self):
-        raise NotImplementedError
-    def valuation(self):
-        raise NotImplementedError
+        r"""
+        Return the smallest non-negative integer in $I \cap \mathbb{Z}$,
+        where $I$ is this ideal.  If $I = 0$, returns $0$.
+        
+        EXAMPLES:
+            sage: K.<a, b> = NumberFieldTower([x^2 - 23, x^2 + 1])
+            sage: I = K.ideal([a + b])
+            sage: I.smallest_integer()
+            12
+            sage: [m for m in range(13) if m in I]
+            [0, 12]
+        """
+        return self.absolute_ideal().smallest_integer()
+
+    def valuation(self, p):
+        r"""
+        Return the valuation of this fractional ideal at the prime
+        $\mathfrak{p}$.  If $\mathfrak{p}$ is not prime, raise a
+        ValueError.
+
+        INPUT:
+            p -- a prime ideal of this relative number field.
+
+        OUTPUT:
+            integer
+
+        EXAMPLES:
+            sage: K.<a, b> = NumberField([x^2 - 17, x^3 - 2])
+            sage: A = K.ideal(a + b)
+            sage: A.is_prime()
+            True
+            sage: (A*K.ideal(3)).valuation(A)
+            1
+            sage: K.ideal(25).valuation(5)
+            Traceback (most recent call last):
+            ...
+            ValueError: p (= Fractional ideal (5)) must be a prime
+         """
+        if p == 0:
+            raise ValueError, "p (= %s) must be nonzero"%p
+        if not isinstance(p, NumberFieldFractionalIdeal):
+            p = self.number_field().ideal(p)
+        if not p.is_prime():
+            raise ValueError, "p (= %s) must be a prime"%p
+        if p.ring() != self.number_field():
+            raise ValueError, "p (= %s) must be an ideal in %s"%self.number_field()
+        return self.absolute_ideal().valuation(p.absolute_ideal())
 
 def is_NumberFieldFractionalIdeal_rel(x):
     """
@@ -356 +689 @@
         Fractional ideal (b)
         sage: is_NumberFieldFractionalIdeal_rel(I)
         True
-        sage: N = I.norm(); N
+        sage: N = I.relative_norm(); N
         Fractional ideal (-a)
         sage: is_NumberFieldFractionalIdeal_rel(N)
         False

sage/rings/number_field/number_field_rel.py

@@ -119 +119 @@
 import sage.rings.integer as integer
 import sage.rings.polynomial.polynomial_ring as polynomial_ring
 import sage.rings.polynomial.polynomial_element as polynomial_element
+from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
 import sage.rings.ideal as ideal
 import sage.rings.complex_field
 import sage.groups.abelian_gps.abelian_group
@@ -329 +330 @@
             Number Field in n with defining polynomial x^2 + x + 1 over its base field
             sage: L.base_field().base_field()
             Number Field in r with defining polynomial x^3 - 2
+
+        And a more complicated example:
+            sage: PQ.<X> = QQ[]
+            sage: F.<a, b> = NumberField([X^2 - 2, X^2 - 3])
+            sage: PF.<Y> = F[]
+            sage: K.<c> = F.extension(Y^2 - (1 + a)*(a + b)*a*b)
+            sage: L.<m, n, r> = K.change_names(); L
+            Number Field in m with defining polynomial x^2 + (-2*r - 3)*n - 2*r - 6 over its base field
+            sage: L.structure()
+            (Isomorphism given by variable name change map:
+              From: Number Field in m with defining polynomial x^2 + (-2*r - 3)*n - 2*r - 6 over its base field
+              To:   Number Field in c with defining polynomial Y^2 + (-2*b - 3)*a - 2*b - 6 over its base field,
+             Isomorphism given by variable name change map:
+              From: Number Field in c with defining polynomial Y^2 + (-2*b - 3)*a - 2*b - 6 over its base field
+              To:   Number Field in m with defining polynomial x^2 + (-2*r - 3)*n - 2*r - 6 over its base field)
         """
         if len(names) == 0:
             names = self.variable_names()
         elif isinstance(names, str):
             names = names.split(',')
         K = self.base_field().change_names(tuple(names[1:]))
-        L = K.extension(self.defining_polynomial(), names=names[0])
+        to_K = K.structure()[1]
+        old_poly = self.relative_polynomial()
+        new_poly = PolynomialRing(K, 'x')([to_K(c) for c in old_poly])
+        L = K.extension(new_poly, names=names[0])
+        L._set_structure(maps.NameChangeMap(L, self), maps.NameChangeMap(self, L))
         return L
 
     def is_absolute(self):
@@ -407 +427 @@
 
     def absolute_degree(self):
         """
+        The degree of this relative number field over the rational field.
+
         EXAMPLES:
-            sage: K.<a> = NumberField([x^2 + 3, x^2 + 2])
+            sage: K.<a> = NumberFieldTower([x^2 - 17, x^3 - 2])
             sage: K.absolute_degree()
-            4
-            sage: K.degree()
+            6
+        """
+        return self.absolute_polynomial().degree()
+
+    def relative_degree(self):
+        """
+
+        EXAMPLES:
+            sage: K.<a> = NumberFieldTower([x^2 - 17, x^3 - 2])
+            sage: K.relative_degree()
             2
         """
-        return self.absolute_polynomial().degree()
+        return self.relative_polynomial().degree()
+
+    def degree(self):
+        """
+        The degree, unqualified, of a relative number field is deliberately
+        not implemented, so that a user cannot mistake the absolute degree
+        for the relative degree, or vice versa.
+        """
+        raise NotImplementedError, "For a relative number field you must use relative_degree or absolute_degree as appropriate"
 
     def maximal_order(self):
         """
@@ -458 +496 @@
             sage: print L == K
             True        
         """
-        return NumberField_relative_v1, (self.__base_field, self.polynomial(), self.variable_name(),
+        return NumberField_relative_v1, (self.__base_field, self.relative_polynomial(), self.variable_name(),
                                           self.latex_variable_name(), self.gen_embedding())
 
     def _repr_(self):
@@ -476 +514 @@
             Number Field in b with defining polynomial x^7 + 3
         """
         
-        return "Number Field in %s with defining polynomial %s over its base field"%(self.variable_name(), self.polynomial())
+        return "Number Field in %s with defining polynomial %s over its base field"%(self.variable_name(), self.relative_polynomial())
         
         #return "Extension by %s of the Number Field in %s with defining polynomial %s"%(
         #self.polynomial(), self.base_field().variable_name(),
@@ -504 +542 @@
         r"""
         Return a \LaTeX representation of the extension.
 
-        EXAMPLE:
+        EXAMPLES:
             sage: x = QQ['x'].0
             sage: K.<a> = NumberField(x^3 - 2)
             sage: t = K['x'].gen()
@@ -512 +550 @@
             '( \\mathbf{Q}[a]/(a^{3} - 2) )[b]/(b^{2} + b + a)'
         """
         return "( %s )[%s]/(%s)"%(latex(self.base_field()), self.latex_variable_name(),
-                              self.polynomial()._latex_(self.latex_variable_name()))
+                              self.relative_polynomial()._latex_(self.latex_variable_name()))
 
     def _coerce_from_other_number_field(self, x):
         """
@@ -938 +976 @@
         """
         return self.absolute_field('a').is_galois()
 
-    def vector_space(self):
+    def relative_vector_space(self):
         """
         Return vector space over the base field of self and isomorphisms
         from the vector space to self and in the other direction.
@@ -946 +984 @@
         EXAMPLES:
             sage: K.<a,b,c> = NumberField([x^2 + 2, x^3 + 2, x^3 + 3]); K
             Number Field in a with defining polynomial x^2 + 2 over its base field
-            sage: V, from_V, to_V = K.vector_space()
+            sage: V, from_V, to_V = K.relative_vector_space()
             sage: from_V(V.0)
             1
             sage: to_V(K.0)
@@ -959 +997 @@
             (0, 1)
 
         The underlying vector space and maps is cached:
-            sage: W, from_V, to_V = K.vector_space()
+            sage: W, from_V, to_V = K.relative_vector_space()
             sage: V is W
             True
         """
         try:
-            return self.__vector_space
+            return self.__relative_vector_space
         except AttributeError:
             pass
-        V = self.base_field()**self.degree()
+        V = self.base_field()**self.relative_degree()
         from_V = maps.MapRelativeVectorSpaceToRelativeNumberField(V, self)
         to_V   = maps.MapRelativeNumberFieldToRelativeVectorSpace(self, V)
-        self.__vector_space = (V, from_V, to_V)
-        return self.__vector_space
+        self.__relative_vector_space = (V, from_V, to_V)
+        return self.__relative_vector_space
 
     def absolute_vector_space(self):
         """
@@ -1009 +1047 @@
         ans = (V, fr, to)
         self.__absolute_vector_space = ans
         return ans
+
+    def vector_space(self):
+        """
+        For a relative number field \code{L}, \code{L.vector_space()} is deliberately
+        not implemented, so that a user cannot confuse \code{L.relative_vector_space()} 
+        with \code{L.absolute_vector_space()}.
+        """
+        raise NotImplementedError, "For a relative number field L you must use either L.relative_vector_space() or L.absolute_vector_space() as appropriate"
         
     def absolute_base_field(self):
         """
@@ -1089 +1135 @@
             sage: k.<a, c> = NumberField([x^2 + 3, x^2 + 1])
             sage: k.pari_polynomial()
             x^4 + 8*x^2 + 4
-            sage: k.defining_polynomial ()
+            sage: k.relative_polynomial ()
             x^2 + 3
         """
         try:
@@ -1165 +1211 @@
         """
         abs_base, _, _ = self.absolute_base_field()
         g = QQ['y'](abs_base.polynomial())
-        vals = [ QQ['y'](f.polynomial())._pari_().Mod(g) for f in self.polynomial().list() ]
+        vals = [ QQ['y'](f.polynomial())._pari_().Mod(g) for f in self.relative_polynomial().list() ]
         f = pari(vals).Polrev()
         return f
 
@@ -1215 +1261 @@
             self.__abs_gen = self._element_class(self, QQ['x'].gen())
             return self.__abs_gen
         
-
     def absolute_field(self, names):
         r"""
         Return an absolute number field K that is isomorphic to this
@@ -1307 +1352 @@
         """
         return QQ['x'](self._pari_rnfequation()[0])
 
+    def relative_polynomial(self):
+        """
+        Return the defining polynomial of this relative number field over its base field.
+
+        EXAMPLES:
+            sage: K.<a> = NumberFieldTower([x^2 + x + 1, x^3 + x + 1])
+            sage: K.relative_polynomial()
+            x^2 + x + 1
+
+            Use absolute polynomial for a polynomial that defines the
+            absolute extension.
+
+            sage: K.absolute_polynomial()
+            x^6 + 3*x^5 + 8*x^4 + 9*x^3 + 7*x^2 + 6*x + 3
+        """
+        return self.__relative_polynomial
+
+    def defining_polynomial(self):  
+        """
+        Return the defining polynomial of this relative number field.
+
+        This is exactly the same as \code{self.relative_polynomal()}.
+
+        EXAMPLES:
+            sage: C.<z> = CyclotomicField(5)
+            sage: PC.<X> = C[]
+            sage: K.<a> = C.extension(X^2 + X + z); K
+            Number Field in a with defining polynomial X^2 + X + z over its base field
+            sage: K.defining_polynomial()
+            X^2 + X + z
+        """
+        return self.relative_polynomial()
+
+    def polynomial(self):
+        """
+        For a relative number field \code{L}, \code{L.polynomial()} is deliberately
+        not implemented.  Either \code{L.relative_polynomial()} 
+        or \code{L.absolute_polynomial()} must be used.
+        """
+        raise NotImplementedError, "For a relative number field L you must use either L.relative_polynomial() or L.absolute_polynomial() as appropriate"
+
     def base_field(self):
         """
         Return the base field of this relative number field.
@@ -1393 +1479 @@
         self.__embeddings[K] = Sequence(v, cr=v!=[], immutable=True, check=False, universe=self.Hom(K))
         return self.__embeddings[K]
 
+    def absolute_different(self):
+        r"""
+        Return the absolute different of this relative number field as
+        an ideal of $L$.  To get the relative different of $L/K$, 
+        use \code{L.relative_different()}.
+
+        EXAMPLES:
+            sage: K.<i> = NumberField(x^2 + 1)
+            sage: t = K['t'].gen()
+            sage: L.<b> = K.extension(t^4 - i)
+            sage: L.absolute_different()
+            Fractional ideal (8)
+        """
+        abs = self.absolute_field('a')
+        from_abs = abs.structure()[0]
+        return self.ideal([from_abs(g) for g in abs.different().gens()])
+
+    def relative_different(self):
+        r"""
+        Return the relative different of this extension $L/K$ as
+        an ideal of $L$.  If you want the absolute different of
+        $L/Q$, use \code{L.different()}.
+
+        EXAMPLES:
+            sage: K.<i> = NumberField(x^2 + 1)
+            sage: PK.<t> = K[]
+            sage: L.<a> = K.extension(t^4  - i)
+            sage: L.relative_different()
+            Fractional ideal (4)
+        """
+        I = self.absolute_different()
+        J = self.ideal(self.base_field().absolute_different().gens())
+        return  I/J
+
+    def different(self):
+        """
+        The different, unqualified, of a relative number field is deliberately
+        not implemented, so that a user cannot mistake the absolute different
+        for the relative different, or vice versa.
+        """
+        raise NotImplementedError, "For a relative number field you must use relative_different or absolute_different as appropriate"
+
+    def absolute_discriminant(self, v=None):
+        r"""
+        Return the absolute discriminant of this relative number field
+        or if v is specified, the determinant of the trace pairing
+        on the elements of the list v.  
+
+        INPUT:
+            v (optional) -- list of element of this relative number field.
+        OUTPUT:
+            Integer if v is omitted, and Rational otherwise.
+
+        EXAMPLES:
+            sage: K.<i> = NumberField(x^2 + 1)
+            sage: t = K['t'].gen()
+            sage: L.<b> = K.extension(t^4 - i)
+            sage: L.absolute_discriminant()
+            16777216
+            sage: L.absolute_discriminant([(b + i)^j for j in range(8)])
+            61911970349056
+        """
+        abs = self.absolute_field('a')
+        if v != None:
+            to_abs = abs.structure()[1]
+            v = [to_abs(x) for x in v]
+        return abs.discriminant(v=v)
+
     def relative_discriminant(self, proof=None):
         r"""
         Return the relative discriminant of this extension $L/K$ as
@@ -1408 +1562 @@
         INPUT:
             proof -- (default: False)
 
-        EXAMPLE:
+        EXAMPLES:
             sage: K.<i> = NumberField(x^2 + 1)
             sage: t = K['t'].gen()
             sage: L.<b> = K.extension(t^4 - i)
             sage: L.relative_discriminant()
             Fractional ideal (256)
-            sage: factor(L.discriminant())
-            2^24
-            sage: factor( L.relative_discriminant().norm() )
-            2^16
-        """
+         """
         proof = proof_flag(proof)
         
         bnf = self._pari_base_bnf(proof)
@@ -1427 +1577 @@
         D, d = bnf.rnfdisc(self.pari_relative_polynomial())
         return K.ideal([ K(R(x)) for x in convert_from_zk_basis(K, D) ])
 
+    def discriminant(self):
+        """
+        The discriminant, unqualified, of a relative number field is deliberately
+        not implemented, so that a user cannot mistake the absolute discriminant
+        for the relative discriminant, or vice versa.
+        """
+        raise NotImplementedError, "For a relative number field you must use relative_discriminant or absolute_discriminant as appropriate"
+
+    def disc(self):
+        """
+        The discriminant, unqualified, of a relative number field is deliberately
+        not implemented, so that a user cannot mistake the absolute discriminant
+        for the relative discriminant, or vice versa.
+        """
+        raise NotImplementedError, "For a relative number field you must use relative_discriminant or absolute_discriminant as appropriate"
+
     def order(self, *gens, **kwds):
         """
         Return the order with given ring generators in the maximal
@@ -1472 +1638 @@
         gens = [self(x) for x in gens]
         return order.relative_order_from_ring_generators(gens, **kwds)
         
-
     def galois_group(self, pari_group = True, algorithm='pari'):
         r"""
         Return the Galois group of the Galois closure of this number
@@ -1490 +1655 @@
         typing \code{K.polynomial().galois_group?}, where $K$
         is a number field.
 
-        EXAMPLE:
+        EXAMPLES:
             sage: x = QQ['x'].0
             sage: K.<a> = NumberField(x^2 + 1)
             sage: R.<t> = PolynomialRing(K)
@@ -1511 +1676 @@
         self.__galois_group[pari_group, algorithm] = H
         return H
     
-
     def is_free(self, proof=None):
         r"""
         Determine whether or not $L/K$ is free (i.e. if $\mathcal{O}_L$ is
@@ -1561 +1725 @@
         f = QQ['y'](str_poly)
         return self.base_field()(f.list())
 
-    def polynomial(self):
-        """
-        Return the defining polynomial of this number field.
-
-        EXAMPLES:
-            sage: y = polygen(QQ,'y')
-            sage: k.<a> = NumberField([y^2 + y + 1, x^3 + x + 1])
-            sage: k.polynomial()
-            y^2 + y + 1
-
-        This is the same as defining_polynomial:
-            sage: k.defining_polynomial()
-            y^2 + y + 1
-
-        Use absolute polynomial for a polynomial that defines the
-        absolute extension.
-            sage: k.absolute_polynomial()
-            x^6 + 3*x^5 + 8*x^4 + 9*x^3 + 7*x^2 + 6*x + 3
-        """
-        return self.__relative_polynomial
-
     def relativize(self, alpha, names):
         r"""
         Given an element in self or an embedding of a subfield into self,

sage/rings/number_field/order.py

@@ -255 +255 @@
 
         """
         if self._is_maximal is None:
-            self._is_maximal = (self.absolute_discriminant() == self._K.discriminant())
+            self._is_maximal = (self.absolute_discriminant() == self._K.absolute_discriminant())
         return self._is_maximal
 
     def is_field(self):
@@ -1188 +1188 @@
     def __call__(self, x):
         """
         Coerce an element into this relative order.
+
+        EXAMPLES::
+
+            sage: K.<a, b> = NumberField([x^2 + 2, x^2 + 1000*x + 1])
+            sage: OK = K.ring_of_integers()
+            sage: OK(a)
+            a
+            sage: OK([3, 4])
+            4*a + 3
+
+        The following used to fail; see trac #5276::
+
+            sage: S.<y> = OK[]; S
+            Univariate Polynomial Ring in y over Relative Order in Number Field in a with defining polynomial x^2 + 2 over its base field
+
         """
-        if x.parent() is not self._K:
-            x = self._K(x)
-        x = self._absolute_order(x) # will test membership
+
+        x = self._K(x)
+        abs_order = self._absolute_order
+        to_abs = abs_order._K.structure()[1]
+        x = abs_order(to_abs(x)) # will test membership
         return OrderElement_relative(self, x)
 
     def _repr_(self):

sage/rings/number_field/small_primes_of_degree_one.py

@@ -48 +48 @@
     sage: all(P.residue_class_degree() == 1 for P in Ps)
     True
 
-    In the next two examples, relative residue class degrees are not yet
-    implemented, but we can check that the absolute norms are in fact prime.
+    The next two examples are for relative number fields.
 
     sage: L.<b> = F.extension(x^3 - a, 'b')
     sage: Ps = L.primes_of_degree_one_list(3)
     sage: Ps # random
     [Fractional ideal (17, b - 5), Fractional ideal (23, b - 4), Fractional ideal (31, b - 2)]
-    sage: [ P.norm().norm() for P in Ps ] # random
+    sage: [ P.absolute_norm() for P in Ps ] # random
     [17, 23, 31]
-    sage: all(ZZ(P.norm().norm()).is_prime() for P in Ps)
+    sage: all(ZZ(P.absolute_norm()).is_prime() for P in Ps)
     True
     sage: all(P.residue_class_degree() == 1 for P in Ps)
-    Traceback (most recent call last):
-    ...
-    NotImplementedError...
-
+    True
     sage: M.<c> = NumberField(x^2 - x*b^2 + b, 'c')
     sage: Ps = M.primes_of_degree_one_list(3)
     sage: Ps # random
     [Fractional ideal (17, c - 2), Fractional ideal (c - 1), Fractional ideal (41, c + 15)]
-    sage: [ P.norm().norm().norm() for P in Ps ] # random
+    sage: [ P.absolute_norm() for P in Ps ] # random
     [17, 31, 41]
-    sage: all(ZZ(P.norm().norm().norm()).is_prime() for P in Ps)
+    sage: all(ZZ(P.absolute_norm()).is_prime() for P in Ps)
     True
     sage: all(P.residue_class_degree() == 1 for P in Ps)
-    Traceback (most recent call last):
-    ...
-    NotImplementedError...
+    True
 
 AUTHOR:
     -- Nick Alexander

sage/rings/number_field/totallyreal_rel.py

@@ -750 +750 @@
             K = F.extension(Fx([-1,1,1]), 'tK')
             Kabs = K.absolute_field('tKabs')
             Kabs_pari = pari(Kabs.defining_polynomial())
-            d = K.disc()
+            d = K.absolute_discriminant()
             if abs(d) <= B:
                 ng = Kabs_pari.polredabs()
                 ind = bisect.bisect_left(S, [d,ng])
@@ -762 +762 @@
                 K = F.extension(f, 'tK')
                 Kabs = K.absolute_field('tKabs')
                 Kabs_pari = pari(Kabs.defining_polynomial())
-                d = K.disc()
+                d = K.absolute_discriminant()
                 if abs(d) <= B:
                     ng = Kabs_pari.polredabs()
                     ind = bisect.bisect_left(S, [d,ng])