class as_form: def __init__(self, C, g): self.curve = C n = C.height F = C.base_ring RxyzQ, Rxyz, x, y, z = C.fct_field self.form = RxyzQ(g) def __repr__(self): return "(" + str(self.form)+") * dx" def __eq__(self, other): return self.expansion_at_infty() == other.expansion_at_infty() def expansion_at_infty(self, place = 0): C = self.curve delta = C.nb_of_pts_at_infty F = C.base_ring x_series = C.x_series[place] y_series = C.y_series[place] z_series = C.z_series[place] dx_series = C.dx_series[place] n = C.height RxyzQ, Rxyz, x, y, z = C.fct_field 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 expansion(self, pt = 0): '''Same code as expansion_at_infty.''' C = self.curve F = C.base_ring x_series = C.x_series[pt] y_series = C.y_series[pt] z_series = C.z_series[pt] dx_series = C.dx_series[pt] n = C.height RxyzQ, Rxyz, x, y, z = C.fct_field 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 __neg__(self): C = self.curve g = self.form return as_form(C, -g) def __rmul__(self, constant): C = self.curve omega = self.form return as_form(C, constant*omega) def reduce(self): RxyzQ, Rxyz, x, y, z = self.curve.fct_field aux = as_reduction(self.curve, RxyzQ(self.form)) return as_form(self.curve, aux) def group_action(self, elt): C = self.curve n = C.height aux = as_function(C, self.form) aux = aux.group_action(elt) return as_form(C, aux.function) def coordinates(self, basis = 0): """Find coordinates of the given holomorphic form self in terms of the basis forms in a list holo.""" self = self.reduce() C = self.curve if basis == 0: basis = C.holomorphic_differentials_basis() RxyzQ, Rxyz, x, y, z = C.fct_field # 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]) basis = [denom*omega for omega in basis] self_with_no_denominator = denom*self return linear_representation_polynomials(Rxyz(self_with_no_denominator.form), [Rxyz(omega.form) for omega in basis]) def trace(self, super=True): C = self.curve C_super = C.quotient n = C.height F = C.base_ring RxyzQ, Rxyz, x, y, z = C.fct_field result = as_form(C, 0) G = C.group.elts for a in G: result += self.group_action(a) result = result.form Rxy. = PolynomialRing(F, 2) Qxy = FractionField(Rxy) result = as_reduction(C, result) if super: return superelliptic_form(C_super, Qxy(result)) return as_form(C, Qxy(result)) def residue(self, place=0): return self.expansion_at_infty(place = place).residue() def valuation(self, place=0): return self.expansion_at_infty(place = 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 cartier(self): C = self.curve F = C.base_ring n = C.height ff = C.functions p = F.characteristic() C_super = C.quotient (RxyzQ, Rxyz, x, y, z) = C.fct_field fct = self.form Rxy. = PolynomialRing(F, 2) RxyQ = FractionField(Rxy) x, y = Rxyz.gens()[0], Rxyz.gens()[1] z = Rxyz.gens()[2:] num = Rxyz(fct.numerator()) den = Rxyz(fct.denominator()) result = RxyzQ(0) #return (num, den, z, fct) if den in Rxy: sub_list = {x : x, y : y} | {z[j] : (z[j]^p - RxyzQ(ff[j].function)) for j in range(n)} num = RxyzQ(num.substitute(sub_list)) den1 = Rxyz(num.denominator()) num = Rxyz(num*den1^p) for monomial in Rxyz(num).monomials(): degrees = [monomial.degree(z[i]) for i in range(n)] product_of_z = prod(z[i]^(degrees[i]) for i in range(n)) monomial_divided_by_z = monomial/product_of_z product_of_z_no_p = prod(z[i]^(degrees[i]/p) for i in range(n)) aux_form = superelliptic_form(C_super, RxyQ(monomial_divided_by_z/den)) aux_form = aux_form.cartier() result += product_of_z_no_p * Rxyz(num).monomial_coefficient(monomial) * aux_form.form/den1 return as_form(C, result) raise ValueError("Please present first your form as sum z^i omega_i, where omega_i are forms on quotient curve.") def is_regular_on_U0(self): AS = self.curve C = AS.quotient m = C.exponent RxyzQ, Rxyz, x, y, z = AS.fct_field if y^(m-1)*self.form in Rxyz: return True return False 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 RxyzQ, Rxyz, x, y, z = C.fct_field 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]) 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