class as_form: def __init__(self, C, g): self.curve = C n = C.height F = C.base_ring 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.form = RxyzQ(g) def __repr__(self): return "(" + str(self.form)+") * dx" def expansion_at_infty(self, i = 0): C = self.curve delta = C.nb_of_pts_at_infty F = C.base_ring x_series = C.x[i] y_series = C.y[i] z_series = C.z[i] dx_series = C.dx[i] n = C.height 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) prec = C.prec Rt. = LaurentSeriesRing(F, default_prec=prec) g = self.form sub_list = {x : x_series, y : y_series} | {z[j] : z_series[j] for j in range(n)} return g.substitute(sub_list)*dx_series def __add__(self, other): C = self.curve g1 = self.form g2 = other.form return as_form(C, g1 + g2) def __sub__(self, other): C = self.curve g1 = self.form g2 = other.form return as_form(C, g1 - g2) def __rmul__(self, constant): C = self.curve omega = self.form return as_form(C, constant*omega) def group_action(self, ZN_tuple): C = self.curve n = C.height F = C.base_ring 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)) def coordinates(self, holo): """Find coordinates of the given form self in terms of the basis forms in a list holo.""" C = self.curve n = C.height gC = C.genus() F = C.base_ring 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:] from sage.rings.polynomial.toy_variety import linear_representation return linear_representation(Rxyz(self.form), holo) def trace(self): C = self.curve C_super = C.quotient n = C.height F = C.base_ring 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) result = as_form(C, 0) G = C.group for a in G: result += self.group_action(a) result = result.form Rxy. = PolynomialRing(F, 2) Qxy = FractionField(Rxy) result = as_reduction(AS, result) return superelliptic_form(C_super, Qxy(result)) def residue(self, place=0): return self.expansion_at_infty(i = place).residue() def valuation(self, place=0): return self.expansion_at_infty(i = place).valuation() 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. = LaurentSeriesRing(F, default_prec=prec) RtQ = FractionField(Rt) power_series = RtQ(power_series) if power_series.valuation() == +Infinity: raise ValueError("Precision is too low.") 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: T = ((power_series)^(-1)).nth_root(jump) #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]) T_rev = new_reverse(T, prec = prec) t_old = T_rev(t^p/(1 - t^((p-1)*jump)).nth_root(jump)) z = 1/t^(jump) + Rt(correction)(t = t_old) return(jump, correction, t_old, 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 F = C.base_ring n = C.height variable_names = 'x, y' for i in range(n): variable_names += ', z' + str(i) Rxyz = PolynomialRing(F, n+2, variable_names) denominators = prod(denominator(omega.form) for omega in set_of_forms) return is_linearly_dependent([Rxyz(denominators*omega.form) for omega in set_of_forms]) #given a set S of (form, corresponding Laurent series at some pt), find their combinations holomorphic at that pt def holomorphic_combinations_fcts(S, pole_order): 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([Rt(g[1]).valuation() for g in S]) if minimal_valuation >= -pole_order: 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 + Rt(eta_exp).valuation() list_coeffs = a*[0] + Rt(eta_exp).list() + (-minimal_valuation)*[0] list_coeffs = list_coeffs[:-minimal_valuation - pole_order] 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_function(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 #given a set S of (form, corresponding Laurent series at some pt), find their combinations holomorphic at that pt def holomorphic_combinations_forms(S, pole_order): 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([Rt(g[1]).valuation() for g in S]) if minimal_valuation >= -pole_order: 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 + Rt(eta_exp).valuation() list_coeffs = a*[0] + Rt(eta_exp).list() + (-minimal_valuation)*[0] list_coeffs = list_coeffs[:-minimal_valuation - pole_order] 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 #print only forms that are log at the branch pts, but not holomorphic def only_log_forms(C_AS): list1 = AS.at_most_poles_forms(0) list2 = AS.at_most_poles_forms(1) result = [] for a in list2: if not(are_forms_linearly_dependent(list1 + result + [a])): result += [a] return result