as transform for unramified points fixed

as_covers/as_form_class.sage

@@ -176,49 +176,6 @@ class as_form:
             return True
         return False
 
-def artin_schreier_transform(power_series, prec = 10):
-    """Given a power_series, find correction such that power_series - (correction)^p +correction has valuation
-       -jump non divisible by p. Also, express t (the variable) in terms of the uniformizer at infty on the curve
-       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:
-        raise ValueError("Precision is too low.")
-    if power_series.valuation() >= 0:
-        # THIS IS WRONG - THERE ARE SEVERAL PLACES OVER THIS PLACE, AND IT DEPENDS
-        aux = t^p - t
-        z = new_reverse(aux, prec = prec)
-        z = z(t = power_series)
-        return(0, 0, t, z)
-    
-    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
-        correction += coeff.nth_root(p)*t^(-M)
-        power_series = power_series - (coeff*t^(-p*M) - coeff.nth_root(p)*t^(-M))
-    jump = max(-(power_series.valuation()), 0)
-    try:
-        if jump != 0:
-            T = nth_root2((power_series)^(-1), jump, prec=prec) #T is defined by power_series = 1/T^m
-    except:
-        print("no ", str(jump), "-th root; divide by", power_series.list()[0])
-        return (jump, power_series.list()[0])
-    if jump != 0:
-        T_rev = new_reverse(T, prec = prec)
-        t_old = T_rev(t^p/nth_root2(1 - t^((p-1)*jump), jump, prec=prec))
-        z = 1/t^(jump) + Rt(correction)(t = t_old)
-        return(jump, correction, t_old, z)
-    if jump == 0:
-        aux = t^p - t
-        z = new_reverse(aux, prec = prec)
-        z = z(t = power_series)
-        return(0, correction, t, z)
-
-
 def are_forms_linearly_dependent(set_of_forms):
     from sage.rings.polynomial.toy_variety import is_linearly_dependent
     C = set_of_forms[0].curve

as_covers/as_transform.sage

@@ -0,0 +1,45 @@
+def artin_schreier_transform(power_series, prec = 10):
+    """Given a power_series, find correction such that power_series - (correction)^p +correction has valuation
+       -jump non divisible by p. Also, express t (the variable) in terms of the uniformizer at infty on the curve
+       z^p - z = power_series, where z = 1/t_new^(jump) and express z in terms of the new uniformizer."""
+    print('as transform for ', power_series)
+    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:
+        raise ValueError("Precision is too low.")
+    if power_series.valuation() >= 0:
+        # THIS IS WRONG - THERE ARE SEVERAL PLACES OVER THIS PLACE, AND IT DEPENDS
+        aux = t^p - t
+        z = new_reverse(aux, prec = prec)
+        z = z(t = power_series)
+        print("a")
+        return(0, 0, t, z)
+    
+    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
+        correction += coeff.nth_root(p)*t^(-M)
+        power_series = power_series - (coeff*t^(-p*M) - coeff.nth_root(p)*t^(-M))
+    jump = max(-(power_series.valuation()), 0)
+    try:
+        if jump != 0:
+            T = nth_root2((power_series)^(-1), jump, prec=prec) #T is defined by power_series = 1/T^m
+    except:
+        print("no ", str(jump), "-th root; divide by", power_series.list()[0])
+        return (jump, power_series.list()[0])
+    if jump != 0:
+        T_rev = new_reverse(T, prec = prec)
+        t_old = T_rev(t^p/nth_root2(1 - t^((p-1)*jump), jump, prec=prec))
+        z = 1/t^(jump) + Rt(correction)(t = t_old)
+        return(jump, correction, t_old, z)
+    if jump == 0:
+        aux = t^p - t
+        z = new_reverse(aux, prec = prec)
+        z = z(t = power_series)
+        z = z + correction
+        print('corr', correction, 'ps', power_series, 'z', z)
+        return(0, correction, t, z)

drafty/draft2.sage

@@ -1,12 +1,13 @@
 p = 3
-F = GF(3^2, 'a')
+F = GF(3)
+#F.<a> = GF(3^2)
 Rx.<x> = PolynomialRing(F)
 P1 = superelliptic(x^2 + 1, 2)
 fct1 = (P1.x)^2
-fct2 = fct1 + (P1.x)/(P1.y - P1.x)
+fct2 = (fct1 + P1.one/(P1.y - P1.x))
-fct3 = (P1.x)^4
+fct3 = 0*P1.x
-C = heisenberg_cover(P1, [1/2*fct1, fct2, fct3], prec=500)
+C = heisenberg_cover(P1, [fct1, fct2, fct3], prec=200)
-print(C)
+print(C, '\n', C.genus(), '\n', C.jumps)
-B = C.holomorphic_differentials_basis()
+#B = C.holomorphic_differentials_basis()
 #print("Computed basis")
 #a1, b1, c1 = heisenberg_group_action_matrices_holo(C, basis = B)

heisenberg_covers/heisenberg_covers.sage

@@ -194,9 +194,11 @@ class heisenberg_cover:
 
         forms = holomorphic_combinations_fcts(S, pole_order)
 
-        for i in range(1, delta):
+        for i in range(delta):
-            forms = [(omega, omega.expansion_at_infty(place = i)) for omega in forms]
+            for g in [(0, i, 0) for i in range(p)]:
-            forms = holomorphic_combinations_fcts(forms, pole_order)
+                if i!=0 or g != (0, 0, 0):
+                    forms = [(omega, omega.expansion_at_infty(place = i)) for omega in forms]
+                    forms = holomorphic_combinations_fcts(forms, pole_order)
                   
         return forms
     
@@ -217,7 +219,7 @@ class heisenberg_cover:
         return result
 
     def at_most_poles_forms(self, pole_order, threshold = 8):
-        """Find forms with pole order in all the points at infty equat at most to pole_order. Threshold gives a bound on powers of x in the form.
+        """Find forms with pole order in all the points at infty equal at most to pole_order. Threshold gives a bound on powers of x in the form.
            If you suspect that you haven't found all the functions, you may increase it."""
         from itertools import product
         x_series = self.x_series
@@ -405,6 +407,75 @@ class heisenberg_cover:
             result += [heisenberg_cech(self, omega, f)]
         return result
     
+    def stabilizer(self, place = 0):
+        result = []
+        for g in self.group:
+            flag = 1
+            for i in range(self.height):
+                if self.z[i].valuation(place = place) > 0:
+                    fct = self.z[i]
+                elif self.z[i].valuation(place = place) < 0:
+                    fct = self.one/self.z[i]
+                if fct.group_action(g).valuation(place = place) <= 0:
+                    flag = 0
+            if flag:
+                result += [g]
+        return result
+    
+    def stabilizer_coset_reps(self, place = 0):
+        result = [(0, 0, 0)]
+        p = self.characteristic
+        H = self.stabilizer(place = place)
+        for g in self.group:
+            flag = 1
+            for v in result:
+                if heisenberg_mult(g, heisenberg_inv(v, p), p) in H:
+                    flag = 0
+            if flag:
+                result += [g]
+        return result
+    
+##############
+def at_most_poles2(self, pole_orders, threshold = 8):
+    """ Find fcts with pole order in infty's at most pole_order from the given dictionary. The keys of the dictionary are pairs (place_at_infty, group element). The items are the poles orders at those places.
+    Threshold gives a bound on powers of x in the function. If you suspect that you haven't found all the functions, you may increase it."""
+    from itertools import product
+    x_series = self.x_series
+    y_series = self.y_series
+    z_series = self.z_series
+    delta = self.nb_of_pts_at_infty
+    p = self.characteristic
+    n = self.height
+    prec = self.prec
+    C = self.quotient
+    F = self.base_ring
+    m = C.exponent
+    r = C.polynomial.degree()
+    RxyzQ, Rxyz, x, y, z = self.fct_field
+    F = C.base_ring
+    Rt.<t> = LaurentSeriesRing(F, default_prec=prec)
+    #Tworzymy zbiór S form z^i x^j y^k dx/y o waluacji >= waluacja z^(p-1)*dx/y
+    S = []
+    RQxyz = FractionField(Rxyz)
+    pr = [list(GF(p)) for _ in range(n)]
+    for i in range(0, threshold*r):
+        for j in range(0, m):
+            for k in product(*pr):
+                eta = heisenberg_function(self, x^i * prod(z[i1]^(k[i1]) for i1 in range(n))*y^j)
+                eta_exp = eta.expansion_at_infty()
+                S += [(eta, eta_exp)]
+
+    forms = holomorphic_combinations_fcts(S, pole_orders[(0, (0, 0, 0))])
+
+    for i in range(delta):
+        for g in self.stabilizer_coset_reps(place = i):
+            if i!=0 or g != (0, 0, 0):
+                forms = [(omega, omega.expansion_at_infty(place = i)) for omega in forms]
+                forms = holomorphic_combinations_fcts(forms, pole_orders[(i, g)])
+    return forms
+##############
+    
+    
 def heisenberg_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

heisenberg_covers/heisenberg_form_class.sage

@@ -201,48 +201,6 @@ class heisenberg_form:
             return True
         return False
 
-def artin_schreier_transform(power_series, prec = 10):
-    """Given a power_series, find correction such that power_series - (correction)^p +correction has valuation
-       -jump non divisible by p. Also, express t (the variable) in terms of the uniformizer at infty on the curve
-       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:
-        raise ValueError("Precision is too low.")
-    if power_series.valuation() >= 0:
-        # THIS IS WRONG - THERE ARE SEVERAL PLACES OVER THIS PLACE, AND IT DEPENDS
-        aux = t^p - t
-        z = new_reverse(aux, prec = prec)
-        z = z(t = power_series)
-        return(0, 0, t, z)
-    
-    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
-        correction += coeff.nth_root(p)*t^(-M)
-        power_series = power_series - (coeff*t^(-p*M) - coeff.nth_root(p)*t^(-M))
-    jump = max(-(power_series.valuation()), 0)
-    try:
-        if jump != 0:
-            T = nth_root2((power_series)^(-1), jump, prec=prec) #T is defined by power_series = 1/T^m
-    except:
-        print("no ", str(jump), "-th root; divide by", power_series.list()[0])
-        return (jump, power_series.list()[0])
-    if jump != 0:
-        T_rev = new_reverse(T, prec = prec)
-        t_old = T_rev(t^p/nth_root2(1 - t^((p-1)*jump), jump, prec=prec))
-        z = 1/t^(jump) + Rt(correction)(t = t_old)
-        return(jump, correction, t_old, z)
-    if jump == 0:
-        aux = t^p - t
-        z = new_reverse(aux, prec = prec)
-        z = z(t = power_series)
-        return(0, correction, t, z)
-
 def are_forms_linearly_dependent(set_of_forms):
     from sage.rings.polynomial.toy_variety import is_linearly_dependent
     C = set_of_forms[0].curve

init.sage

@@ -3,6 +3,7 @@ load('superelliptic/superelliptic_function_class.sage')
 load('superelliptic/superelliptic_form_class.sage')
 load('superelliptic/superelliptic_cech_class.sage')
 load('superelliptic/frobenius_kernel.sage')
+load('as_covers/as_transform.sage')
 load('as_covers/as_cover_class.sage')
 load('as_covers/as_function_class.sage')
 load('as_covers/as_form_class.sage')
@@ -43,6 +44,9 @@ load('heisenberg_covers/heisenberg_form_class.sage')
 load('heisenberg_covers/heisenberg_polyforms.sage')
 load('heisenberg_covers/heisenberg_reduction.sage')
 load('heisenberg_covers/heisenberg_group_action_matrices.sage')
+load('heisenberg_covers/dual_element.sage')
+load('heisenberg_covers/ith_magical_component.sage')
+load('heisenberg_covers/heisenberg_group.sage')
 ##############
 ##############
 def init(lista, tests = False, init=True):

quaternion_covers/quaternion_form_class.sage

@@ -195,49 +195,6 @@ class quaternion_form:
             return True
         return False
 
-def artin_schreier_transform(power_series, prec = 10):
-    """Given a power_series, find correction such that power_series - (correction)^p +correction has valuation
-       -jump non divisible by p. Also, express t (the variable) in terms of the uniformizer at infty on the curve
-       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:
-        raise ValueError("Precision is too low.")
-    if power_series.valuation() >= 0:
-        # THIS IS WRONG - THERE ARE SEVERAL PLACES OVER THIS PLACE, AND IT DEPENDS
-        aux = t^p - t
-        z = new_reverse(aux, prec = prec)
-        z = z(t = power_series)
-        return(0, 0, t, z)
-    
-    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
-        correction += coeff.nth_root(p)*t^(-M)
-        power_series = power_series - (coeff*t^(-p*M) - coeff.nth_root(p)*t^(-M))
-    jump = max(-(power_series.valuation()), 0)
-    try:
-        if jump != 0:
-            T = nth_root2((power_series)^(-1), jump, prec=prec) #T is defined by power_series = 1/T^m
-    except:
-        print("no ", str(jump), "-th root; divide by", power_series.list()[0])
-        return (jump, power_series.list()[0])
-    if jump != 0:
-        T_rev = new_reverse(T, prec = prec)
-        t_old = T_rev(t^p/nth_root2(1 - t^((p-1)*jump), jump, prec=prec))
-        z = 1/t^(jump) + Rt(correction)(t = t_old)
-        return(jump, correction, t_old, z)
-    if jump == 0:
-        aux = t^p - t
-        z = new_reverse(aux, prec = prec)
-        z = z(t = power_series)
-        return(0, correction, t, z)
-
-
 def are_forms_linearly_dependent(set_of_forms):
     from sage.rings.polynomial.toy_variety import is_linearly_dependent
     C = set_of_forms[0].curve