uniformizer; skoki filtracji; grupy rozgalezienia

sage/as_covers/as_cover_class.sage

@@ -8,6 +8,15 @@ class as_cover:
         p = C.characteristic
         self.characteristic = p
         self.prec = prec
+        #group acting
+        n = self.height
+        from itertools import product
+        pr = [list(GF(p)) for _ in range(n)]
+        group = []
+        for a in product(*pr):
+            group += [a]
+        self.group = group
+        #########
         f = C.polynomial
         m = C.exponent
         r = f.degree()
@@ -229,6 +238,75 @@ class as_cover:
                   
         return forms
     
+    def uniformizer(self, i = 0):
+        '''Return uniformizer of curve self at i-th place at infinity.'''
+        p = self.characteristic
+        n = self.height
+        variable_names = 'x, y'
+        for j in range(n):
+            variable_names += ', z' + str(j)
+        Rxyz = PolynomialRing(F, n+2, variable_names)
+        x, y = Rxyz.gens()[:2]
+        z = Rxyz.gens()[2:]
+        fx = as_function(self, x)
+        z = [as_function(self, zi) for zi in z]
+        # We create a list of functions. We add there all variables...
+        list_of_fcts = [fx]+z
+        vfx = fx.valuation(i)
+        vz = [zi.valuation(i) for zi in z]
+        
+        # Then we subtract powers of variables with the same valuation (so that 1/t^(kp) cancels) and add to this list.
+        for  j1 in range(n):
+            for j2 in range(n):
+                if j1>j2:
+                    a = gcd(vz[j1] , vz[j2])
+                    vz1 = vz[j1]/a
+                    vz2 = vz[j2]/a
+                    for b in GF(p):
+                        if (z[j1]^(vz2) - b*z[j2]^(vz1)).valuation(i) > (z[j2]^(vz1)).valuation(i):
+                            list_of_fcts += [z[j1]^(vz2) - b*z[j2]^(vz1)]
+        for j1 in range(n):
+            a = gcd(vz[j1], vfx)
+            vzj = vz[j1] /a
+            vfx = vfx/a
+            for b in GF(p):
+                if (fx^(vzj) - b*z[j1]^(vfx)).valuation(i) > (z[j1]^(vfx)).valuation(i):
+                    list_of_fcts += [fx^(vzj) - b*z[j1]^(vfx)]
+        #Finally, we check if on the list there are two elements with the same valuation.
+        for f1 in list_of_fcts:
+            for f2 in list_of_fcts:
+                d, a, b = xgcd(f1.valuation(i), f2.valuation(i))
+                if d == 1:
+                    return f1^a*f2^b
+        raise ValueError("My method of generating fcts with relatively prime valuation failed.")
+        
+
+    def ith_ramification_gp(self, i, place = 0):
+        '''Find ith ramification group at place at infty of nb place.'''
+        G = self.group
+        t = self.uniformizer(place)
+        Gi = [G[0]]
+        for g in G:
+            if g != G[0]:
+                tg = t.group_action(g)
+                v = (tg - t).valuation(place)
+                if v >= i+1:
+                    Gi += [g]
+        return Gi
+    
+    def ramification_jumps(self, place = 0):
+        '''Return list of lower ramification jumps at at place at infty of nb place.'''
+        G = self.group
+        ramification_jps = []
+        i = 0
+        while len(G) > 1:
+            Gi = self.ith_ramification_gp(i+1, place)
+            if len(Gi) < len(G):
+                ramification_jps += [i]
+            G = Gi
+            i+=1
+        return ramification_jps
+            
 def holomorphic_combinations(S):
     """Given a list S of pairs (form, corresponding Laurent series at some pt), find their combinations holomorphic at that pt."""
     C_AS = S[0][0].curve

sage/as_covers/as_form_class.sage

@@ -122,9 +122,9 @@ class as_form:
         z = Rxyz.gens()[2:]
         RxyzQ = FractionField(Rxyz)
         result = as_form(C, 0)
-        for i in range(0, p):
+        G = C.group
-            for j in range(0, p):
+        for a in G:
-                result += self.group_action([i, j])
+            result += self.group_action(a)
         result = result.form
         Rxy.<x, y> = PolynomialRing(F, 2)
         Qxy = FractionField(Rxy)
@@ -138,11 +138,12 @@ def artin_schreier_transform(power_series, prec = 10):
        z^p - z = power_series, where z = 1/t_new^(jump) and express z in terms of the new uniformizer."""
     correction = 0
     F = power_series.parent().base()
+    p = F.characteristic()
     Rt.<t> = LaurentSeriesRing(F, default_prec=prec)
     RtQ = FractionField(Rt)
     power_series = RtQ(power_series)
     if power_series.valuation() == +Infinity:
-        return(0,0,t,0)
+        raise ValueError("Precision is too low.")
     while(power_series.valuation() % p == 0 and power_series.valuation() < 0):
         M = -power_series.valuation()/p
         coeff = power_series.list()[0]   #wspolczynnik a_(-p) w f_AS

sage/as_covers/as_function_class.sage

@@ -39,6 +39,17 @@ class as_function:
         g2 = other.function
         return as_function(C, g1*g2)
     
+    def __truediv__(self, other):
+        C = self.curve
+        g1 = self.function
+        g2 = other.function
+        return as_function(C, g1/g2)
+    
+    def __pow__(self, exponent):
+        C = self.curve
+        g1 = self.function
+        return as_function(C, g1^(exponent))
+    
     def expansion_at_infty(self, i = 0):
         C = self.curve
         delta = C.nb_of_pts_at_infty
@@ -116,10 +127,15 @@ class as_function:
         z = Rxyz.gens()[2:]
         RxyzQ = FractionField(Rxyz)
         result = as_function(C, 0)
-        for i in range(0, p):
+        G = C.group
-            for j in range(0, p):
+        for a in G:
-                result += self.group_action([i, j])
+            result += self.group_action(a)
         result = result.function
         Rxy.<x, y> = PolynomialRing(F, 2)
         Qxy = FractionField(Rxy)
         return superelliptic_function(C_super, Qxy(result))
+    
+    
+    def valuation(self, i = 0):
+        '''Return valuation at i-th place at infinity.'''
+        return self.expansion_at_infty(i).valuation()

sage/as_covers/dual_element.sage

@@ -2,7 +2,7 @@ def dual_elt(AS, zmag):
     '''Find the trace dual of a given elt zmag in the function field of an Artin-Schreier cover AS.'''
     p = AS.characteristic
     n = AS.height
-    group_elts = [(i, j) for i in range(p) for j in range(p)]
+    G = AS.group
     variable_names = 'x, y'
     for i in range(n):
         variable_names += ', z' + str(i)
@@ -13,12 +13,12 @@ def dual_elt(AS, zmag):
     M = matrix(RxyzQ, p^n, p^n)
     for i in range(p^n):
         for j in range(p^n):
-            M[i, j] = (zmag.group_action(group_elts[i])*zmag.group_action(group_elts[j])).trace2()
+            M[i, j] = (zmag.group_action(G[i])*zmag.group_action(G[j])).trace2()
     main_det = M.determinant()
     zvee = as_function(AS, 0)
     for i in range(p^n):
         Mprim = matrix(RxyzQ, M)
-        Mprim[:, i] = vector([(j == 0) for j in range(p^2)])
+        Mprim[:, i] = vector([(j == 0) for j in range(p^n)])
         fi = Mprim.determinant()/main_det
-        zvee += fi*zmag.group_action(group_elts[i])
+        zvee += fi*zmag.group_action(G[i])
     return zvee

sage/as_covers/ith_magical_component.sage

@@ -1,9 +1,8 @@
-def ith_magical_component(omega, zvee, i):
+def ith_magical_component(omega, zvee, g):
-    '''Given a form omega on AS cover and normal basis element zmag, find the decomposition
+    '''Given a form omega on AS cover, element g of group AS.group and normal basis element zmag, find the decomposition
-    sum_g g(zmag) omega_g and return omega_g, where g is the ith element of the group.'''
+    sum_g g(zmag) omega_g and return omega_g.'''
     AS = omega.curve
     p = AS.characteristic
-    group_elts = [(j1, j2) for j1 in range(p) for j2 in range(p)]
+    z_vee_fct = zvee.group_action(g).function
-    z_vee_fct = zvee.group_action(group_elts[i]).function
     new_form = as_form(AS, z_vee_fct*omega.form)
     return new_form.trace2()

sage/as_covers/tests/ith_ramification_gp_test.sage

@@ -0,0 +1,20 @@
+p = 3
+m = 1
+F = GF(p)
+Rx.<x> = PolynomialRing(F)
+f = x
+C_super = superelliptic(f, m)
+
+Rxy.<x, y> = PolynomialRing(F, 2)
+f1 = superelliptic_function(C_super, x^7)
+f2 = superelliptic_function(C_super, x^4)
+AS = as_cover(C_super, [f1, f2], prec=1000)
+n = AS.height
+d_test = (p^n - 1)
+Gi = AS.group
+i = 1
+while(len(Gi) > 1):
+    Gi = AS.ith_ramification_gp(i)
+    d_test += len(Gi) - 1
+    i+=1
+print(d_test == AS.exponent_of_different())

sage/as_covers/tests/ramification_jumps_test.sage

@@ -0,0 +1,25 @@
+p = 5
+m = 1
+F = GF(p)
+Rx.<x> = PolynomialRing(F)
+f = x
+C_super = superelliptic(f, m)
+
+Rxy.<x, y> = PolynomialRing(F, 2)
+f1 = superelliptic_function(C_super, x^2)
+f2 = superelliptic_function(C_super, x^3)
+AS = as_cover(C_super, [f1, f2], prec=500)
+m = AS.jumps[0]
+m1 = m[0]
+m2 = m[1]
+#We compute jumps from jumps in the tower of two Z/p-covers.
+if m1 >= m2:
+    M1 = m2
+    M2 = m2 + p*(m1 - m2)
+else:
+    M1 = m1
+    M2 = m2
+
+theoretical_jumps = [M1, M2]
+theoretical_jumps.sort()
+print(theoretical_jumps == AS.ramification_jumps())

sage/as_covers/tests/uniformizer_test.sage

@@ -0,0 +1,12 @@
+p = 3
+m = 1
+F = GF(p)
+Rx.<x> = PolynomialRing(F)
+f = x
+C_super = superelliptic(f, m)
+
+Rxy.<x, y> = PolynomialRing(F, 2)
+f1 = superelliptic_function(C_super, x^7)
+f2 = superelliptic_function(C_super, x^4)
+AS = as_cover(C_super, [f1, f2], prec=1000)
+print(AS.unifomizer().valuation() == 1)

sage/drafty/draft.sage

@@ -1,4 +1,4 @@
-p = 5
+p = 3
 m = 1
 F = GF(p)
 Rx.<x> = PolynomialRing(F)
@@ -6,14 +6,16 @@ f = x
 C_super = superelliptic(f, m)
 
 Rxy.<x, y> = PolynomialRing(F, 2)
-f1 = superelliptic_function(C_super, x^3)
+f1 = superelliptic_function(C_super, x^2)
-f2 = superelliptic_function(C_super, x^11)
+f2 = superelliptic_function(C_super, x^4)
-AS = as_cover(C_super, [f1, f2], prec=500)
+f3 = superelliptic_function(C_super, x^5)
+AS = as_cover(C_super, [f1, f2, f3], prec=1000)
+print(AS)
 zmag = AS.magical_element(threshold = 20)[0]
 zvee = dual_elt(AS, zmag)
 
 ### DEFINE THE POLYNOMIALS
-n = 2
+n = AS.height
 variable_names = 'x, y'
 for i in range(n):
     variable_names += ', z' + str(i)
@@ -32,26 +34,23 @@ def val_of_components(omega, zvee):
         result += [val]
     return result
 #############
-print(zvee.expansion_at_infty().valuation())
+G = AS.group
+
 g = AS.genus()
 print(AS.exponent_of_different_prim())
-#for i in range(g):
-#    om = AS.holomorphic_differentials_basis(threshold = 30)[i]
-#    print(AS.exponent_of_different_prim(), val_of_components(om, zvee))
-
-
 v_x = as_function(AS, x).expansion_at_infty().valuation()
-v_z0 = as_function(AS, z[0]).expansion_at_infty().valuation()
+n = AS.height
-v_z1 = as_function(AS, z[1]).expansion_at_infty().valuation()
+v_z = [as_function(AS, z[i]).expansion_at_infty().valuation() for i in range(n)]
-n = 2
+omega = AS.holomorphic_differentials_basis()[-16]
 from itertools import product
 pr = [list(range(p)) for _ in range(n)]
 for i in range(0, 30):
     for k in product(*pr):
-        v_w = i*v_x+k[0]*v_z0+k[1]*v_z1
+        v_w = i*v_x+ sum(k[i]*v_z[i] for i in range(n))
         if (v_w < - AS.exponent_of_different_prim() + 10 and v_w > - AS.exponent_of_different_prim()):
             w = as_function(AS, x^i * prod(z[i1]^(k[i1]) for i1 in range(n)))
-            tr_wz = (zvee*w).trace()
+            result = as_form(AS, 0)
-            val = tr_wz.expansion_at_infty().valuation()
+            for g in G:
-            #val *= p^2
+                component = ith_magical_component(omega, zvee, g).form
-            #print(val)
+                result += as_form(AS, w.group_action(g).function*component)
+            print(result.expansion_at_infty().valuation(), w.expansion_at_infty().valuation() - zmag.expansion_at_infty().valuation())

sage/drafty/draft2.sage

@@ -0,0 +1,43 @@
+p = 3
+m = 1
+F = GF(p)
+Rx.<x> = PolynomialRing(F)
+f = x
+C_super = superelliptic(f, m)
+
+Rxy.<x, y> = PolynomialRing(F, 2)
+f1 = superelliptic_function(C_super, x^7)
+f2 = superelliptic_function(C_super, x^4)
+AS = as_cover(C_super, [f1, f2], prec=1000)
+print(AS.uniformizer())
+
+def rep_jumps(AS, threshold = 30):
+    ile = 1
+    i = 1
+    result = []
+    flag = 0
+    while(flag == 0):
+        if len(AS.at_most_poles(i, threshold = threshold)) > ile:
+            ile = len(AS.at_most_poles(i, threshold = threshold))
+            result += [i]
+            if i%p != 0:
+                flag = 1
+        i+=1
+    return result
+
+#print(rep_jumps(AS, threshold = 30))
+
+def uniformizer(AS, threshold = 30):
+    p = AS.characteristic
+    n = AS.height
+    variable_names = 'x, y'
+    for i in range(n):
+        variable_names += ', z' + str(i)
+    Rxyz = PolynomialRing(F, n+2, variable_names)
+    x, y = Rxyz.gens()[:2]
+    z = Rxyz.gens()[2:]
+    zmag = AS.magical_element()[0]
+    v_x = as_function(AS, x).expansion_at_infty().valuation()
+    dprim = AS.exponent_of_different_prim()
+    d, a, b = xgcd(v_x, -dprim)
+    return as_function(AS, x^a*zmag.function^b)

sage/drafty/draft3.sage

@@ -0,0 +1,7 @@
+Rx.<x> = PolynomialRing(GF(5))
+C = superelliptic(x^3 + 1, 2)
+Rxy.<x, y> = PolynomialRing(GF(5), 2)
+f1 = superelliptic_function(C, x*y)
+CAS = as_cover(C, [f1])
+g = CAS.uniformizer()
+AA = g

sage/init.sage

@@ -12,3 +12,7 @@ load('as_covers/combination_components.sage')
 load('as_covers/group_action_matrices.sage')
 load('auxilliaries/reverse.sage')
 load('auxilliaries/hensel.sage')
+##############
+##############
+load('drafty/draft2.sage')
+#load('drafty/draft3.sage')

sage/tests.sage

@@ -4,5 +4,11 @@
 #load('as_covers/tests/group_action_matrices_test.sage')
 #print("dual_element_test:")
 #load('as_covers/tests/dual_element_test.sage')
-print("ith_component_test:")
+#print("ith_component_test:")
-load('as_covers/tests/ith_component_test.sage')
+#load('as_covers/tests/ith_component_test.sage')
+#print("ith ramification group test:")
+#load('as_covers/tests/ith_ramification_gp_test.sage')
+#print("uniformizer test:")
+#load('as_covers/tests/uniformizer_test.sage')
+print("ramification jumps test:")
+load('as_covers/tests/ramification_jumps_test.sage')