Ticket #9334: trac_9334-hilbert.patch
File trac_9334-hilbert.patch, 20.6 KB (added by , 12 years ago) |
---|
-
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 3202 3202 r""" 3203 3203 The Legendre symbol `(x|p)`, for `p` prime. 3204 3204 3205 .. note::3205 .. NOTE:: 3206 3206 3207 3207 The :func:`kronecker_symbol` command extends the Legendre 3208 3208 symbol to composite moduli and `p=2`. 3209 The :func:`generalized_legendre_symbol` command extends the Legendre 3210 symbol to number fields. 3209 3211 3210 3212 INPUT: 3211 3213 … … 3241 3243 if p == 2: 3242 3244 raise ValueError, "p must be odd" 3243 3245 return x.kronecker(p) 3246 3247 def 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 3244 3294 3245 3295 def primitive_root(n): 3246 3296 """ … … 3872 3922 3873 3923 3874 3924 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. 3875 3930 3876 3931 EXAMPLES:: 3877 3932 … … 3948 4003 else: 3949 4004 raise ValueError, "Algorithm %s not defined"%algorithm 3950 4005 4006 def 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 3951 4116 3952 4117 def hilbert_conductor(a, b): 3953 4118 """ -
sage/rings/number_field/number_field.py
diff -r 426be7b253ad -r 537d7ad27f24 sage/rings/number_field/number_field.py
a b 7823 7823 # field with lower precision will equal the lower-precision root! 7824 7824 diffs = [(RC(ee(K.gen()))-old_root).abs() for ee in elist] 7825 7825 return elist[min(izip(diffs,count()))[1]] 7826 7827 def 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 7885 def _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 7988 def _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 2752 2752 raise NotImplementedError, "inverse_mod is not implemented for non-integral elements" 2753 2753 2754 2754 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 2755 2940 cdef class NumberFieldElement_absolute(NumberFieldElement): 2756 2941 2757 2942 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 1167 1167 """ 1168 1168 return self.number_field().galois_group().artin_symbol(self) 1169 1169 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 1170 1209 def basis_to_module(B, K): 1171 1210 r""" 1172 1211 Given a basis `B` of elements for a `\ZZ`-submodule of a number