trying to fix superelliptic cech coordinates

as_covers/as_form_class.sage

@@ -84,7 +84,6 @@ class as_form:
     def coordinates(self, basis = 0):
         """Find coordinates of the given holomorphic form self in terms of the basis forms in a list holo."""
         self = self.reduce()
-        print(self)
         C = self.curve
         if basis == 0:
             basis = C.holomorphic_differentials_basis()
@@ -94,7 +93,6 @@ class as_form:
         denom = LCM([denominator(omega.form) for omega in basis])
         basis = [denom*omega for omega in basis]
         self_with_no_denominator = denom*self
-        print(denom, basis, self_with_no_denominator)
         return linear_representation_polynomials(Rxyz(self_with_no_denominator.form), [Rxyz(omega.form) for omega in basis])
 
     def trace(self, super=True):

drafty/mumford_curve.sage

@@ -0,0 +1,166 @@
+def mumford_gp(p):
+    '''We want m | p-1 and b to be of order m in F_p.'''
+    name = "Mumford group (Z/"+str(p)+")^2⋊ D"+str(p-1)
+    short_name = "(Z/"+str(p)+")^2 ⋊ D"+str(p-1)
+    elts = [(i, j, s, t) for i in range(p) for j in range(p) for s in range(1) for t in range(p-1)]
+    mult = lambda elt1, elt2: (0, 0, 0, 0)
+    inv = lambda elt1 : (0, 0, 0, 0)
+    gens = [(1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0,0,0,1)]
+    one = (0, 0, 0, 0)
+    gp = group(name, short_name, elts, one, mult, inv, gens)
+    return gp
+
+def mumford_template(p):
+    group = mumford_gp(p)
+    field = GF(p)
+    n = 2
+    variable_names = ''
+    for i in range(n):
+        variable_names += 'z'+str(i)+','
+    for i in range(n):
+        variable_names += 'f'+str(i) + ','
+    variable_names += 'x, y'        
+    R = PolynomialRing(field, 2*n+2, variable_names)
+    z = R.gens()[:n]
+    f = R.gens()[n:]
+    x = R.gens()[-2]
+    y = R.gens()[-1]
+    height = n
+    fcts = [x + y, x - y]
+    gp_action = [[z[j] + (i == j) for j in range(n)]+[x, y] for i in range(n)]
+    gp_action += [[z[1], z[0], -x, y]]
+    d = field(primitive_root(p))
+    gp_action += [[d*z[0], d^(-1)*z[1], 1/d*(y+x) - d*(y-x), 1/d*(y+x) + d*(y-x)]]
+    return template(height, field, group, fcts, gp_action)
+    
+def mumford_cover(p, prec=10):
+    field = GF(p)
+    R.<x> = PolynomialRing(field)
+    C = superelliptic(x^2 + 1, 2)
+    return as_cover(C, mumford_template(p), [C.x, C.x], branch_points = [], prec = prec)    
+    
+ASM = mumford_cover(3, prec = 400)
+
+
+###############
+###############
+def metacyclic_gp(p, c):
+    name = "metacyclic group Z/"+str(p)+"⋊ Z/"+str(c)
+    short_name = "Z/"+str(p)+" ⋊ Z/"+str(c)
+    elts = [(i, j) for i in range(p) for j in range(c)]
+    mult = lambda elt1, elt2: (0, 0)
+    inv = lambda elt1 : (0, 0)
+    gens = [(1, 0), (0, 1)]
+    one = (0, 0)
+    gp = group(name, short_name, elts, one, mult, inv, gens)
+    return gp
+
+def metacyclic_template(p, m, nn):
+    group = metacyclic_gp(p, m*(p-1))
+    N = Integers(m*(p-1))(p).multiplicative_order()
+    field.<a> = GF(p^N)
+    zeta = a^((p^N - 1)/((p-1)*m))
+    n = 1
+    variable_names = ''
+    for i in range(n):
+        variable_names += 'z'+str(i)+','
+    for i in range(n):
+        variable_names += 'f'+str(i) + ','
+    variable_names += 'x, y'        
+    R = PolynomialRing(field, 2*n+2, variable_names)
+    z = R.gens()[:n]
+    f = R.gens()[n:]
+    x = R.gens()[-2]
+    y = R.gens()[-1]
+    height = n
+    fcts = [x]
+    gp_action = [[z[j] + (i == j) for j in range(n)]+[x, y] for i in range(n)]
+    gp_action += [[zeta^m * z[0], zeta^m * x, zeta * y]]
+    return template(height, field, group, fcts, gp_action)
+    
+def metacyclic_cover(p, m, nn, prec=10):
+    N = Integers(m*(p-1))(p).multiplicative_order()
+    field.<a> = GF(p^N)
+    R.<x> = PolynomialRing(field)
+    C = superelliptic(sum(x^(p^i) for i in range(0, nn)), m)
+    return as_cover(C, metacyclic_template(p, m, nn), [C.x], branch_points = [], prec = prec)
+
+p = 3
+m = 2
+nn = 2
+N = Integers(m*(p-1))(p).multiplicative_order()
+field.<a> = GF(p^N)
+zeta = a^((p^N - 1)/((p-1)*m))
+AS = metacyclic_cover(p, m, nn, prec=100)
+Bh = AS.holomorphic_differentials_basis(threshold = 30)
+Bs = AS.cohomology_of_structure_sheaf_basis(threshold = 30)
+BdR = AS.de_rham_basis(threshold = 30)
+print(Bh[2].group_action((1, 0)).coordinates(basis = Bh))
+
+
+#H = CyclicPermutationGroup(4)
+
+#alpha = PermutationGroupMorphism(A,A,[A.gens()[0]^3*A.gens()[1],A.gens()[1]])
+
+#phi = [[(1,2)],[alpha]]
+
+p = 3
+m = 2
+nn = 2
+N = Integers(m*(p-1))(p).multiplicative_order()
+field.<a> = GF(p^N)
+zeta = a^((p^N - 1)/((p-1)*m))
+
+def gp_action(fct, elt):
+    if elt == (1, 0):
+        if isinstance(fct, superelliptic_function):
+            f = fct.function
+            C = fct.curve
+            Fxy, Rxy, x, y = C.fct_field
+            f = f.subs({x: x+1, y: y})
+            return superelliptic_function(C, f)
+
+        if isinstance(fct, superelliptic_form):
+            f = fct.form
+            C = fct.curve
+            Fxy, Rxy, x, y = C.fct_field
+            f = f.subs({x: x+1, y: y})
+            return superelliptic_form(C, f)
+
+        if isinstance(fct, superelliptic_cech):
+            omega = fct.omega0
+            ff = fct.f
+            C = fct.curve
+            return superelliptic_cech(C, gp_action(omega, elt), gp_action(ff, elt))
+    if elt == (0, 1):
+        if isinstance(fct, superelliptic_function):
+            f = fct.function
+            C = fct.curve
+            Fxy, Rxy, x, y = C.fct_field
+            f = f.subs({x : zeta^m*x, y:zeta*y})
+            return superelliptic_function(C, f)
+
+        if isinstance(fct, superelliptic_form):
+            f = fct.form
+            C = fct.curve
+            Fxy, Rxy, x, y = C.fct_field
+            f = f.subs({x : zeta^m*x, y:zeta*y})
+            return superelliptic_form(C, f*zeta^m)
+
+        if isinstance(fct, superelliptic_cech):
+            omega = fct.omega0
+            ff = fct.f
+            C = fct.curve
+            return superelliptic_cech(C, gp_action(omega, elt), gp_action(ff, elt))
+        
+        
+superelliptic_function.group_action = gp_action
+superelliptic_form.group_action = gp_action
+superelliptic_cech.group_action = gp_action
+
+R.<x> = PolynomialRing(field)
+C = superelliptic(x^(p^nn) - x, m)
+Bh = C.holomorphic_differentials_basis()
+Bs = C.cohomology_of_structure_sheaf_basis()
+BdR = C.de_rham_basis()
+mat = as_group_action_matrices(field, BdR, [(1, 0), (0, 1)], BdR)

superelliptic/superelliptic_cech_class.sage

@@ -38,7 +38,8 @@ class superelliptic_cech:
         Rx.<x> = PolynomialRing(F)
         return superelliptic_cech(C, superelliptic_form(C, Rx(0)), superelliptic_function(C, fct^p))
 
-    def coordinates(self):
+    def coordinates(self, basis = 0):
+        print('coord', self, self.omega8.valuation())
         C = self.curve
         F = C.base_ring
         m = C.exponent
@@ -46,7 +47,8 @@ class superelliptic_cech:
         Fx = FractionField(Rx)
         FxRy.<y> = PolynomialRing(Fx)
         g = C.genus()
-        basis = C.de_rham_basis()
+        if basis == 0:
+            basis = C.de_rham_basis()
         
         omega = self.omega0
         fct = self.f
@@ -55,6 +57,7 @@ class superelliptic_cech:
             return vector((2*g)*[0])
         
         if fct.function == Rx(0) and omega.form != Rx(0):
+            print('A')
             result = list(omega.coordinates()) + g*[0]
             result = vector([F(a) for a in result])
             return result
@@ -66,9 +69,11 @@ class superelliptic_cech:
         for i in range(g, 2*g):
             aux -= coord[i]*basis[i]
         aux_f = decomposition_g0_g8(aux.f)[0]
+        print('aux_f', aux_f, 'aux.f', aux.f)
         aux.omega0 -= aux_f.diffn()
         aux.f = 0*C.x
         aux.omega8 = aux.omega0
+        print('B', aux)
         return coord + aux.coordinates()
     
     def is_cocycle(self):

superelliptic/superelliptic_class.sage

@@ -92,27 +92,37 @@ class superelliptic:
         f = self.polynomial
         m = self.exponent
         r = f.degree()
+        genus = self.genus()
         delta = GCD(r, m)
         F = self.base_ring
         Rx.<x> = PolynomialRing(F)
         Rxy.<x, y> = PolynomialRing(F, 2)
         Fxy = FractionField(Rxy)
         basis_holo = self.holomorphic_differentials_basis()
-        basis = []
+        basis = 2*genus*[0]
+        index = 0
         #First g_X elements of basis are holomorphic differentials.
         for k in range(0, len(basis_holo)):
-            basis += [superelliptic_cech(self, basis_holo[k], superelliptic_function(self, 0))]
+            basis[index] = superelliptic_cech(self, basis_holo[k], superelliptic_function(self, 0))
+            index += 1
 
         ## Next elements do not come from holomorphic differentials.
         t = len(basis)
         degrees0 = {}
         degrees1 = {}
+        degrees = self.degrees_holomorphic_differentials()
+        degrees_inv = {b:a for a, b in degrees.items()}
         for j in range(1, m):
             for i in range(1, r):
                 if (r*(m-j) - m*i >= delta): 
+                    #########
+                    index = degrees_inv[(i-1, m-j)]
+                    fct = superelliptic_function(self, Fxy(m*y^(m-j)/x^i))
+                    constant = self.holomorphic_differentials_basis()[index].serre_duality_pairing(fct)
+                    #######
                     s = Rx(m-j)*Rx(x)*Rx(f.derivative()) - Rx(m)*Rx(i)*f
                     psi = Rx(cut(s, i))
-                    basis += [superelliptic_cech(self, superelliptic_form(self, Fxy(psi/y^j)), superelliptic_function(self, Fxy(m*y^(m-j)/x^i)))]
+                    basis[index+genus] = 1/constant*superelliptic_cech(self, superelliptic_form(self, Fxy(psi/y^j)), superelliptic_function(self, Fxy(m*y^(m-j)/x^i)))
                     degrees0[t] = (psi.degree(), j)
                     degrees1[t] = (-i, m-j)
                     t += 1
@@ -216,14 +226,20 @@ class superelliptic:
         r = f.degree()
         F = self.base_ring
         delta = self.nb_of_pts_at_infty
+        g = self.genus()
         Rx.<x> = PolynomialRing(F)
         Rxy.<x, y> = PolynomialRing(F, 2)
         Fxy = FractionField(Rxy)
-        basis = []
+        basis = g*[0]
+        degrees = self.degrees_holomorphic_differentials()
+        degrees_inv = {b:a for a, b in degrees.items()}
         for j in range(1, m):
             for i in range(1, r):
-                if (r*(m-j) - m*i >= delta): 
+                if (r*(m-j) - m*i >= delta):
-                    basis += [superelliptic_function(self, Fxy(m*y^(m-j)/x^i))]
+                    index = degrees_inv[(i-1, m-j)]
+                    fct = superelliptic_function(self, Fxy(m*y^(m-j)/x^i))
+                    constant = self.holomorphic_differentials_basis()[index].serre_duality_pairing(fct)
+                    basis[index] = 1/constant*fct
         return basis
 
     def uniformizer(self):