added possibility of substituting x, y and template of a wrong hypoelementary action

as_covers/as_cover_class.sage

@@ -21,7 +21,7 @@ class as_cover:
         self.branch_points = list(range(delta)) + branch_points
         Rxy.<x, y> = PolynomialRing(F, 2)
         Rt.<t> = LaurentSeriesRing(F, default_prec=prec)
-        Rzf, zgen, fgen = cover_template.fct_field
+        Rzf, zgen, fgen, xgen, ygen = cover_template.fct_field
         all_x_series = {}
         all_y_series = {}
         all_z_series = {}
@@ -73,8 +73,8 @@ class as_cover:
         self.z = [as_function(self, z[j]) for j in range(n)]
         self.dx = as_form(self, 1)
         self.one = as_function(self, 1)
-        Rzf, zgen, fgen = cover_template.fct_field
+        Rzf, zgen, fgen, xgen, ygen = cover_template.fct_field
-        subs_fs = {zgen[i] : z[i]}| {fgen[i] : RxyzQ(list_of_fcts[i].function) for i in range(n)}
+        subs_fs = {zgen[i] : z[i]}| {fgen[i] : RxyzQ(list_of_fcts[i].function) for i in range(n)}|{xgen:x, ygen:y}
         self.rhs = [RxyzQ(cover_template.fcts[i].subs(subs_fs)) for i in range(n)]
         #####
         ##### We compute now the differentials dz[i]

as_covers/as_form_class.sage

@@ -88,8 +88,10 @@ class as_form:
         # We need to have only polynomials to use monomial_coefficients in linear_representation_polynomials,
         # and sometimes basis elements have denominators. Thus we multiply by them.
         denom = LCM([denominator(omega.form) for omega in basis])
+        print(denom, basis, '\n')
         basis = [denom*omega for omega in basis]
         self_with_no_denominator = denom*self
+        print(self_with_no_denominator.form, [omega.form for omega in basis])
         return linear_representation_polynomials(Rxyz(self_with_no_denominator.form), [Rxyz(omega.form) for omega in basis])
 
     def trace(self, super=True):

as_covers/as_function_class.sage

@@ -104,7 +104,7 @@ class as_function:
     def group_action(self, elt):
         C = self.curve
         RxyzQ, Rxyz, x, y, z = C.fct_field
-        Rzf, zgen, fgen = C.cover_template.fct_field
+        Rzf, zgen, fgen, xgen, ygen = C.cover_template.fct_field
         if isinstance(elt, group_elt):
             elt = elt.as_tuple
         AS = self.curve
@@ -114,8 +114,8 @@ class as_function:
         if elt in G.gens:
             ind = G.gens.index(elt)
             gp_action_list = C.cover_template.gp_action[ind]
-            sub_list_gen = {zgen[i] : RxyzQ(z[i]) for i in range(n)}|{fgen[i] : RxyzQ(AS.functions[i].function) for i in range(n)}
+            sub_list_gen = {zgen[i] : RxyzQ(z[i]) for i in range(n)}|{fgen[i] : RxyzQ(AS.functions[i].function) for i in range(n)}|{xgen:x}|{ygen:y}
-            sub_list = {x : RxyzQ(x), y : RxyzQ(y)} | {z[j] : RxyzQ(gp_action_list[j].subs(sub_list_gen)) for j in range(n)}
+            sub_list = {x : RxyzQ(gp_action_list[-2]), y : RxyzQ(gp_action_list[-1])} | {z[j] : RxyzQ(gp_action_list[j].subs(sub_list_gen)) for j in range(n)}
             g = self.function
             return as_function(C, g.substitute(sub_list))
         result = self

as_covers/group.sage

@@ -122,4 +122,22 @@ def quaternion_gp():
     gens = [(1, 0), (0, 1)]
     one = (0, 0)
     gp = group(name, short_name, elts, one, mult, inv, gens)
+    return gp
+
+def hypoelementary_mult(p, m, b, A, B, C, D):
+    return ((A+C)%m, (b^C*B+D)%p)
+
+def hypoelementary_inv(p, m, b, A, B):
+    return hypoelementary_mult(p, m, b, 0, p-B, m - A, 0)
+
+def hypoelementary(p, m, b):
+    '''We want m | p-1 and b to be of order m in F_p.'''
+    name = "Hypoelementary group Z/"+str(p)+"⋊ Z/"+str(m)+", glued by character 1 -->" + str(b)
+    short_name = "Z/"+str(p)+"⋊ Z/"+str(m)
+    elts = [(i, j) for i in range(m) for j in range(p)]
+    mult = lambda elt1, elt2: hypoelementary_mult(p, m, b, elt1[0], elt1[1], elt2[0], elt2[1])
+    inv = lambda elt1 : hypoelementary_inv(p, m, b, elt1[0], elt1[1])
+    gens = [(1, 0), (0, 1)]
+    one = (0, 0)
+    gp = group(name, short_name, elts, one, mult, inv, gens)
     return gp

as_covers/template.sage

@@ -10,14 +10,15 @@ class template:
         for i in range(n):
             variable_names += 'z'+str(i)+','
         for i in range(n):
-            variable_names += 'f'+str(i)
+            variable_names += 'f'+str(i)+','
-            if i!=n-1:
+        variable_names += 'x, y'
-                variable_names += ','
+        Rzf = PolynomialRing(field, 2*n+2, variable_names)
-        Rzf = PolynomialRing(field, 2*n, variable_names)
         z = Rzf.gens()[:n]
         f = Rzf.gens()[n:]
+        x = Rzf.gens()[-2]
+        y = Rzf.gens()[-1]
         RzfQ = FractionField(Rzf) #nowa linijka
-        self.fct_field = RzfQ, z, f #Rzf zmienione na RzfQ
+        self.fct_field = RzfQ, z, f, x, y #Rzf zmienione na RzfQ
         self.fcts = [RzfQ(ff) for ff in fcts] #RHSs of the Artin-Schreier equations
 
 def elementary_template(p, n):
@@ -27,15 +28,16 @@ def elementary_template(p, n):
     for i in range(n):
         variable_names += 'z'+str(i)+','
     for i in range(n):
-        variable_names += 'f'+str(i)
+        variable_names += 'f'+str(i) + ','
-        if i!=n-1:
+    variable_names += 'x, y'        
-            variable_names += ','
+    R = PolynomialRing(field, 2*n+2, variable_names)
-    R = PolynomialRing(field, 2*n, variable_names)
     z = R.gens()[:n]
     f = R.gens()[n:]
+    x = R.gens()[-2]
+    y = R.gens()[-1]
     height = n
     fcts = [f[i] for i in range(n)]
-    gp_action = [[z[j] + (i == j) for j in range(n)] for i in range(n)]
+    gp_action = [[z[j] + (i == j) for j in range(n)]+[x, y] for i in range(n)]
     return template(height, field, group, fcts, gp_action)
 
 def elementary_cover(list_of_fcts, prec=10):
@@ -51,16 +53,17 @@ def heisenberg_template(p):
     for i in range(n):
         variable_names += 'z'+str(i)+','
     for i in range(n):
-        variable_names += 'f'+str(i)
+        variable_names += 'f'+str(i)+','
-        if i!=n-1:
+    variable_names += 'x, y'
-            variable_names += ','
+    R = PolynomialRing(field, 2*n+2, variable_names)
-    R = PolynomialRing(field, 2*n, variable_names)
     z = R.gens()[:n]
     f = R.gens()[n:]
+    x = R.gens()[-2]
+    y = R.gens()[-1]
     height = n
     fcts = [f[i] for i in range(n)]
     fcts[2] += (z[0] - z[1])*f[1]
-    gp_action = [[z[0] + 1, z[1], z[2] + z[1]], [z[0] + 1, z[1] + 1, z[2]], [z[0], z[1], z[2] - 1]]
+    gp_action = [[z[0] + 1, z[1], z[2] + z[1], x, y], [z[0] + 1, z[1] + 1, z[2], x, y], [z[0], z[1], z[2] - 1, x, y]]
     return template(height, field, group, fcts, gp_action)
 
 def heisenberg_cover(list_of_fcts, prec=10):
@@ -121,12 +124,13 @@ def witt_template(p, n):
     for i in range(n):
         variable_names += 'z'+str(i)+','
     for i in range(n):
-        variable_names += 'f'+str(i)
+        variable_names += 'f'+str(i)+','
-        if i!=n-1:
+    variable_names += 'x, y'
-            variable_names += ','
+    R = PolynomialRing(field, 2*n+2, variable_names)
-    R = PolynomialRing(field, 2*n, variable_names)
     z = R.gens()[:n]
     f = R.gens()[n:]
+    x = R.gens()[-2]
+    y = R.gens()[-1]
     ###########
     rhs = []
     gp_action = []
@@ -142,7 +146,7 @@ def witt_template(p, n):
     fcts = [-rhs[i] + z[i]^p - z[i] + f[i] for i in range(n)]
     ########
     aux
-    gp_action = [gp_action]
+    gp_action = [gp_action+[x, y]]
     return template(height, field, group, fcts, gp_action)
 
 def witt_cover(list_of_fcts, prec=10):
@@ -158,18 +162,42 @@ def quaternion_template():
     for i in range(n):
         variable_names += 'z'+str(i)+','
     for i in range(n):
-        variable_names += 'f'+str(i)
+        variable_names += 'f'+str(i)+','
-        if i!=n-1:
+    variable_names += 'x, y'
-            variable_names += ','
+    R = PolynomialRing(field, 2*n+2, variable_names)
-    R = PolynomialRing(field, 2*n, variable_names)
     z = R.gens()[:n]
     f = R.gens()[n:]
+    x = R.gens()[-2]
+    y = R.gens()[-1]
     group = quaternion_gp()
     fcts = [f[0], f[1], f[2] + z[0]*f[0]+z[1]*(f[0] + f[1])]
-    gp_action = [[z[0]+1, z[1], z[2] + z[0]], [z[0], z[1] + 1, z[2] + z[1] + z[0]]]
+    gp_action = [[z[0]+1, z[1], z[2] + z[0], x, y], [z[0], z[1] + 1, z[2] + z[1] + z[0], x, y]]
     return template(height, field, group, fcts, gp_action)
 
 def quaternion_cover(list_of_fcts, prec=10):
     n = len(list_of_fcts)
     C = list_of_fcts[0].curve
-    return as_cover(C, quaternion_template(), list_of_fcts, branch_points = [], prec = prec)
+    return as_cover(C, quaternion_template(), list_of_fcts, branch_points = [], prec = prec)
+
+def hypoelementary_template(p, m, b, zeta):
+    '''unfinished'''
+    field = GF(p)
+    height = 1
+    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]
+    group = hypoelementary(p, m, b)
+    fcts = [1/(zeta - b)*f[0]^p*z[0]^p - 1/(zeta - b)*f[0]*z[0]
+    gp_action = []
+    gp_action += [b*z[0]+f[0]*y, x, zeta*y]
+    gp_action += [z[0]+1, x, y]
+    return template(height, field, group, fcts, gp_action)