Ticket #9334: trac_9334-hilbert.patch

File trac_9334-hilbert.patch, 20.6 KB (added by aly.deines, 9 years ago)

Fixes some documentation.

  • sage/rings/arith.py

    # HG changeset patch
    # User Aly Deines <aly.deines@gmail.com>
    # Date 1277846753 25200
    # Node ID 537d7ad27f2465dbc68bc38ab8155a0c0c9db2e3
    # Parent  426be7b253ad9c3137e733aba26165a3de5b832f
    Trac 9334: added features from need to do and wish list
    
    diff -r 426be7b253ad -r 537d7ad27f24 sage/rings/arith.py
    a b  
    32023202    r"""
    32033203    The Legendre symbol `(x|p)`, for `p` prime.
    32043204   
    3205     .. note::
     3205    .. NOTE::
    32063206
    32073207       The :func:`kronecker_symbol` command extends the Legendre
    32083208       symbol to composite moduli and `p=2`.
     3209       The :func:`generalized_legendre_symbol` command extends the Legendre
     3210       symbol to number fields.
    32093211   
    32103212    INPUT:
    32113213   
     
    32413243    if p == 2:
    32423244        raise ValueError, "p must be odd"
    32433245    return x.kronecker(p)
     3246
     3247def generalized_legendre_symbol(self,P):
     3248    r"""
     3249    Returns the generalized Legendre symbol `(a|\mathfrak{p})` for odd primes `\mathfrak{p}.`
     3250   
     3251    INPUT:
     3252
     3253    -``P`` --odd prime ideal of a number field
     3254   
     3255    OUTPUT:
     3256
     3257    The generalized legendre symbol.
     3258
     3259    ALGORITHM: Comes from an exercise in Cohen: A Course in Computational Number Theory.
     3260   
     3261    .. NOTE::
     3262
     3263        This is a naive implementation and is possibly VERY SLOW. 
     3264        The algorithm comes from the definition given in Cohen's A Course in Computational Number Theory:
     3265        `(a|\mathfrak{p}) = \epsilon`
     3266        where `\epsilon \in \{-1,+1,0\}`, `N(\mathfrak{p})` is the norm, and
     3267        `a^{(N(\mathfrak{p})-1)/2} \equiv \epsilon \mod{\mathfrak{p}}.`
     3268       
     3269    EXAMPLES::
     3270
     3271        sage: K.<a> = NumberField(x^2-23)
     3272        sage: P = K.ideal(5)
     3273        sage: b = a+5
     3274        sage: generalized_legendre_symbol(a,P)
     3275        -1
     3276        sage: generalized_legendre_symbol(K(7),P)
     3277        1
     3278    """
     3279    if not P.is_prime():
     3280        raise ValueError, 'P must be a prime ideal'
     3281    if self in P:
     3282        return ZZ(0)
     3283    n = P.norm()
     3284    K = P.ring()
     3285    k = P.residue_field()
     3286    if n%2 == 0:
     3287        raise ValueError, 'P must be odd'
     3288    l = k(K(self)**((n-1)/2))
     3289    if k(-1) == l:
     3290        return ZZ(-1)
     3291    return ZZ(l)
     3292   
     3293
    32443294   
    32453295def primitive_root(n):
    32463296    """
     
    38723922   
    38733923   
    38743924    OUTPUT: integer (0, -1, or 1)
     3925
     3926    .. NOTE::
     3927
     3928       The :func:`generalized_hilbert_symbol` command extends the Hilbert
     3929       symbol to number fields.
    38753930   
    38763931    EXAMPLES::
    38773932   
     
    39484003    else:
    39494004        raise ValueError, "Algorithm %s not defined"%algorithm
    39504005
     4006def generalized_hilbert_symbol(a,b,P):
     4007   
     4008    r"""
     4009    Returns the Hilbert symbol `(a,b)_\mathfrak{p}` for primes `\mathfrak{p}` over a number field.
     4010   
     4011    INPUT:
     4012
     4013    - ``a,b`` -- elements of a number field
     4014    - ``P`` -- odd prime ideal of the same number field
     4015   
     4016    OUTPUT:
     4017    The Hilbert symbol `(a,b)_{\mathfrak{p}}`.
     4018   
     4019    .. NOTE::
     4020
     4021        The algorithm follows Proposition 5.5 from John Voight: Identifying the Matrix Ring.
     4022       
     4023    EXAMPLES::
     4024
     4025        sage: K.<a> = NumberField(x^2-23)
     4026        sage: P = K.ideal(5)
     4027        sage: b = a+5
     4028        sage: generalized_hilbert_symbol(a,a+5,K.ideal(5))
     4029        1
     4030        sage: generalized_hilbert_symbol(a+1,13,K.ideal(-a-6))
     4031        -1
     4032       
     4033    ::
     4034
     4035        sage: K.<a> = NumberField(x^5-23)
     4036        sage: P = K.ideal(-1105*a^4 + 1541*a^3 - 795*a^2 - 2993*a + 11853)
     4037        sage: b = -a+5
     4038        sage: generalized_hilbert_symbol(a,a+5,K.ideal(2*a^4 + 3*a^3 + 4*a^2 + 15*a + 11))
     4039        1
     4040        sage: generalized_hilbert_symbol(a,b,K.ideal(2*a^4 + 3*a^3 + 4*a^2 + 15*a + 11))
     4041        1
     4042        sage: generalized_hilbert_symbol(a,b,P)
     4043        -1
     4044        sage: generalized_hilbert_symbol(a,2,P)
     4045        -1
     4046
     4047    ::
     4048
     4049        sage: K.<a> = NumberField(x^3+x+1)
     4050        sage: P = K.ideal(-a^2-a-2)
     4051        sage: generalized_hilbert_symbol(-6912, 24, P)
     4052        1
     4053
     4054    ::
     4055
     4056        sage: K.<a> = NumberField(x^5-23)
     4057        sage: P = K.ideal(-1105*a^4 + 1541*a^3 - 795*a^2 - 2993*a + 11853)
     4058        sage: Q = K.ideal(-7*a^4 + 13*a^3 - 13*a^2 - 2*a + 50)
     4059        sage: b = -a+5
     4060        sage: generalized_hilbert_symbol(a,b,P)
     4061        -1
     4062        sage: generalized_hilbert_symbol(a,b,Q)
     4063        1
     4064
     4065    ::
     4066        sage: K.<i> = QuadraticField(-1)
     4067        sage: O = K.maximal_order()
     4068        sage: generalized_hilbert_symbol(K(1/2), K(1), 3*O)
     4069        1
     4070        sage: generalized_hilbert_symbol(K(1/3), K(1), (1+i)*O)
     4071        1
     4072        sage: p = 1+i
     4073        sage: generalized_hilbert_symbol(p,p,p*O)
     4074        -1
     4075
     4076    """
     4077    from sage.rings.number_field.number_field import generalized_even_hilbert_symbol
     4078
     4079    if not P.is_prime():
     4080        raise ValueError, "P must be a prime"
     4081   
     4082    pi = P.uniformizer()
     4083    K = P.ring()
     4084
     4085    a = K(a)*K(a.denominator())
     4086    b = K(b)*K(b.denominator())
     4087    c = K(-a*b)
     4088
     4089    a = a / pi**(2*(a.valuation(P)//2))
     4090    b = b / pi**(2*(b.valuation(P)//2))
     4091    c = c / pi**(2*(c.valuation(P)//2))
     4092
     4093
     4094    if a.valuation(P)%2==1 and b.valuation(P)%2==1:
     4095       return generalized_hilbert_symbol(a, c, P)
     4096
     4097    if P.divides(2):
     4098            return generalized_even_hilbert_symbol(a,b,P)
     4099
     4100   
     4101    ssa = a.square_symbol(P)
     4102    if ssa == 1:
     4103        return 1
     4104    ssb = b.square_symbol(P)
     4105    if ssb == 1:
     4106        return 1
     4107    ssc = c.square_symbol(P)
     4108    if ssc == 1:
     4109        return 1
     4110    if ssa == -1 and ssb == -1:
     4111        return 1
     4112
     4113    return -1
     4114
     4115
    39514116
    39524117def hilbert_conductor(a, b):
    39534118    """
  • sage/rings/number_field/number_field.py

    diff -r 426be7b253ad -r 537d7ad27f24 sage/rings/number_field/number_field.py
    a b  
    78237823    # field with lower precision will equal the lower-precision root!
    78247824    diffs = [(RC(ee(K.gen()))-old_root).abs() for ee in elist]
    78257825    return elist[min(izip(diffs,count()))[1]]
     7826
     7827def generalized_even_hilbert_symbol(a,b,P):
     7828    r"""
     7829    Returns the Hilbert symbol `(a,b)_P` for `a,b` elements of a number field `K` and `P` a prime ideal of `K`.
     7830   
     7831    INPUT:
     7832
     7833    - ``a,b`` --number field elements
     7834    - ``P`` --prime ideal
     7835   
     7836    OUTPUT:
     7837
     7838    - 1, -1, or 0
     7839   
     7840    ALGORITHM: This is Algorithm 6.6 from John Voight: Identifying the Matrix Ring.
     7841       
     7842    EXAMPLES::
     7843
     7844        sage: from sage.rings.number_field.number_field import generalized_even_hilbert_symbol
     7845        sage: K.<a> = NumberField(x^5-23)
     7846        sage: P = K.ideal(-1105*a^4 + 1541*a^3 - 795*a^2 - 2993*a + 11853)
     7847        sage: b = a+5
     7848        sage: generalized_even_hilbert_symbol(a,b,P)
     7849        -1
     7850        sage: generalized_even_hilbert_symbol(a,2,P)
     7851        -1
     7852        sage: generalized_even_hilbert_symbol(a+5,2,P)
     7853        -1
     7854    """
     7855   
     7856    #step 0: checks
     7857    F = P.ring()
     7858    a,b = F(a),F(b)
     7859    if not P.divides(F.ideal(2)):
     7860        raise ValueError, 'P must be even'
     7861   
     7862    #step 1: assume a and b have been scaled
     7863    #step 2:
     7864   
     7865    x,y,z,w = _voight_alg_6_5(a,b,P)
     7866
     7867    Rp = F.residue_field(P)
     7868    pmap = Rp.lift_map()
     7869    R = F['T']
     7870    T = R.gen()
     7871    #the norm of i prime:
     7872    Niprime = (1-a*y**2-b*z**2+a*b*w**2)/4
     7873    #here f is the min poly of iprime
     7874    f = T**2-T+Niprime
     7875    for r in Rp:
     7876        if f(pmap(r))==0:
     7877            return 1
     7878   
     7879    bprime = (z**2)*(b**2)*a+(y**2)*(a**2)*b
     7880    if bprime.valuation(P) % 2 == 0:
     7881        return 1
     7882       
     7883    return -1   
     7884 
     7885def _voight_alg_6_2(a,b,P):
     7886    r"""
     7887    This function returns a solution to the congruence
     7888    `1-a*y^2-b*z^2 \equiv 0 (\mod P^{2*e})` where `e` is the ramification index of `P` over 2,
     7889    i.e. it returns a solution to an integral norm form (via a Hensel-like lifting).
     7890    This is a special case of the more general `x^2-a*y^2-b*z^2+a*b*w^2 \equiv 0 (\mod P^{2e}).`
     7891
     7892    INPUT:
     7893
     7894    - ``a,b`` --integers in the number field `F`
     7895    - ``P``  -- a prime ideal dividing 2
     7896
     7897    OUTPUT:
     7898
     7899    a tuple `1,y,z,0` --integer elements of `F`
     7900
     7901    EXAMPLES::
     7902
     7903        sage: from sage.rings.number_field.number_field import _voight_alg_6_2
     7904        sage: K.<a> = NumberField(x^5-23)
     7905        sage: P = K.ideal(-1105*a^4 + 1541*a^3 - 795*a^2 - 2993*a + 11853)
     7906        sage: Q = K.ideal(-7*a^4 + 13*a^3 - 13*a^2 - 2*a + 50)
     7907        sage: b = -a+5
     7908        sage: _voight_alg_6_2(a,2,P)
     7909        (1, a^2, 1, 0)
     7910        sage: _voight_alg_6_2(b,2,P)
     7911        (1, a^2 + a + 1, a^3 + a^2, 0)
     7912        sage: _voight_alg_6_2(2,b,P)
     7913        (1, a^3 + a^2, a^2 + a + 1, 0)
     7914
     7915    """
     7916
     7917    #some initializations
     7918    F = P.number_field()
     7919    a = F(a)
     7920    b = F(b)
     7921
     7922    if not P.is_prime():
     7923        raise ValueError, "P must be prime"
     7924    if not P.divides(F.ideal(2)):
     7925        raise ValueError, "P must be even"
     7926    e = P.ramification_index()
     7927    k = P.residue_field()
     7928    E = 2*e
     7929    va = a.valuation(P)
     7930    vb = b.valuation(P)
     7931    switch = False
     7932   
     7933    if va != 0 and vb != 0:
     7934        raise ValueError, 'ord_P(a) or ord_P(b) must be zero'
     7935    if va == 0 and vb == 0:
     7936        raise ValueError, 'wrong case, use _voight_alg_6_5'
     7937    if vb == 0:
     7938        switch = True
     7939        a,b = b,a
     7940        va = a.valuation(P)
     7941        vb = b.valuation(P)
     7942
     7943    #step 1
     7944    f = P.residue_class_degree()
     7945    q = 2**f
     7946    pi = P.gens_reduced()[-1]
     7947 
     7948
     7949    #step 2
     7950    y = a.solver_mod_p(P,1)
     7951    z = 0
     7952
     7953    #step 3
     7954
     7955    N = F(1-a*y**2-b*z**2).mod(F.ideal(4))
     7956
     7957    if N == 0:
     7958        return 1,y,z,0
     7959    t = N.valuation(P)
     7960
     7961    while t < E:
     7962        if E <= t:
     7963            break
     7964        if t%2==0:
     7965            ins1 = (N/(a*pi**t)).sqrt_mod_p(P)
     7966            y = y+ins1*pi**(t/2)
     7967            N = (1-a*y**2-b*z**2).mod(F.ideal(4))
     7968            t = N.valuation(P)
     7969
     7970        if E <= t:
     7971            break
     7972
     7973        if t%2==1:
     7974            ins2 = (N/(b*pi**(t-1))).sqrt_mod_p(P)
     7975            z = z+ins2*pi**((t/2).floor())
     7976            N = (1-a*y**2-b*z**2)
     7977            t = N.valuation(P)
     7978   
     7979        if E <= t:
     7980            break
     7981    #end of while
     7982   
     7983    if switch:
     7984        return 1,z,y,0
     7985    return 1,y,z,0   
     7986
     7987
     7988def _voight_alg_6_5(a,b,P):
     7989    r"""
     7990    Returns a solution to the congruence `1-a*y^2-b*z^2 +a*b*w^2 \equiv 0 (\mod P^{2e})`
     7991    where `e` is the ramification index of `P` over 2,
     7992    i.e. it returns a solution to an integral norm form (via a Hensel-like lifting).
     7993
     7994    INPUT:
     7995
     7996    - ``a,b`` --integers in the number field `F`
     7997    - ``P``  -- a prime ideal dividing 2
     7998
     7999    OUTPUT:
     8000
     8001    a tuple `1,y,z,w` --integer elements of `F`
     8002
     8003    EXAMPLES::
     8004   
     8005        sage: from sage.rings.number_field.number_field import _voight_alg_6_5
     8006        sage: K.<a> = NumberField(x^5-23)
     8007        sage: P = K.ideal(-1105*a^4 + 1541*a^3 - 795*a^2 - 2993*a + 11853)
     8008        sage: b = -a+5
     8009        sage: _voight_alg_6_5(a,b,P)
     8010        (1, a^2, a^2 + a + 1, a^4 + a^3 + a^2)
     8011        sage: _voight_alg_6_5(a*b,b,P)
     8012        (1, a + 1, a^2 + a + 1, a^3 + 2*a^2 + 2*a + 1)
     8013
     8014
     8015
     8016    """
     8017
     8018    F = P.number_field() 
     8019    a,b = F(a),F(b) 
     8020    pi = P.uniformizer()
     8021    if not P.is_prime():
     8022        raise ValueError, 'P must be a prime'
     8023    if not P.divides(F.ideal(2)):
     8024        raise ValueError, 'P must lie over 2'
     8025       
     8026    va = a.valuation(P)
     8027    vb = b.valuation(P)
     8028    if va != 0 and vb != 0:
     8029        raise ValueError, 'ord_P(a) or ord_P(b) must be zero'
     8030    #fix these to reducing b and c:
     8031    if va == 0 and vb > 1:
     8032        b = b / pi**(2*(b.valuation(P)//2))
     8033        vb = b.valuation(P)
     8034    if vb == 0 and va > 1:
     8035        a = a / pi**(2*(a.valuation(P)//2))
     8036        va = a.valuation(P)
     8037    if va >1 or vb >1:
     8038        raise ValueError, 'the reduction did not work'
     8039       
     8040    Zp = P.residue_field()
     8041    e = P.ramification_index()
     8042    pi = P.gens_reduced()[0]   
     8043    E = 2*e
     8044
     8045   
     8046    #step 1
     8047    #first possibility
     8048    if va == 1 and vb == 0:
     8049        return _voight_alg_6_2(a,b,P)
     8050    #second possibility
     8051    if va == 0 and vb == 1:
     8052        return _voight_alg_6_2(a,b,P)
     8053   
     8054    #step 2
     8055    #check if we can solve x^2*c = 1 mod P^2 for c = a and c = b
     8056    #if not, returns solution = 0
     8057    while True:
     8058        try:
     8059            a0 = a.solver_mod_p(P,e)
     8060            break
     8061        except ZeroDivisionError:
     8062            a0 = 0
     8063        break
     8064    while True:
     8065        try:
     8066            b0 = b.solver_mod_p(P,e)
     8067            break
     8068        except ZeroDivisionError:
     8069            b0 = 0
     8070        break
     8071   
     8072    if a0 and b0:
     8073        a0 = F(a).solver_mod_p(P,e)
     8074        b0 = F(b).solver_mod_p(P,e)
     8075        return 1,a0,b0,a0*b0
     8076       
     8077    #end step 2
     8078   
     8079    #step 3
     8080    #swap so that a0 is not invertible mod P^e
     8081    switch = False
     8082    if not b0:
     8083        a0,b0 = b0,a0
     8084        switch = True
     8085       
     8086    #now assuming that a0 is not invertible mod P^e
     8087    t = 1
     8088    aIn = a.solver_mod_p(P,1)
     8089    while aIn:
     8090        try:
     8091            t = t+1
     8092            aIn = a.solver_mod_p(P,t)
     8093            break
     8094        except ZeroDivisionError:
     8095            aIn = 0
     8096            break
     8097   
     8098
     8099    top = F(a)-F(a0**2)
     8100    at = top/(pi**t)
     8101    newb = -pi*at/b
     8102    x,y,z,w = _voight_alg_6_2(a,newb,P)
     8103    xnew = 1
     8104   
     8105    ynew = a.solver_mod_p(P,1)
     8106    zinv = z.inverse_mod(P)
     8107    znew = pi**((t/2).floor())*zinv*ynew
     8108    wnew = y*pi**((t/2).floor())*zinv*ynew
     8109    if switch:
     8110        return xnew,znew,ynew,wnew
     8111    return xnew,ynew,znew,wnew
     8112
  • sage/rings/number_field/number_field_element.pyx

    diff -r 426be7b253ad -r 537d7ad27f24 sage/rings/number_field/number_field_element.pyx
    a b  
    27522752            raise NotImplementedError, "inverse_mod is not implemented for non-integral elements"               
    27532753
    27542754
     2755
     2756    def sqrt_mod_p(self,P):
     2757        r"""
     2758       
     2759        Returns the square root of self mod the prime ideal `\mathfrak{p}`.
     2760
     2761        INPUT:
     2762
     2763        -  ``P`` -- is a prime ideal be an ideal of self.parent(). A ValueError
     2764           is raised if `\mathfrak{p}` is not prime or self is not a square mod `\mathfrak{p}`.
     2765
     2766        OUTPUT:
     2767
     2768        The square root of self mod `\mathfrak{p}`
     2769
     2770        .. NOTE::
     2771
     2772            This is not yet implemented for non-integral elements.
     2773
     2774        EXAMPLES::
     2775
     2776            sage: K.<a> = NumberField(x^5-23)
     2777            sage: P = K.ideal(-1105*a^4 + 1541*a^3 - 795*a^2 - 2993*a + 11853)
     2778            sage: Q = K.ideal(-7*a^4 + 13*a^3 - 13*a^2 - 2*a + 50)
     2779            sage: b = -a+5
     2780            sage: a.sqrt_mod_p(P)
     2781            a^3
     2782            sage: b.sqrt_mod_p(P)
     2783            a^3 + 1
     2784
     2785        ::
     2786
     2787            sage: k.<a> = NumberField(x^3 + 11)
     2788            sage: d = a + 3
     2789            sage: d.sqrt_mod_p(k.ideal(-a-2))
     2790            1
     2791
     2792        """
     2793        k = P.residue_field()
     2794        f = k.lift_map()
     2795        if not P.is_prime():
     2796            raise ValueError, 'P must be a prime ideal.'
     2797        if not k(self).is_square():
     2798            raise ValueError, 'must be a square mod P'
     2799        return f(k(self).sqrt())
     2800
     2801    def sqrt_mod(self,P,n, verb = False):
     2802        r"""
     2803       
     2804        Returns the square root of self mod the prime ideal `\mathfrak{p}^n`.
     2805       
     2806        INPUT:
     2807
     2808        -  ``P`` -- is a prime ideal be an ideal of self.parent(). A ValueError
     2809           is raised if `\mathfrak{p}` is not prime or self is not a square mod `\mathfrak{p}`.
     2810
     2811        OUTPUT:
     2812
     2813        The square root of self mod `\mathfrak{p}^n`
     2814
     2815        .. NOTE::
     2816
     2817            This is not yet implemented for non-integral elements.
     2818
     2819        EXAMPLES::
     2820
     2821            sage: K.<a> = NumberField(x^5-23)
     2822            sage: P = K.ideal(-1105*a^4 + 1541*a^3 - 795*a^2 - 2993*a + 11853)
     2823            sage: Q = K.ideal(-7*a^4 + 13*a^3 - 13*a^2 - 2*a + 50)
     2824            sage: b = -a+5
     2825            sage: a.sqrt_mod(P,1)
     2826            a^3
     2827            sage: b.sqrt_mod(P,1)
     2828            a^3 + 1
     2829            sage: ((a^2).sqrt_mod(P,2)^2 - a^2) in P^2
     2830            True
     2831
     2832        ::
     2833
     2834            sage: k.<a> = NumberField(x^3 + 11)
     2835            sage: d = a + 3
     2836            sage: d.sqrt_mod(k.ideal(-a-2),1)
     2837            1
     2838            sage: d.sqrt_mod(k.ideal(-a-2),2)
     2839            -a^2
     2840
     2841        """
     2842        if not P.is_prime():
     2843            raise ValueError, 'P must be a prime ideal.'
     2844        if n == 1:
     2845            return self.sqrt_mod_p(P)
     2846        Pn = P**n
     2847        I = Pn.residues()
     2848        for i in I:
     2849            if (i**2 - self) in Pn:
     2850                return i
     2851        raise ValueError, 'self is not a square root mod P^n'
     2852       
     2853    def solver_mod_p(self,P,n):
     2854        r"""
     2855        Returns `x` such that `x^2 a \equiv 1 \text{ } (\text{mod }{ \mathfrak{p}^n})` where `a =` self.
     2856       
     2857        INPUT:
     2858
     2859        -  ``P`` - is a prime ideal be an ideal of self.parent(). A ValueError
     2860           is raised if `\mathfrak{p}` is not prime or self has no solution to the congruence
     2861           mod `\mathfrak{p}^n.`
     2862
     2863        - ``n`` - a positive integer
     2864
     2865        OUTPUT:
     2866
     2867        The solution to the above congruence.
     2868       
     2869        EXAMPLES::
     2870
     2871            sage: K.<a> = NumberField(x^5-23)
     2872            sage: P = K.ideal(-1105*a^4 + 1541*a^3 - 795*a^2 - 2993*a + 11853)
     2873            sage: Q = K.ideal(-7*a^4 + 13*a^3 - 13*a^2 - 2*a + 50)
     2874            sage: b = -a+5
     2875            sage: a.solver_mod_p(P,1)
     2876            a^2
     2877            sage: (b^2).solver_mod_p(P,2)
     2878            -a^3 - a
     2879       
     2880        """
     2881       
     2882        Ppow = P**n
     2883        a = self.inverse_mod(Ppow)
     2884        x = a.sqrt_mod(P,n)
     2885        return x
     2886
     2887    def square_symbol(self,P):
     2888        r"""
     2889        Returns the square symbol from John Voight's: Identifying the Matrix Ring. 
     2890        Let `K` be a number field, `a \in K` and `\mathfrak{p}` a prime ideal of `K` then:
     2891        `\{ \frac{a}{\mathfrak{p}}\} =  1` if `a \in K_{\mathfrak{p}}^{* 2}`,
     2892        `\{ \frac{a}{\mathfrak{p}}\} = -1` if `a \not \in K_{\mathfrak{p}}^{* 2}` and
     2893        `\text{ord}_{\mathfrak{p}}(a)` is even,
     2894        and
     2895        `\{ \frac{a}{\mathfrak{p}}\} =  0` if `a \not \in K_{\mathfrak{p}}^{* 2}` and
     2896        `\text{ord}_{\mathfrak{p}}(a)` is odd.
     2897       
     2898        INPUT:
     2899
     2900        - ``P`` --prime ideal
     2901       
     2902        OUTPUT:
     2903
     2904        - 1,-1, or 0
     2905       
     2906        ALGORITHM: The algorithm follows the section on Computing Local Hilbert Symbols from
     2907        John Voight: Identifying the Matrix Ring.
     2908
     2909        EXAMPLE::
     2910
     2911            sage: K.<a> = NumberField(x^5-23)
     2912            sage: Q = K.ideal(-7*a^4 + 13*a^3 - 13*a^2 - 2*a + 50)
     2913            sage: b = -a+5
     2914            sage: a.square_symbol(Q)
     2915            1
     2916            sage: b.square_symbol(Q)
     2917            -1
     2918
     2919        """
     2920        from sage.rings.arith import generalized_legendre_symbol
     2921        if not P.is_prime():
     2922            raise ValueError, "P must be a prime"
     2923        K = P.ring()
     2924        if P.divides(2):
     2925            raise ValueError, "P must be odd"
     2926        pi = P.uniformizer()
     2927        a = K(self)
     2928        e = a.valuation(P)
     2929        if e%2 == 1:
     2930            square_symbol_a = 0
     2931        else:
     2932            pi = P.uniformizer()
     2933            a0 = a*pi**(-e/2)
     2934            square_symbol_a = generalized_legendre_symbol(a0,P)
     2935           
     2936        return square_symbol_a
     2937
     2938
     2939
    27552940cdef class NumberFieldElement_absolute(NumberFieldElement):
    27562941
    27572942    def _pari_(self, var='x'):
  • sage/rings/number_field/number_field_ideal.py

    diff -r 426be7b253ad -r 537d7ad27f24 sage/rings/number_field/number_field_ideal.py
    a b  
    11671167        """
    11681168        return self.number_field().galois_group().artin_symbol(self)
    11691169
     1170    def uniformizer(self):
     1171        r"""
     1172        Returns an element `\pi` of `\mathfrak{p} =` self such that `\text{ord}(\pi)_{\mathfrak{p}} = 1`.
     1173        This wraps K.uniformizer(self).
     1174       
     1175       
     1176        OUTPUT: 
     1177        `\pi` -- a uniformizer of `\mathfrak{p}`
     1178       
     1179       
     1180           
     1181        EXAMPLES::
     1182           
     1183            sage: K.<a> = NumberField(x^2-10)
     1184            sage: P = K.ideal(3).factor()[0][0]
     1185            sage: P.uniformizer()
     1186            -2*a + 1
     1187           
     1188        ::
     1189           
     1190            sage: K.<a> = NumberField(x^5-23)
     1191            sage: P = K.ideal(3).factor()[0][0]
     1192            sage: P.uniformizer()
     1193            a^4 - a^3 + a^2 - a + 1
     1194           
     1195        ::
     1196           
     1197            sage: K.<a> = NumberField(x^2+1489)
     1198            sage: P = K.ideal(3).factor()[0][0]
     1199            sage: P.uniformizer()
     1200            3
     1201                   
     1202        """
     1203        #this just raps K.uniformizer(self)
     1204        K = self.ring()
     1205        return K.uniformizer(self)
     1206
     1207
     1208
    11701209def basis_to_module(B, K):
    11711210    r"""
    11721211    Given a basis `B` of elements for a `\ZZ`-submodule of a number