219 lines
8.1 KiB
Python
219 lines
8.1 KiB
Python
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.<t> = 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.<t> = 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.<x, y> = 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.<x, y> = 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
|