class quaternion_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, 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 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 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 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 quaternion_form(C, g1 + g2) def __sub__(self, other): C = self.curve g1 = self.form g2 = other.form return quaternion_form(C, g1 - g2) def __neg__(self): C = self.curve g = self.form return quaternion_form(C, -g) def __rmul__(self, constant): C = self.curve omega = self.form return quaternion_form(C, constant*omega) def group_action(self, elt): Q8 = QuaternionGroup() Qi, Qj = Q8.gens() AS = self.curve RxyzQ, Rxyz, x, y, z = AS.fct_field if elt == Qi^4: sub_list = {x : x, y : y} | {z[0] : z[0], z[1] : z[1], z[2]: z[2]} if elt == Qi: sub_list = {x : x, y : y} | {z[0] : z[0]+1, z[1] : z[1], z[2]: z[2] + z[0]} if elt == Qj: sub_list = {x : x, y : y} | {z[0] : z[0], z[1] : z[1] + 1, z[2]: z[2] + z[1] + z[0]} if elt == Qi^2: sub_list = {x : x, y : y} | {z[0] : z[0], z[1] : z[1], z[2]: z[2] + 1} if elt == Qi * Qj: sub_list = {x : x, y : y} | {z[0] : z[0] + 1, z[1] : z[1] + 1, z[2]: z[2] + z[1] + 1} if elt == Qj * Qi: sub_list = {x : x, y : y} | {z[0] : z[0] + 1, z[1] : z[1] + 1, z[2]: z[2] + z[1]} if elt == Qi^3: sub_list = {x : x, y : y} | {z[0] : z[0]+1, z[1] : z[1], z[2]: z[2] + z[0] + 1} if elt == Qj^3: sub_list = {x : x, y : y} | {z[0] : z[0], z[1] : z[1] + 1, z[2]: z[2] + z[1] + z[0] + 1} g = self.form return quaternion_form(AS, g.substitute(sub_list)) def coordinates(self, basis = 0): """Find coordinates of the given holomorphic form self in terms of the basis forms in a list holo.""" 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. fct = quaternion_function(C, self.form) fct = quaternion_reduction(C, fct) self = quaternion_form(C, fct) 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): 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 = quaternion_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 = quaternion_reduction(C, result) return superelliptic_form(C_super, 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 quaternion_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 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]) #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