Ticket #2329: trac_2329_rnfisnorm5.2.patch

File trac_2329_rnfisnorm5.2.patch, 23.3 KB (added by jdemeyer, 11 years ago)

Apply only this, rebased to sage-4.6.2.alpha1 + #10677

  • sage/rings/integer.pyx

    # HG changeset patch
    # User Francis Clarke <F.Clarke@Swansea.ac.uk>
    # Date 1293411223 0
    # Node ID 29c8665017219254eec9e610d091db50206167bf
    # Parent  4a1a15a2a55b613f85e0817c76f554be58613125
    Trac: 2329: add interface to rnfisnorm
    
    diff -r 4a1a15a2a55b -r 29c866501721 sage/rings/integer.pyx
    a b  
    389389    specifying an alternative parent to ``IntegerRing()``.
    390390    """
    391391
    392     def __init__(self, x=None, unsigned int base=0, parent = None):
     392    def __init__(self, x=None, unsigned int base=0, parent=None):
    393393        """
    394394        We illustrate how to create integers with parents different
    395395        from ``IntegerRing()``::
    396396
    397397            sage: from sage.rings.integer import IntegerWrapper
    398398
    399             sage: n = IntegerWrapper(3, parent = Primes()) # indirect doctest
     399            sage: n = IntegerWrapper(3, parent=Primes()) # indirect doctest
    400400            sage: n
    401401            3
    402402            sage: n.parent()
     
    413413            sage: TestSuite(n).run()
    414414        """
    415415        if parent is not None:
    416             Element.__init__(self, parent = parent)
    417         Integer.__init__(self, x, base = base)
     416            Element.__init__(self, parent=parent)
     417        Integer.__init__(self, x, base=base)
    418418
    419419cdef class Integer(sage.structure.element.EuclideanDomainElement):
    420420    r"""
     
    43424342            else:
    43434343                return False
    43444344        return mpz_perfect_power_p(self.value)
    4345        
     4345
     4346    def is_norm(self, K, element=False, proof=True):
     4347        r"""
     4348        See ``QQ(self).is_norm()``.
     4349       
     4350        EXAMPLES::
     4351
     4352            sage: K = NumberField(x**2 - 2, 'beta')
     4353            sage: n = 4
     4354            sage: n.is_norm(K)
     4355            True
     4356            sage: 5.is_norm(K)
     4357            False
     4358            sage: 7.is_norm(QQ)
     4359            True
     4360            sage: n.is_norm(K, element=True)
     4361            (True, 4*beta + 6)
     4362            sage: n.is_norm(K, element=True)[1].norm()
     4363            4
     4364            sage: n = 5
     4365            sage: n.is_norm(K, element=True)
     4366            (False, None)
     4367            sage: n = 7
     4368            sage: n.is_norm(QQ, element=True)
     4369            (True, 7)
     4370
     4371        """
     4372        from sage.rings.rational_field import QQ
     4373        return QQ(self).is_norm(K, element=element, proof=proof)
     4374
     4375    def bnfisnorm(self, K, certify=True, extra_primes=0):
     4376        r"""
     4377        See ``QQ(self).bnfisnorm()``.
     4378       
     4379        EXAMPLES::
     4380       
     4381            sage: 3.bnfisnorm(QuadraticField(-1, 'i'))
     4382            (1, 3)
     4383            sage: 7.bnfisnorm(CyclotomicField(7))
     4384            (-zeta7^2 + zeta7, 1)
     4385        """
     4386        from sage.rings.rational_field import QQ
     4387        return QQ(self).bnfisnorm(K, certify=certify, extra_primes=extra_primes)
     4388
     4389     
    43464390    def jacobi(self, b):
    43474391        r"""
    43484392        Calculate the Jacobi symbol `\left(\frac{self}{b}\right)`.
  • sage/rings/number_field/number_field.py

    diff -r 4a1a15a2a55b -r 29c866501721 sage/rings/number_field/number_field.py
    a b  
    10011001        else:
    10021002            assert category.is_subcategory(default_category), "%s is not a subcategory of %s"%(category, default_category)
    10031003
    1004         ParentWithGens.__init__(self, QQ, name, category = category)
     1004        ParentWithGens.__init__(self, QQ, name, category=category)
    10051005        if not isinstance(polynomial, polynomial_element.Polynomial):
    10061006            raise TypeError, "polynomial (=%s) must be a polynomial"%repr(polynomial)
    10071007       
     
    25872587            self.__pari_bnf_certified = True
    25882588        return self.__pari_bnf_certified
    25892589
     2590    def pari_rnfnorm_data(self, L):
     2591        """
     2592        Return the pari rnfisnorminit data corresponding to the
     2593        extension L/self.
     2594
     2595        EXAMPLES::
     2596       
     2597            sage: K = NumberField(x**2-2,'alpha')
     2598            sage: L = K.extension(x**2+5, 'gamma')
     2599            sage: ls = K.pari_rnfnorm_data(L) ; len(ls)
     2600            8
     2601
     2602            sage: K.<a> = NumberField(x^2 + x + 1)
     2603            sage: P.<X> = K[]
     2604            sage: L.<b> = NumberField(X^3 + a)
     2605            sage: ls = K.pari_rnfnorm_data(L); len(ls)
     2606            8
     2607        """
     2608        if L.base_field() != self:
     2609            raise ValueError, "L must be an extension of self"
     2610       
     2611        relpoly = L.defining_polynomial()
     2612        Kbnf = self.absolute_polynomial()._pari_with_name('y').bnfinit()
     2613        coeffs = [ a._pari_('y') for a in relpoly.coeffs() ]
     2614
     2615        polrel = sage.libs.pari.gen.pari(coeffs).Polrev()
     2616        return Kbnf.rnfisnorminit(polrel)
     2617
    25902618    def _gap_init_(self):
    25912619        """
    25922620        Create a gap object representing self and return its name
     
    26982726        gens = [self.ideal(hnf) for hnf in k.bnf_get_gen()]
    26992727       
    27002728        G = ClassGroup(cycle_structure, names, self, gens, proof=proof)       
    2701         self.__class_group[proof,names] = G
     2729        self.__class_group[proof, names] = G
    27022730        return G
    27032731
    27042732    def class_number(self, proof=None):
     
    29202948            sage: K.selmer_group([K.ideal(2, -a+1), K.ideal(3, a+1)], 3)
    29212949            [2, a + 1]
    29222950            sage: K.selmer_group([K.ideal(2, -a+1), K.ideal(3, a+1), K.ideal(a)], 3)
    2923             [2, a + 1, a]    # 32-bit
    2924             [2, a + 1, -a]   # 64-bit
     2951            [2, a + 1, a]
    29252952            sage: K.<a> = NumberField(polygen(QQ))
    29262953            sage: K.selmer_group([],5)
    29272954            []
     
    35283555            self.__gen = self._element_class(self, X)
    35293556            return self.__gen
    35303557
    3531     def is_field(self, proof = True):
     3558    def is_field(self, proof=True):
    35323559        """
    35333560        Return True since a number field is a field.
    35343561       
     
    36543681            return GaloisGroup_v2(self, names)
    36553682       
    36563683        elif type=="pari":
    3657             return GaloisGroup_v1(self.absolute_polynomial().galois_group(pari_group = True, algorithm = algorithm), self)
     3684            return GaloisGroup_v1(self.absolute_polynomial().galois_group(pari_group=True, algorithm=algorithm), self)
    36583685        elif type=="gap":
    3659             return GaloisGroup_v1(self.absolute_polynomial().galois_group(pari_group = False, algorithm = algorithm), self)
     3686            return GaloisGroup_v1(self.absolute_polynomial().galois_group(pari_group=False, algorithm=algorithm), self)
    36603687        else:
    36613688            raise ValueError, "Galois group type must be None, 'pari', or 'gap'."
    36623689       
     
    40984125                       prec = prec)
    40994126        s = 'nf = nfinit(%s);'%self.absolute_polynomial()
    41004127        s += 'dzk = dirzetak(nf,cflength());'
    4101         Z.init_coeffs('dzk[k]',pari_precode = s,
     4128        Z.init_coeffs('dzk[k]', pari_precode=s,
    41024129                      max_imaginary_part=max_imaginary_part,
    41034130                      max_asymp_coeffs=max_asymp_coeffs)         
    41044131        Z.check_functional_equation()
     
    42964323            self.__regulator = RealField(53)(k.bnf_get_reg())
    42974324            return self.__regulator
    42984325
    4299     def residue_field(self, prime, names = None, check = True):
     4326    def residue_field(self, prime, names=None, check=True):
    43004327        """
    43014328        Return the residue field of this number field at a given prime, ie
    43024329        `O_K / p O_K`.
     
    43624389        if check and not prime.is_prime():
    43634390            raise ValueError, "%s is not a prime ideal"%prime
    43644391        from sage.rings.residue_field import ResidueField
    4365         return ResidueField(prime, names = names, check = False)
     4392        return ResidueField(prime, names=names, check=False)
    43664393
    43674394    def signature(self):
    43684395        """
     
    44004427                A[j,i] = t
    44014428        return A
    44024429
    4403     def uniformizer(self, P, others = "positive"):
     4430    def uniformizer(self, P, others="positive"):
    44044431        """
    44054432        Returns an element of self with valuation 1 at the prime ideal P.
    44064433       
     
    53675394        except KeyError:
    53685395            pass
    53695396
    5370         B = map(self, self._pari_integral_basis(v = v))
     5397        B = map(self, self._pari_integral_basis(v=v))
    53715398
    53725399        if len(v) == 0 or v is None:
    53735400            is_maximal = True
     
    53775404        import sage.rings.number_field.order as order
    53785405        O = order.absolute_order_from_module_generators(B,
    53795406                 check_integral=False, check_rank=False,
    5380                  check_is_ring=False, is_maximal = is_maximal)
     5407                 check_is_ring=False, is_maximal=is_maximal)
    53815408       
    53825409        self.__maximal_order[v] = O
    53835410        return O
     
    56785705        embs.sort()
    56795706        v = [ self.hom([ e ], check=False) for e in embs ]
    56805707        put_natural_embedding_first(v)
    5681         self.__embeddings[self] = Sequence(v, cr = (v != []), immutable=True,
     5708        self.__embeddings[self] = Sequence(v, cr=(v != []), immutable=True,
    56825709                                        check=False, universe=self.Hom(self))
    56835710        return self.__embeddings[self]
    56845711
  • sage/rings/number_field/number_field_element.pyx

    diff -r 4a1a15a2a55b -r 29c866501721 sage/rings/number_field/number_field_element.pyx
    a b  
    929929        """
    930930        return self.number_field().complex_embeddings(prec)[i](self)
    931931
     932
     933    def is_norm(self, L, element=False, proof=True):
     934        r"""
     935        Determine whether self is the relative norm of an element
     936        of L/K, where K is self.parent().
     937       
     938        INPUT:
     939       
     940         - L -- a number field containing K=self.parent()
     941         - element -- True or False, whether to also output an element
     942           of which self is a norm
     943         - proof -- If True, then the output is correct unconditionally.
     944           If False, then the output is correct under GRH.
     945       
     946        OUTPUT:
     947       
     948        If element is False, then the output is a boolean B, which is
     949        True if and only if self is the relative norm of an element of L
     950        to K.
     951        If element is False, then the output is a pair (B, x), where
     952        B is as above. If B is True, then x is an element of L such that
     953        self == x.norm(K). Otherwise, x is None.
     954       
     955        ALGORITHM:
     956       
     957        Uses Pari's rnfisnorm. See self.rnfisnorm().
     958
     959        EXAMPLES::
     960
     961            sage: K.<beta> = NumberField(x^3+5)
     962            sage: Q.<X> = K[]
     963            sage: L = K.extension(X^2+X+beta, 'gamma')
     964            sage: (beta/2).is_norm(L)
     965            False
     966            sage: beta.is_norm(L)
     967            True
     968
     969        With a relative base field::
     970
     971            sage: K.<a, b> = NumberField([x^2 - 2, x^2 - 3])
     972            sage: L.<c> = K.extension(x^2 - 5)
     973            sage: (2*a*b).is_norm(L)
     974            True
     975            sage: _, v = (2*b*a).is_norm(L, element=True)
     976            sage: v.norm(K) == 2*a*b
     977            True
     978
     979        Non-Galois number fields::
     980           
     981            sage: K.<a> = NumberField(x^2 + x + 1)
     982            sage: Q.<X> = K[]
     983            sage: L.<b> = NumberField(X^4 + a + 2)
     984            sage: (a/4).is_norm(L)
     985            True
     986            sage: (a/2).is_norm(L)
     987            Traceback (most recent call last):
     988            ...
     989            NotImplementedError: is_norm is not implemented unconditionally for norms from non-Galois number fields
     990            sage: (a/2).is_norm(L, proof=False)
     991            False
     992
     993            sage: K.<a> = NumberField(x^3 + x + 1)
     994            sage: Q.<X> = K[]
     995            sage: L.<b> = NumberField(X^4 + a)
     996            sage: t = (-a).is_norm(L, element=True); t
     997            (True, b^3 + 1)
     998            sage: t[1].norm(K)
     999            -a
     1000
     1001        AUTHORS:
     1002
     1003        - Craig Citro (2008-04-05)
     1004
     1005        - Marco Streng (2010-12-03)
     1006        """
     1007        if not element:
     1008            return self.is_norm(L, element=True, proof=proof)[0]
     1009
     1010        K = self.parent()
     1011        from sage.rings.number_field.all import is_AbsoluteNumberField, \
     1012                                                is_NumberField
     1013        if not is_NumberField(L):
     1014            raise ValueError, "L (=%s) must be a NumberField in is_norm" % L
     1015       
     1016        if is_AbsoluteNumberField(L):
     1017            Lrel = L.relativize(K.hom(L), ('a', 'b'))
     1018            b, x = self.is_norm(Lrel, element=True, proof=proof)
     1019            h = Lrel.structure()[0]
     1020            return b, h(x)
     1021
     1022        if L.relative_degree() == 1 or self.is_zero():
     1023            return True, L(self)
     1024
     1025        a, b = self.rnfisnorm(L, certify=proof)
     1026        if b == 1:
     1027            assert a.norm(K) == self
     1028            return True, a
     1029
     1030        if L.is_galois_relative():
     1031            return False, None
     1032
     1033        # The following gives the galois closure of K/QQ, but the galois
     1034        # closure of K/self.parent() would suffice.
     1035        M = L.galois_closure('a')
     1036        from sage.functions.log import log
     1037        from sage.functions.other import floor
     1038        extra_primes = floor(12*log(abs(M.discriminant()))**2)
     1039        a, b = self.rnfisnorm(L, certify=proof, extra_primes=extra_primes)
     1040        if b == 1:
     1041            assert a.norm(K) == self
     1042            return True, a
     1043
     1044        if proof:
     1045            raise NotImplementedError, "is_norm is not implemented unconditionally for norms from non-Galois number fields"
     1046        return False, None
     1047
     1048    def rnfisnorm(self, L, certify=True, extra_primes=0):
     1049        r"""
     1050        Gives the output of the Pari function rnfisnorm.
     1051       
     1052        This tries to decide whether the number field element self is
     1053        the norm of some x in the extension L/K (with K = self.parent()).
     1054
     1055        The output is a pair (x, q), where self = Norm(x)*q. The
     1056        algorithm looks for a solution x that is an S-integer, with S
     1057        a list of places of L containing at least the ramified primes,
     1058        the generators of the class group of L, as well as those primes
     1059        dividing self.
     1060       
     1061        If L/K is Galois, then this is enough; otherwise,
     1062        extra_primes is used to add more primes to S: all the places
     1063        above the primes p <= extra_primes (resp. p|extra_primes) if
     1064        extra_primes > 0 (resp. extra_primes < 0).
     1065
     1066        The answer is guaranteed (i.e., self is a norm iff q = 1) if the
     1067        field is Galois, or, under GRH, if S contains all primes less
     1068        than 12log^2|\disc(M)|, where M is the normal closure of L/K.
     1069
     1070        INPUT:
     1071       
     1072         - L -- a relative number field with base field self.parent()
     1073         - certify -- whether to certify outputs of Pari init functions.
     1074           If false, truth of the output depends on GRH.
     1075         - extra_primes -- an integer as explained above.
     1076
     1077        OUTPUT:
     1078       
     1079        A pair (x, q) with x in L and q in K as explained above
     1080        such that self == x.norm(K)*q.
     1081       
     1082        ALGORITHM:
     1083       
     1084        Uses Pari's rnfisnorm.
     1085       
     1086        EXAMPLES::
     1087       
     1088            sage: K.<a> = NumberField(x^3 + x^2 - 2*x - 1, 'a')
     1089            sage: P.<X> = K[]
     1090            sage: L = NumberField(X^2 + a^2 + 2*a + 1, 'b')
     1091            sage: K(17).rnfisnorm(L)
     1092            ((a^2 - 2)*b - 4, 1)
     1093           
     1094            sage: K.<a> = NumberField(x^3 + x + 1)
     1095            sage: Q.<X> = K[]
     1096            sage: L.<b> = NumberField(X^4 + a)
     1097            sage: t = (-a).rnfisnorm(L); t
     1098            (b^3 + 1, 1)
     1099            sage: t[0].norm(K)
     1100            -a
     1101            sage: t = K(3).rnfisnorm(L); t
     1102            ((-a^2 - 1)*b^3 + b^2 + a*b + a^2 + 1, -3*a)
     1103            sage: t[0].norm(K)*t[1]
     1104            3
     1105
     1106        An example where the base field is a relative field::
     1107
     1108            sage: K.<a, b> = NumberField([x^2 - 2, x^2 - 3])
     1109            sage: L.<c> = K.extension(x^3 + 2)
     1110            sage: t = (2*a + b).rnfisnorm(L); t[1]
     1111            (b - 2)*a + 2*b - 3
     1112            sage: t[0].norm(K)*t[1]
     1113            2*a + b
     1114
     1115        AUTHORS:
     1116
     1117        - Craig Citro (2008-04-05)
     1118
     1119        - Marco Streng (2010-12-03)
     1120
     1121        - Francis Clarke (2010-12-26)
     1122        """
     1123        K = self.parent()
     1124        from sage.rings.number_field.all import is_RelativeNumberField
     1125        if (not is_RelativeNumberField(L)) or L.base_field() != K:
     1126            raise ValueError, "L (=%s) must be a relative number field with base field K (=%s) in rnfisnorm" % (L, K)
     1127
     1128        if certify:
     1129            K.pari_bnf_certify()
     1130
     1131        rnf_data = K.pari_rnfnorm_data(L)
     1132        x, q = self._pari_('y').rnfisnorm(rnf_data)
     1133
     1134        degL = L.relative_degree()
     1135        repx = [K(x.lift().polcoeff(i).lift()) for i in range(degL)]
     1136        x = L(repx)
     1137
     1138        from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
     1139        degK = K.absolute_degree()
     1140        coeffsq = [q.lift().polcoeff(i)._sage_() for i in range(degK)]
     1141        q = PolynomialRing(QQ, 't')(coeffsq)(K.absolute_generator())
     1142
     1143        return x, q
     1144
    9321145    def _mpfr_(self, R):
    9331146        """
    9341147        EXAMPLES::
  • sage/rings/rational.pyx

    diff -r 4a1a15a2a55b -r 29c866501721 sage/rings/rational.pyx
    a b  
    11741174        """
    11751175        return mpq_sgn(self.value) >= 0 and mpz_perfect_square_p(mpq_numref(self.value)) and mpz_perfect_square_p(mpq_denref(self.value))
    11761176
     1177    def is_norm(self, L, element=False, proof=True):
     1178        r"""
     1179        Determine whether self is the norm of an element of L.
     1180       
     1181        INPUT:
     1182       
     1183         - L -- a number field
     1184         - element -- True or False, whether to also output an element
     1185           of which self is a norm
     1186         - proof -- If True, then the output is correct unconditionally.
     1187           If False, then the output assumes GRH.
     1188       
     1189        OUTPUT:
     1190       
     1191        If element is False, then the output is a boolean B, which is
     1192        True if and only if self is the norm of an element of L.
     1193        If element is False, then the output is a pair (B, x), where
     1194        B is as above. If B is True, then x an element of L such that
     1195        self == x.norm(). Otherwise, x is None.
     1196       
     1197        ALGORITHM:
     1198       
     1199        Uses Pari's bnfisnorm. See self.bnfisnorm().
     1200
     1201        EXAMPLES::
     1202
     1203            sage: K = NumberField(x^2 - 2, 'beta')
     1204            sage: (1/7).is_norm(K)
     1205            True
     1206            sage: (1/10).is_norm(K)
     1207            False
     1208            sage: 0.is_norm(K)
     1209            True
     1210            sage: (1/7).is_norm(K, element=True)
     1211            (True, -3/7*beta + 5/7)
     1212            sage: (1/10).is_norm(K, element=True)
     1213            (False, None)
     1214            sage: (1/691).is_norm(QQ, element=True)
     1215            (True, 1/691)
     1216
     1217        The number field doesn't have to be defined by an
     1218        integral polynomial::
     1219           
     1220            sage: (1/5).is_norm(QuadraticField(5/4, 'a'), element=True)
     1221            (True, -1/5*a + 1/2)
     1222           
     1223        A non-Galois number field::
     1224       
     1225            sage: K.<b> = NumberField(x^3-2)
     1226            sage: x, y = (3/5).is_norm(K, element=True); x
     1227            True
     1228            sage: y.norm()
     1229            3/5
     1230           
     1231            sage: 7.is_norm(K)
     1232            Traceback (most recent call last):
     1233            ...
     1234            NotImplementedError: is_norm is not implemented unconditionally for norms from non-Galois number fields
     1235            sage: 7.is_norm(K, proof=False)
     1236            False
     1237
     1238        AUTHORS:
     1239
     1240        - Craig Citro (2008-04-05)
     1241
     1242        - Marco Streng (2010-12-03)
     1243        """
     1244        if not element:
     1245            return self.is_norm(L, element=True, proof=proof)[0]
     1246
     1247        from sage.rings.number_field.all import is_NumberField
     1248        if not is_NumberField(L):
     1249            raise ValueError, "L (=%s) must be a NumberField in is_norm" % L
     1250        if L.degree() == 1 or self.is_zero():
     1251            return True, L(self)
     1252        d = L.polynomial().denominator()
     1253        if not d == 1:
     1254            M, M_to_L = L.subfield(L.gen()*d)
     1255            b, x = self.is_norm(M, element=True, proof=proof)
     1256            if b:
     1257                x = M_to_L(x)
     1258            return b, x
     1259        a, b = self.bnfisnorm(L, certify=proof)
     1260        if b == 1:
     1261            assert a.norm() == self
     1262            return True, a
     1263        if L.is_galois():
     1264            return False, None
     1265        M = L.galois_closure('a')
     1266        from sage.functions.log import log
     1267        from sage.functions.other import floor
     1268        extra_primes = floor(12*log(abs(M.discriminant()))**2)
     1269        a, b = self.bnfisnorm(L, certify=proof, extra_primes=extra_primes)
     1270        if b == 1:
     1271            assert a.norm() == self
     1272            return True, a
     1273        if proof:
     1274            raise NotImplementedError, "is_norm is not implemented unconditionally for norms from non-Galois number fields"
     1275        return False, None
     1276
     1277    def bnfisnorm(self, K, certify=True, extra_primes=0):
     1278        r"""
     1279        This gives the output of the Pari function bnfisnorm.
     1280       
     1281        Tries to tell whether the rational number self is the norm of some
     1282        element y in K. Returns a pair (a, b) where self = Norm(a)*b. Looks for
     1283        a solution that is an S-unit, with S a certain set of prime ideals
     1284        containing (among others) all primes dividing self.
     1285       
     1286        If K is known to be Galois, set extra_primes = 0 (in this case, self
     1287        is a norm iff b = 1).
     1288       
     1289        If extra_primes is non-zero, the program adds to S the following
     1290        prime ideals, depending on the sign of extra_primes.
     1291        If extra_primes > 0, the ideals of norm less than extra_primes.
     1292        And if extra_primes < 0, the ideals dividing extra_primes.
     1293
     1294        Assuming GRH, the answer is guaranteed (i.e., self is a norm
     1295        iff b = 1), if S contains all primes less than 12log(\disc(L))^2,
     1296        where L is the Galois closure of K.
     1297
     1298        INPUT:
     1299       
     1300         - K -- a number field
     1301         - certify -- whether to certify the output of bnfinit.
     1302           If false, then correctness of the output depends on GRH.
     1303         - extra_primes -- an integer as explained above
     1304
     1305        OUTPUT:
     1306       
     1307        A pair (a, b) with a in K and b in `QQ` such that self == Norm(a)*b
     1308        as explained above.
     1309       
     1310        ALGORITHM:
     1311       
     1312        Uses Pari's bnfisnorm.
     1313       
     1314        EXAMPLES::
     1315       
     1316            sage: QQ(2).bnfisnorm(QuadraticField(-1, 'i'))
     1317            (i + 1, 1)
     1318            sage: 7.bnfisnorm(NumberField(x^3-2, 'b'))
     1319            (1, 7)
     1320       
     1321        AUTHORS:
     1322
     1323        - Craig Citro (2008-04-05)
     1324
     1325        - Marco Streng (2010-12-03)
     1326        """
     1327        from sage.rings.number_field.all import is_NumberField
     1328        if not is_NumberField(K):
     1329            raise ValueError, "K must be a NumberField in bnfisnorm"
     1330        if certify:
     1331            K.pari_bnf_certify()
     1332
     1333        a, b = self._pari_().bnfisnorm(K.pari_bnf(), flag=extra_primes)
     1334        deg = K.degree()
     1335        coeffs = [ a.lift().polcoeff(i)._sage_() for i in range(deg) ]
     1336        from sage.rings.rational_field import QQ
     1337        return K(coeffs), QQ(b._sage_())
     1338
     1339
    11771340    def is_perfect_power(self, expected_value=False):
    11781341        r"""
    11791342        Returns ``True`` if self is a perfect power. 
     
    26942857        mpz_cdiv_q(n.value, mpq_numref(self.value), mpq_denref(self.value))
    26952858        return n
    26962859
    2697     def round(Rational self, mode = "away"):
     2860    def round(Rational self, mode="away"):
    26982861        """
    26992862        Returns the nearest integer to self, rounding away from 0 by
    27002863        default, for consistency with the builtin Python round.