as transform for unramified points fixed
This commit is contained in:
parent
9585d6995b
commit
780c1f03f2
|
|
@ -175,49 +175,6 @@ class as_form:
|
|||
if y^(m-1)*self.form in Rxyz:
|
||||
return True
|
||||
return False
|
||||
|
||||
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.<t> = LaurentSeriesRing(F, default_prec=prec)
|
||||
RtQ = FractionField(Rt)
|
||||
power_series = RtQ(power_series)
|
||||
if power_series.valuation() == +Infinity:
|
||||
raise ValueError("Precision is too low.")
|
||||
if power_series.valuation() >= 0:
|
||||
# THIS IS WRONG - THERE ARE SEVERAL PLACES OVER THIS PLACE, AND IT DEPENDS
|
||||
aux = t^p - t
|
||||
z = new_reverse(aux, prec = prec)
|
||||
z = z(t = power_series)
|
||||
return(0, 0, t, z)
|
||||
|
||||
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:
|
||||
if jump != 0:
|
||||
T = nth_root2((power_series)^(-1), jump, prec=prec) #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])
|
||||
if jump != 0:
|
||||
T_rev = new_reverse(T, prec = prec)
|
||||
t_old = T_rev(t^p/nth_root2(1 - t^((p-1)*jump), jump, prec=prec))
|
||||
z = 1/t^(jump) + Rt(correction)(t = t_old)
|
||||
return(jump, correction, t_old, z)
|
||||
if jump == 0:
|
||||
aux = t^p - t
|
||||
z = new_reverse(aux, prec = prec)
|
||||
z = z(t = power_series)
|
||||
return(0, correction, t, z)
|
||||
|
||||
|
||||
def are_forms_linearly_dependent(set_of_forms):
|
||||
from sage.rings.polynomial.toy_variety import is_linearly_dependent
|
||||
|
|
|
|||
|
|
@ -0,0 +1,45 @@
|
|||
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."""
|
||||
print('as transform for ', power_series)
|
||||
correction = 0
|
||||
F = power_series.parent().base()
|
||||
p = F.characteristic()
|
||||
Rt.<t> = LaurentSeriesRing(F, default_prec=prec)
|
||||
RtQ = FractionField(Rt)
|
||||
power_series = RtQ(power_series)
|
||||
if power_series.valuation() == +Infinity:
|
||||
raise ValueError("Precision is too low.")
|
||||
if power_series.valuation() >= 0:
|
||||
# THIS IS WRONG - THERE ARE SEVERAL PLACES OVER THIS PLACE, AND IT DEPENDS
|
||||
aux = t^p - t
|
||||
z = new_reverse(aux, prec = prec)
|
||||
z = z(t = power_series)
|
||||
print("a")
|
||||
return(0, 0, t, z)
|
||||
|
||||
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:
|
||||
if jump != 0:
|
||||
T = nth_root2((power_series)^(-1), jump, prec=prec) #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])
|
||||
if jump != 0:
|
||||
T_rev = new_reverse(T, prec = prec)
|
||||
t_old = T_rev(t^p/nth_root2(1 - t^((p-1)*jump), jump, prec=prec))
|
||||
z = 1/t^(jump) + Rt(correction)(t = t_old)
|
||||
return(jump, correction, t_old, z)
|
||||
if jump == 0:
|
||||
aux = t^p - t
|
||||
z = new_reverse(aux, prec = prec)
|
||||
z = z(t = power_series)
|
||||
z = z + correction
|
||||
print('corr', correction, 'ps', power_series, 'z', z)
|
||||
return(0, correction, t, z)
|
||||
|
|
@ -1,12 +1,13 @@
|
|||
p = 3
|
||||
F = GF(3^2, 'a')
|
||||
F = GF(3)
|
||||
#F.<a> = GF(3^2)
|
||||
Rx.<x> = PolynomialRing(F)
|
||||
P1 = superelliptic(x^2 + 1, 2)
|
||||
fct1 = (P1.x)^2
|
||||
fct2 = fct1 + (P1.x)/(P1.y - P1.x)
|
||||
fct3 = (P1.x)^4
|
||||
C = heisenberg_cover(P1, [1/2*fct1, fct2, fct3], prec=500)
|
||||
print(C)
|
||||
B = C.holomorphic_differentials_basis()
|
||||
fct2 = (fct1 + P1.one/(P1.y - P1.x))
|
||||
fct3 = 0*P1.x
|
||||
C = heisenberg_cover(P1, [fct1, fct2, fct3], prec=200)
|
||||
print(C, '\n', C.genus(), '\n', C.jumps)
|
||||
#B = C.holomorphic_differentials_basis()
|
||||
#print("Computed basis")
|
||||
#a1, b1, c1 = heisenberg_group_action_matrices_holo(C, basis = B)
|
||||
|
|
@ -194,9 +194,11 @@ class heisenberg_cover:
|
|||
|
||||
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)
|
||||
for i in range(delta):
|
||||
for g in [(0, i, 0) for i in range(p)]:
|
||||
if i!=0 or g != (0, 0, 0):
|
||||
forms = [(omega, omega.expansion_at_infty(place = i)) for omega in forms]
|
||||
forms = holomorphic_combinations_fcts(forms, pole_order)
|
||||
|
||||
return forms
|
||||
|
||||
|
|
@ -217,7 +219,7 @@ class heisenberg_cover:
|
|||
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.
|
||||
"""Find forms with pole order in all the points at infty equal 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
|
||||
|
|
@ -405,6 +407,75 @@ class heisenberg_cover:
|
|||
result += [heisenberg_cech(self, omega, f)]
|
||||
return result
|
||||
|
||||
def stabilizer(self, place = 0):
|
||||
result = []
|
||||
for g in self.group:
|
||||
flag = 1
|
||||
for i in range(self.height):
|
||||
if self.z[i].valuation(place = place) > 0:
|
||||
fct = self.z[i]
|
||||
elif self.z[i].valuation(place = place) < 0:
|
||||
fct = self.one/self.z[i]
|
||||
if fct.group_action(g).valuation(place = place) <= 0:
|
||||
flag = 0
|
||||
if flag:
|
||||
result += [g]
|
||||
return result
|
||||
|
||||
def stabilizer_coset_reps(self, place = 0):
|
||||
result = [(0, 0, 0)]
|
||||
p = self.characteristic
|
||||
H = self.stabilizer(place = place)
|
||||
for g in self.group:
|
||||
flag = 1
|
||||
for v in result:
|
||||
if heisenberg_mult(g, heisenberg_inv(v, p), p) in H:
|
||||
flag = 0
|
||||
if flag:
|
||||
result += [g]
|
||||
return result
|
||||
|
||||
##############
|
||||
def at_most_poles2(self, pole_orders, threshold = 8):
|
||||
""" Find fcts with pole order in infty's at most pole_order from the given dictionary. The keys of the dictionary are pairs (place_at_infty, group element). The items are the poles orders at those places.
|
||||
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.<t> = 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 = heisenberg_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_orders[(0, (0, 0, 0))])
|
||||
|
||||
for i in range(delta):
|
||||
for g in self.stabilizer_coset_reps(place = i):
|
||||
if i!=0 or g != (0, 0, 0):
|
||||
forms = [(omega, omega.expansion_at_infty(place = i)) for omega in forms]
|
||||
forms = holomorphic_combinations_fcts(forms, pole_orders[(i, g)])
|
||||
return forms
|
||||
##############
|
||||
|
||||
|
||||
def heisenberg_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
|
||||
|
|
|
|||
|
|
@ -200,48 +200,6 @@ class heisenberg_form:
|
|||
if y^(m-1)*self.form in Rxyz:
|
||||
return True
|
||||
return False
|
||||
|
||||
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.<t> = LaurentSeriesRing(F, default_prec=prec)
|
||||
RtQ = FractionField(Rt)
|
||||
power_series = RtQ(power_series)
|
||||
if power_series.valuation() == +Infinity:
|
||||
raise ValueError("Precision is too low.")
|
||||
if power_series.valuation() >= 0:
|
||||
# THIS IS WRONG - THERE ARE SEVERAL PLACES OVER THIS PLACE, AND IT DEPENDS
|
||||
aux = t^p - t
|
||||
z = new_reverse(aux, prec = prec)
|
||||
z = z(t = power_series)
|
||||
return(0, 0, t, z)
|
||||
|
||||
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:
|
||||
if jump != 0:
|
||||
T = nth_root2((power_series)^(-1), jump, prec=prec) #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])
|
||||
if jump != 0:
|
||||
T_rev = new_reverse(T, prec = prec)
|
||||
t_old = T_rev(t^p/nth_root2(1 - t^((p-1)*jump), jump, prec=prec))
|
||||
z = 1/t^(jump) + Rt(correction)(t = t_old)
|
||||
return(jump, correction, t_old, z)
|
||||
if jump == 0:
|
||||
aux = t^p - t
|
||||
z = new_reverse(aux, prec = prec)
|
||||
z = z(t = power_series)
|
||||
return(0, correction, t, z)
|
||||
|
||||
def are_forms_linearly_dependent(set_of_forms):
|
||||
from sage.rings.polynomial.toy_variety import is_linearly_dependent
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@ load('superelliptic/superelliptic_function_class.sage')
|
|||
load('superelliptic/superelliptic_form_class.sage')
|
||||
load('superelliptic/superelliptic_cech_class.sage')
|
||||
load('superelliptic/frobenius_kernel.sage')
|
||||
load('as_covers/as_transform.sage')
|
||||
load('as_covers/as_cover_class.sage')
|
||||
load('as_covers/as_function_class.sage')
|
||||
load('as_covers/as_form_class.sage')
|
||||
|
|
@ -43,6 +44,9 @@ load('heisenberg_covers/heisenberg_form_class.sage')
|
|||
load('heisenberg_covers/heisenberg_polyforms.sage')
|
||||
load('heisenberg_covers/heisenberg_reduction.sage')
|
||||
load('heisenberg_covers/heisenberg_group_action_matrices.sage')
|
||||
load('heisenberg_covers/dual_element.sage')
|
||||
load('heisenberg_covers/ith_magical_component.sage')
|
||||
load('heisenberg_covers/heisenberg_group.sage')
|
||||
##############
|
||||
##############
|
||||
def init(lista, tests = False, init=True):
|
||||
|
|
|
|||
|
|
@ -194,49 +194,6 @@ class quaternion_form:
|
|||
if y^(m-1)*self.form in Rxyz:
|
||||
return True
|
||||
return False
|
||||
|
||||
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.<t> = LaurentSeriesRing(F, default_prec=prec)
|
||||
RtQ = FractionField(Rt)
|
||||
power_series = RtQ(power_series)
|
||||
if power_series.valuation() == +Infinity:
|
||||
raise ValueError("Precision is too low.")
|
||||
if power_series.valuation() >= 0:
|
||||
# THIS IS WRONG - THERE ARE SEVERAL PLACES OVER THIS PLACE, AND IT DEPENDS
|
||||
aux = t^p - t
|
||||
z = new_reverse(aux, prec = prec)
|
||||
z = z(t = power_series)
|
||||
return(0, 0, t, z)
|
||||
|
||||
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:
|
||||
if jump != 0:
|
||||
T = nth_root2((power_series)^(-1), jump, prec=prec) #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])
|
||||
if jump != 0:
|
||||
T_rev = new_reverse(T, prec = prec)
|
||||
t_old = T_rev(t^p/nth_root2(1 - t^((p-1)*jump), jump, prec=prec))
|
||||
z = 1/t^(jump) + Rt(correction)(t = t_old)
|
||||
return(jump, correction, t_old, z)
|
||||
if jump == 0:
|
||||
aux = t^p - t
|
||||
z = new_reverse(aux, prec = prec)
|
||||
z = z(t = power_series)
|
||||
return(0, correction, t, z)
|
||||
|
||||
|
||||
def are_forms_linearly_dependent(set_of_forms):
|
||||
from sage.rings.polynomial.toy_variety import is_linearly_dependent
|
||||
|
|
|
|||
Loading…
Reference in New Issue