class as_cover: def __init__(self, C, list_of_fcts, branch_points = [], prec = 10): self.quotient = C self.functions = list_of_fcts self.height = len(list_of_fcts) F = C.base_ring self.base_ring = F 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() delta = GCD(m, r) self.nb_of_pts_at_infty = delta self.branch_points = list(range(delta)) + branch_points Rxy. = PolynomialRing(F, 2) Rt. = LaurentSeriesRing(F, default_prec=prec) all_x_series = {} all_y_series = {} all_z_series = {} all_dx_series = {} all_jumps = {} for pt in self.branch_points: x_series = superelliptic_function(C, x).expansion(pt=pt, prec=prec) y_series = superelliptic_function(C, y).expansion(pt=pt, prec=prec) z_series = [] jumps = [] n = len(list_of_fcts) list_of_power_series = [g.expansion(pt=pt, prec=prec) for g in list_of_fcts] for j in range(n): power_series = list_of_power_series[j] jump, correction, t_old, z = artin_schreier_transform(power_series, prec = prec) x_series = x_series(t = t_old) y_series = y_series(t = t_old) z_series = [zi(t = t_old) for zi in z_series] z_series += [z] jumps += [jump] list_of_power_series = [g(t = t_old) for g in list_of_power_series] all_jumps[pt] = jumps all_x_series[pt] = x_series all_y_series[pt] = y_series all_z_series[pt] = z_series all_dx_series[pt] = x_series.derivative() self.jumps = all_jumps self.x_series = all_x_series self.y_series = all_y_series self.z_series = all_z_series self.dx_series = all_dx_series ############## #Function field 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:] 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[j]) for j in range(n)] self.dx = as_form(self, 1) self.one = as_function(self, 1) def __repr__(self): n = self.height p = self.characteristic if n==1: return "(Z/p)-cover of " + str(self.quotient)+" with the equation:\n z^" + str(p) + " - z = " + str(self.functions[0]) result = "(Z/p)^"+str(self.height)+ "-cover of " + str(self.quotient)+" with the equations:\n" for i in range(n): result += 'z' + str(i) + "^" + str(p) + " - z" + str(i) + " = " + str(self.functions[i]) + "\n" return result def genus(self): jumps = self.jumps gY = self.quotient.genus() n = self.height branch_pts = self.branch_points p = self.characteristic return p^n*gY + (p^n - 1)*(len(branch_pts) - 1) + sum(p^(n-j-1)*(jumps[pt][j]-1)*(p-1)/2 for j in range(n) for pt in branch_pts) def exponent_of_different(self, place = 0): jumps = self.jumps n = self.height delta = self.nb_of_pts_at_infty p = self.characteristic return sum(p^(n-j-1)*(jumps[place][j]+1)*(p-1) for j in range(n)) def exponent_of_different_prim(self, place = 0): jumps = self.jumps n = self.height delta = self.nb_of_pts_at_infty p = self.characteristic return sum(p^(n-j-1)*(jumps[place][j])*(p-1) for j in range(n)) def holomorphic_differentials_basis(self, threshold = 8): from itertools import product x_series = self.x_series y_series = self.y_series z_series = self.z_series dx_series = self.dx_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 Rt. = 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 = [] 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 = as_form(self, x^i * prod(z[i1]^(k[i1]) for i1 in range(n))/y^j) eta_exp = eta.expansion(pt=self.branch_points[0]) S += [(eta, eta_exp)] forms = holomorphic_combinations(S) for pt in self.branch_points[1:]: forms = [(omega, omega.expansion(pt=pt)) for omega in forms] forms = holomorphic_combinations(forms) if len(forms) < self.genus(): print("I haven't found all forms, only ", len(forms), " of ", self.genus()) return holomorphic_differentials_basis(self, threshold = threshold + 1) if len(forms) > self.genus(): raise ValueError("Increase precision.") return forms def cartier_matrix(self, prec=50): g = self.genus() F = self.base_ring M = matrix(F, g, g) for i, omega in enumerate(self.holomorphic_differentials_basis()): M[:, i] = vector(omega.cartier().coordinates()) return M def at_most_poles(self, pole_order, threshold = 8): """ 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_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. = 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 = as_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_order) for i in range(1, delta): forms = [(omega, omega.expansion_at_infty(place = i)) for omega in forms] forms = holomorphic_combinations_fcts(forms, pole_order) return forms def magical_element(self, threshold = 8): list_of_elts = self.at_most_poles(self.exponent_of_different_prim(), threshold) result = [] for a in list_of_elts: if a.trace().function != 0: result += [a] return result def pseudo_magical_element(self, threshold = 8): list_of_elts = self.at_most_poles(self.exponent_of_different(), threshold) result = [] for a in list_of_elts: if a.trace().function != 0: result += [a] 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. 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 Rt. = 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 = as_form(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_forms(S, pole_order) for pt in self.branch_points[1:]: forms = [(omega, omega.expansion(pt=pt)) for omega in forms] forms = holomorphic_combinations_forms(forms, pole_order) return forms def uniformizer(self, place = 0): '''Return uniformizer of curve self at place-th place at infinity.''' p = self.characteristic n = self.height F = self.base_ring RxyzQ, Rxyz, x, y, z = self.fct_field 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(place) vz = [zi.valuation(place) 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 F: if (z[j1]^(vz2) - b*z[j2]^(vz1)).valuation(place) > (z[j2]^(vz1)).valuation(place): 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 F: if (fx^(vzj) - b*z[j1]^(vfx)).valuation(place) > (z[j1]^(vfx)).valuation(place): 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(place), f2.valuation(place)) 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 a_number(self): g = self.genus() return g - self.cartier_matrix().rank() def cohomology_of_structure_sheaf_basis(self, holo_basis = 0, threshold = 8): if holo_basis == 0: holo_basis = self.holomorphic_differentials_basis(threshold = threshold) 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 Rt. = 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 result_fcts = [] V = VectorSpace(F,self.genus()) S = V.subspace([]) RQxyz = FractionField(Rxyz) pr = [list(GF(p)) for _ in range(n)] i = 0 while len(result_fcts) < self.genus(): 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 = [omega.serre_duality_pairing(f) for omega in holo_basis] if vector(f_products) not in S: S = S+V.subspace([V(f_products)]) result_fcts += [f] i += 1 return result_fcts def lift_to_de_rham(self, fct, threshold = 30): '''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)''' from itertools import product x_series = self.x_series y_series = self.y_series z_series = self.z_series dx_series = self.dx_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 Rt. = 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 = [(fct.diffn(), fct.diffn().expansion_at_infty())] pr = [list(GF(p)) for _ in range(n)] holo = self.holomorphic_differentials_basis(threshold = threshold) for i in range(0, threshold*r): for j in range(0, m): for k in product(*pr): eta = as_form(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(S) if len(forms) <= self.genus(): raise ValueError("Increase threshold!") for omega in forms: for a in F: if (a*omega + fct.diffn()).form in Rxyz: return a*omega + fct.diffn() raise ValueError("Unknown.") def de_rham_basis(self, holo_basis = 0, cohomology_basis = 0, threshold = 30): if holo_basis == 0: holo_basis = self.holomorphic_differentials_basis(threshold = threshold) if cohomology_basis == 0: cohomology_basis = self.cohomology_of_structure_sheaf_basis(holo_basis = holo_basis, threshold = threshold) result = [] for omega in holo_basis: result += [as_cech(self, omega, as_function(self, 0))] for f in cohomology_basis: omega = self.lift_to_de_rham(f, threshold = threshold) result += [as_cech(self, omega, f)] return result 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 p = C_AS.characteristic F = C_AS.base_ring prec = C_AS.prec Rt. = LaurentSeriesRing(F, default_prec=prec) RtQ = FractionField(Rt) minimal_valuation = min([g[1].valuation() for g in S]) if minimal_valuation >= 0: return [s[0] for s in S] list_of_lists = [] #to będzie lista złożona z list współczynników część nieholomorficznych rozwinięcia form z S for eta, eta_exp in S: a = -minimal_valuation + eta_exp.valuation() list_coeffs = a*[0] + eta_exp.list() + (-minimal_valuation)*[0] list_coeffs = list_coeffs[:-minimal_valuation] list_of_lists += [list_coeffs] M = matrix(F, list_of_lists) V = M.kernel() #chcemy wyzerować części nieholomorficzne, biorąc kombinacje form z S # Sprawdzamy, jakim formom odpowiadają elementy V. forms = [] for vec in V.basis(): forma_holo = as_form(C_AS, 0) forma_holo_power_series = Rt(0) for vec_wspolrzedna, elt_S in zip(vec, S): eta = elt_S[0] #eta_exp = elt_S[1] forma_holo += vec_wspolrzedna*eta #forma_holo_power_series += vec_wspolrzedna*eta_exp forms += [forma_holo] return forms