praca nad as_cech coordinate; przed poprawa drugiej czesci

sage/as_covers/as_cech_class.sage

@@ -12,6 +12,9 @@ class as_cech:
         RxyzQ = FractionField(Rxyz)
         self.omega0 = omega
         self.f = f
+        self.omega8 = self.omega0 - self.f.diffn()
+        if self.omega0.form not in Rxyz or self.omega8.valuation() < 0:
+            raise ValueError('cech cocycle not regular')
 
     def __repr__(self):
         return "( " + str(self.omega0)+", " + str(self.f) + " )"
@@ -41,6 +44,7 @@ class as_cech:
     def coordinates(self, threshold=10, basis = 0):
         '''Find coordinates of self in the de Rham cohomology basis. Threshold is an argument passed to AS.de_rham_basis().'''
         AS = self.curve
+        RxyzQ, Rxyz, x, y, z = AS.fct_field
         if basis == 0:
             basis = [AS.holomorphic_differentials_basis(), AS.cohomology_of_structure_sheaf_basis(), AS.de_rham_basis(threshold=threshold)]
         holo_diffs = basis[0]
@@ -48,25 +52,37 @@ class as_cech:
         dR = basis[2]
         F = AS.base_ring
         f_products = []
-        for i, f in enumerate(coh_basis):
+        for f in coh_basis:
-            f_products += [[]]
+            f_products += [[omega.serre_duality_pairing(f) for omega in holo_diffs]]
-            for omega in holo_diffs:
+        print(f_products)
-                f_products[i] += [sum((f*omega).residue(place = _) for _ in range(AS.nb_of_pts_at_infty))]
-
         product_of_fct_and_omegas = []
         fct = self.f
-        for omega in holo_diffs:
+        product_of_fct_and_omegas = [omega.serre_duality_pairing(fct) for omega in holo_diffs]
-                product_of_fct_and_omegas += [sum((fct*omega).residue(place = _) for _ in range(AS.nb_of_pts_at_infty))]
 
         V = (F^(AS.genus())).span_of_basis([vector(a) for a in f_products])
         coh_coordinates = V.coordinates(product_of_fct_and_omegas) #coeficients of self in the basis elts coming from cohomology of OX
         for i in range(AS.genus()):
             self -= coh_coordinates[i]*dR[i+AS.genus()]
-
+        #We remove now from f the summands which are obviously regular at infty
-        hol_form = self.omega0 + self.f.diffn() #now this should be a holomorphic form
+        print(self, [])
-        hol_form = hol_form
+        f_num = numerator(self.f.function)
-        print(hol_form)
+        f_den = denominator(self.f.function)
-        return hol_form.coordinates() + coh_coordinates
+        v_f_den = as_function(AS, f_den).valuation()
+        for a in f_num.monomials():
+            if as_function(AS, a).valuation() >= v_f_den:
+                self.f.function -= f_num.monomial_coefficient(a)*a/f_den
+        f_num = numerator(self.f.function)
+        f_den = denominator(self.f.function)
+        quo, rem = f_num.quo_rem(f_den)
+        if as_function(AS, rem/f_den).valuation() >= 0:
+            self.f = as_function(AS, quo)
+            hol_form = self.omega0 - self.f.diffn() #now this should be a holomorphic form
+            hol_form = as_form(AS, as_reduction(AS, hol_form.form))
+            print('hol_form', hol_form)
+            return hol_form.coordinates() + coh_coordinates
+        print(self, [omega.serre_duality_pairing(self.f) for omega in holo_diffs])
+        raise ValueError('I arrived at a form (omega, 0), in which omega is not regular on U0. I hoped this wouldn t happen.')
+        
     
     def group_action(self, g):
         AS = self.curve

sage/as_covers/as_cover_class.sage

@@ -54,10 +54,10 @@ class as_cover:
             all_z_series += [z_series]
             all_dx_series += [x_series.derivative()]
         self.jumps = all_jumps
-        self.x = all_x_series
+        self.x_series = all_x_series
-        self.y = all_y_series
+        self.y_series = all_y_series
-        self.z = all_z_series
+        self.z_series = all_z_series
-        self.dx = all_dx_series
+        self.dx_series = all_dx_series
         ##############
         #Function field
         variable_names = 'x, y'
@@ -68,6 +68,11 @@ class as_cover:
         z = Rxyz.gens()[2:]
         RxyzQ = FractionField(Rxyz)
         self.fct_field = (RxyzQ, Rxyz, x, y, z)
+        self.x = as_function(self, x)
+        self.y = as_function(self, y)
+        self.z = [as_function(self, z[i]) for i in range(n)]
+        self.dx = as_form(self, 1)
+        
         
     def __repr__(self):
         n = self.height
@@ -104,10 +109,10 @@ class as_cover:
     
     def holomorphic_differentials_basis(self, threshold = 8):
         from itertools import product
-        x_series = self.x
+        x_series = self.x_series
-        y_series = self.y
+        y_series = self.y_series
-        z_series = self.z
+        z_series = self.z_series
-        dx_series = self.dx
+        dx_series = self.dx_series
         delta = self.nb_of_pts_at_infty
         p = self.characteristic
         n = self.height
@@ -145,9 +150,9 @@ class as_cover:
         """ Find fcts with pole order in infty's at most pole_order. 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
+        x_series = self.x_series
-        y_series = self.y
+        y_series = self.y_series
-        z_series = self.z
+        z_series = self.z_series
         delta = self.nb_of_pts_at_infty
         p = self.characteristic
         n = self.height
@@ -197,9 +202,9 @@ class as_cover:
         """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.
            If you suspect that you haven't found all the functions, you may increase it."""
         from itertools import product
-        x_series = self.x
+        x_series = self.x_series
-        y_series = self.y
+        y_series = self.y_series
-        z_series = self.z
+        z_series = self.z_series
         delta = self.nb_of_pts_at_infty
         p = self.characteristic
         n = self.height
@@ -297,9 +302,9 @@ class as_cover:
     def cohomology_of_structure_sheaf_basis(self, threshold = 8):
         holo_diffs = self.holomorphic_differentials_basis(threshold = threshold)
         from itertools import product
-        x_series = self.x
+        x_series = self.x_series
-        y_series = self.y
+        y_series = self.y_series
-        z_series = self.z
+        z_series = self.z_series
         delta = self.nb_of_pts_at_infty
         p = self.characteristic
         n = self.height
@@ -321,9 +326,7 @@ class as_cover:
             for j in range(0, m):
                 for k in product(*pr):
                     f = as_function(self, prod(z[i1]^(k[i1]) for i1 in range(n))/x^i*y^j)
-                    f_products = []
+                    f_products = [omega.serre_duality_pairing(f) for omega in holo_diffs]
-                    for omega in holo_diffs:
-                        f_products += [sum((f*omega).residue(place = _) for _ in range(self.nb_of_pts_at_infty))]
                     if vector(f_products) not in S:
                         S = S+V.subspace([V(f_products)])
                         result_fcts += [f]
@@ -334,10 +337,10 @@ class as_cover:
         '''Given function fct, find form eta regular on affine part such that eta - d(fct) is regular in infty. (Works for one place at infty now)'''
         print(fct)
         from itertools import product
-        x_series = self.x
+        x_series = self.x_series
-        y_series = self.y
+        y_series = self.y_series
-        z_series = self.z
+        z_series = self.z_series
-        dx_series = self.dx
+        dx_series = self.dx_series
         delta = self.nb_of_pts_at_infty
         p = self.characteristic
         n = self.height
@@ -363,8 +366,8 @@ class as_cover:
             raise ValueError("Increase threshold!")
         for omega in forms:
             for a in F:
-                if (a*omega - fct.diffn()).form in Rxyz:
+                if (a*omega + fct.diffn()).form in Rxyz:
-                    return a*omega
+                    return a*omega + fct.diffn()
         raise ValueError("Unknown.")
 
     def de_rham_basis(self, threshold = 30):

sage/as_covers/as_form_class.sage

@@ -19,10 +19,10 @@ class as_form:
         C = self.curve
         delta = C.nb_of_pts_at_infty
         F = C.base_ring
-        x_series = C.x[i]
+        x_series = C.x_series[i]
-        y_series = C.y[i]
+        y_series = C.y_series[i]
-        z_series = C.z[i]
+        z_series = C.z_series[i]
-        dx_series = C.dx[i]
+        dx_series = C.dx_series[i]
         n = C.height
         variable_names = 'x, y'
         for j in range(n):
@@ -57,14 +57,7 @@ class as_form:
     def group_action(self, ZN_tuple):
         C = self.curve
         n = C.height
-        F = C.base_ring
+        RxyzQ, Rxyz, x, y, z = C.fct_field
-        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:]
-        RxyzQ = FractionField(Rxyz)
         sub_list = {x : x, y : y} | {z[j] : z[j]+ZN_tuple[j] for j in range(n)}
         g = self.form
         return as_form(C, g.substitute(sub_list))
@@ -80,6 +73,7 @@ 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(self_with_no_denominator, basis)
         return linear_representation_polynomials(Rxyz(self_with_no_denominator.form), [Rxyz(omega.form) for omega in basis])
 
     def trace(self):
@@ -110,6 +104,10 @@ class as_form:
     def valuation(self, place=0):
         return self.expansion_at_infty(i = place).valuation()
 
+    def serre_duality_pairing(self, fct):
+        AS = self.curve
+        return sum((fct*self).residue(place = _) for _ in range(AS.nb_of_pts_at_infty))
+    
 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

sage/as_covers/as_function_class.sage

@@ -60,9 +60,9 @@ class as_function:
         C = self.curve
         delta = C.nb_of_pts_at_infty
         F = C.base_ring
-        x_series = C.x[i]
+        x_series = C.x_series[i]
-        y_series = C.y[i]
+        y_series = C.y_series[i]
-        z_series = C.z[i]
+        z_series = C.z_series[i]
         n = C.height
         variable_names = 'x, y'
         for j in range(n):