naprawione regular form; superelliptyczne maja C.x_series itd
This commit is contained in:
parent
eda1cca0c2
commit
64fe2ee228
39711
sage/.run.term-0.term
39711
sage/.run.term-0.term
File diff suppressed because one or more lines are too long
@ -1,14 +1,14 @@
|
||||
p = 5
|
||||
m = 2
|
||||
F = GF(p)
|
||||
Rx.<x> = PolynomialRing(F)
|
||||
Rxx.<x> = PolynomialRing(F)
|
||||
#f = (x^3 - x)^3 + x^3 - x
|
||||
f = x^3 + x
|
||||
f1 = f(x = x^5 - x)
|
||||
C = superelliptic(f, m)
|
||||
C1 = superelliptic(f1, m)
|
||||
C1 = superelliptic(f1, m, prec = 500)
|
||||
B = C.crystalline_cohomology_basis(prec = 100, info = 1)
|
||||
B1 = C1.crystalline_cohomology_basis(prec = 500, info = 1)
|
||||
B1 = C1.crystalline_cohomology_basis(prec = 100, info = 1)
|
||||
|
||||
def crystalline_matrix(C, prec = 50):
|
||||
B = C.crystalline_cohomology_basis(prec = prec)
|
||||
@ -20,6 +20,12 @@ def crystalline_matrix(C, prec = 50):
|
||||
M[i, :] = vector(autom(b).coordinates(basis = B))
|
||||
return M
|
||||
|
||||
for b in B:
|
||||
print(b.regular_form())
|
||||
|
||||
for b in B1:
|
||||
print(b.regular_form())
|
||||
|
||||
#M = crystalline_matrix(C, prec = 150)
|
||||
#print(M)
|
||||
#print(M^3)
|
@ -1,7 +1,7 @@
|
||||
class superelliptic:
|
||||
"""Class of a superelliptic curve. Given a polynomial f(x) with coefficient field F, it constructs
|
||||
the curve y^m = f(x)"""
|
||||
def __init__(self, f, m):
|
||||
def __init__(self, f, m, prec = 100):
|
||||
Rx = f.parent()
|
||||
x = Rx.gen()
|
||||
F = Rx.base()
|
||||
@ -20,6 +20,31 @@ class superelliptic:
|
||||
self.y = superelliptic_function(self, Rxy(y))
|
||||
self.dx = superelliptic_form(self, Rxy(1))
|
||||
self.one = superelliptic_function(self, Rxy(1))
|
||||
# We compute now expansions at infinity of x and y.
|
||||
Rt.<t> = LaurentSeriesRing(F, default_prec=prec)
|
||||
RptW.<W> = PolynomialRing(Rt)
|
||||
RptWQ = FractionField(RptW)
|
||||
Rxy.<x, y> = PolynomialRing(F)
|
||||
RxyQ = FractionField(Rxy)
|
||||
delta, a, b = xgcd(m, r)
|
||||
a = -a
|
||||
M = m/delta
|
||||
R = r/delta
|
||||
while a<0:
|
||||
a += R
|
||||
b += M
|
||||
g = (x^r*f(x = 1/x))
|
||||
gW = RptWQ(g(x = t^M * W^b)) - W^(delta)
|
||||
self.x_series = []
|
||||
self.y_series = []
|
||||
self.dx_series = []
|
||||
for place in range(delta):
|
||||
ww = naive_hensel(gW, F, start = root_of_unity(F, delta)^place, prec = prec)
|
||||
xx = Rt(1/(t^M*ww^b))
|
||||
yy = 1/(t^R*ww^a)
|
||||
self.x_series += [xx]
|
||||
self.y_series += [yy]
|
||||
self.dx_series += [xx.derivative()]
|
||||
|
||||
def __repr__(self):
|
||||
f = self.polynomial
|
||||
|
@ -137,10 +137,10 @@ class superelliptic_form:
|
||||
g = self.form
|
||||
C = self.curve
|
||||
g = superelliptic_function(C, g)
|
||||
g = g.expansion_at_infty(place = place, prec=prec)
|
||||
x_series = C.x.expansion_at_infty(place = place, prec=prec)
|
||||
dx_series = x_series.derivative()
|
||||
return g*dx_series
|
||||
F = C.base_ring
|
||||
Rt.<t> = LaurentSeriesRing(F, default_prec=prec)
|
||||
g = Rt(g.expansion_at_infty(place = place, prec=prec))
|
||||
return g*C.dx_series[place]
|
||||
|
||||
def expansion(self, pt, prec = 50):
|
||||
'''Expansion in the completed ring of the point pt. If pt is an integer, it means the corresponding place at infinity.'''
|
||||
|
@ -108,31 +108,11 @@ class superelliptic_function:
|
||||
|
||||
def expansion_at_infty(self, place = 0, prec=20):
|
||||
C = self.curve
|
||||
f = C.polynomial
|
||||
m = C.exponent
|
||||
F = C.base_ring
|
||||
Rx.<x> = PolynomialRing(F)
|
||||
f = Rx(f)
|
||||
Rt.<t> = LaurentSeriesRing(F, default_prec=prec)
|
||||
RptW.<W> = PolynomialRing(Rt)
|
||||
RptWQ = FractionField(RptW)
|
||||
Rxy.<x, y> = PolynomialRing(F)
|
||||
RxyQ = FractionField(Rxy)
|
||||
fct = self.function
|
||||
fct = RxyQ(fct)
|
||||
r = f.degree()
|
||||
delta, a, b = xgcd(m, r)
|
||||
a = -a
|
||||
M = m/delta
|
||||
R = r/delta
|
||||
while a<0:
|
||||
a += R
|
||||
b += M
|
||||
g = (x^r*f(x = 1/x))
|
||||
gW = RptWQ(g(x = t^M * W^b)) - W^(delta)
|
||||
ww = naive_hensel(gW, F, start = root_of_unity(F, delta)^place, prec = prec)
|
||||
xx = Rt(1/(t^M*ww^b))
|
||||
yy = 1/(t^R*ww^a)
|
||||
F = C.base_ring
|
||||
Rt.<t> = LaurentSeriesRing(F, default_prec=prec)
|
||||
xx = C.x_series[place]
|
||||
yy = C.y_series[place]
|
||||
return Rt(fct(x = Rt(xx), y = Rt(yy)))
|
||||
|
||||
def expansion(self, pt, prec = 50):
|
||||
|
@ -34,10 +34,10 @@ def de_rham_witt_lift(cech_class, prec = 50):
|
||||
|
||||
def crystalline_cohomology_basis(self, prec = 50, info = 0):
|
||||
result = []
|
||||
prec1 = prec
|
||||
for i, a in enumerate(self.de_rham_basis()):
|
||||
if info:
|
||||
print("Computing " + str(i) +". basis element")
|
||||
prec1 = prec
|
||||
while True:
|
||||
try:
|
||||
result += [de_rham_witt_lift(a, prec = prec1)]
|
||||
|
@ -74,12 +74,14 @@ class superelliptic_regular_drw_form:
|
||||
|
||||
def regular_drw_form(omega):
|
||||
C = omega.curve
|
||||
p = C.characteristic
|
||||
omega_aux = omega.r()
|
||||
omega_aux = omega_aux.regular_form()
|
||||
aux = omega - omega_aux.dx.teichmuller()*C.x.teichmuller().diffn() - omega_aux.dy.teichmuller()*C.y.teichmuller().diffn()
|
||||
aux.omega, fct = decomposition_omega0_hpdh(aux.omega)
|
||||
aux.h2 += fct^p
|
||||
aux.h2 = decomposition_g0_p2th_power(aux.h2)[0]
|
||||
aux.h2, A = decomposition_g0_pth_power(aux.h2)
|
||||
aux.omega += (A.diffn()).inv_cartier()
|
||||
result = superelliptic_regular_drw_form(omega_aux.dx, omega_aux.dy, aux.omega.regular_form(), aux.h2)
|
||||
return result
|
||||
|
||||
|
@ -1,4 +1,8 @@
|
||||
def decomposition_g0_pth_power(fct):
|
||||
C = fct.curve
|
||||
Fxy, Rxy, xy, y = C.fct_field
|
||||
if fct.function in Rxy:
|
||||
return (fct, 0*C.x)
|
||||
'''Decompose fct as g0 + A^p, if possible. Output: (g0, A).'''
|
||||
omega = fct.diffn().regular_form()
|
||||
g0 = omega.int()
|
||||
@ -7,6 +11,8 @@ def decomposition_g0_pth_power(fct):
|
||||
|
||||
def decomposition_g0_p2th_power(fct):
|
||||
'''Decompose fct as g0 + A^(p^2), if possible. Output: (g0, A).'''
|
||||
C = fct.curve
|
||||
p = C.characteristic
|
||||
g0, A = decomposition_g0_pth_power(fct)
|
||||
A0, A1 = decomposition_g0_pth_power(A)
|
||||
return (g0 + A0^p, A1)
|
||||
@ -14,6 +20,9 @@ def decomposition_g0_p2th_power(fct):
|
||||
def decomposition_omega0_hpdh(omega):
|
||||
'''Decompose omega = (regular on U0) + h^(p-1) dh, so that Cartier(omega) = (regular on U0) + dh.
|
||||
Result: (regular on U0, h)'''
|
||||
C = omega.curve
|
||||
if omega.is_regular_on_U0():
|
||||
return (omega, 0*C.x)
|
||||
omega1 = omega.cartier().cartier()
|
||||
omega1 = omega1.inv_cartier().inv_cartier()
|
||||
fct = (omega.cartier() - omega1.cartier()).int()
|
||||
@ -27,6 +36,9 @@ def decomposition_omega8_hpdh(omega, prec = 50):
|
||||
Fxy, Rxy, x, y = C.fct_field
|
||||
F = C.base_ring
|
||||
p = C.characteristic
|
||||
C = omega.curve
|
||||
if omega.is_regular_on_Uinfty():
|
||||
return (omega, 0*C.x)
|
||||
Rt.<t> = LaurentSeriesRing(F)
|
||||
omega_analytic = Rt(laurent_analytic_part(omega.expansion_at_infty(prec = prec)))
|
||||
Cv = C.uniformizer()
|
||||
@ -44,6 +56,8 @@ def decomposition_g8_pth_power(fct, prec = 50):
|
||||
F = C.base_ring
|
||||
Rt.<t> = LaurentSeriesRing(F)
|
||||
Fxy, Rxy, x, y = C.fct_field
|
||||
if fct.expansion_at_infty().valuation() >= 0:
|
||||
return (fct, 0*C.x)
|
||||
A = laurent_analytic_part(fct.expansion_at_infty(prec = prec))
|
||||
Cv = C.uniformizer()
|
||||
v = Cv.function
|
||||
|
@ -56,13 +56,19 @@ class superelliptic_drw_cech:
|
||||
C = self.curve
|
||||
return superelliptic_cech(C, omega0.h1*C.dx, f.t)
|
||||
|
||||
def div_by_p(self):
|
||||
def div_by_p(self, info = 0):
|
||||
'''Given a regular cocycle of the form (V(omega) + dV(h), [f] + V(t), ...), where [f] = 0 in H^1(X, OX),
|
||||
find de Rham cocycle (xi0, f, xi8) such that (V(omega) + dV(h), [f] + V(t), ...) = p*(xi0, f, xi8).'''
|
||||
#
|
||||
if info: print("Computing " + str(self) + " divided by p.")
|
||||
#
|
||||
C = self.curve
|
||||
aux = self
|
||||
Fxy, Rxy, x, y = C.fct_field
|
||||
aux_f_t_0 = decomposition_g0_g8(aux.f.t, prec=50)[0]
|
||||
#
|
||||
if info: print("Computed decomposition_g0_g8 of self.f.t.")
|
||||
#
|
||||
aux.f.t = 0*C.x
|
||||
aux.omega0 -= aux_f_t_0.teichmuller().diffn()
|
||||
aux.omega8 = aux.omega0 - aux.f.diffn()
|
||||
@ -72,9 +78,17 @@ class superelliptic_drw_cech:
|
||||
omega = aux.omega0.omega
|
||||
aux.omega0.omega, fct = decomposition_omega0_hpdh(aux.omega0.omega)
|
||||
aux.omega0.h2 += fct^p
|
||||
#
|
||||
if info: print("Computed decomposition_omega0_hpdh of self.omega0.omega.")
|
||||
#
|
||||
# Now we have to ensure that aux.omega0.h2.function in Rxy...
|
||||
# In other words, we decompose h2 = (regular on U0) + A^(p^2).
|
||||
aux.omega0.h2 = decomposition_g0_p2th_power(aux.omega0.h2)[0]
|
||||
# In other words, we decompose h2 = (regular on U0) + A^p.
|
||||
# Then we replace h2 by (regular on U0) and omega by omega + inverse Cartier(dA)
|
||||
aux.omega0.h2, A = decomposition_g0_pth_power(aux.omega0.h2)
|
||||
aux.omega0.omega += (A.diffn()).inv_cartier()
|
||||
#
|
||||
if info: print("Computed decomposition_g0_p2th_power(aux.omega0.h2).")
|
||||
#
|
||||
# Now we can reduce: (... + dV(h2), V(f), ...) --> (..., V(f - h2), ...)
|
||||
aux.f -= aux.omega0.h2.verschiebung()
|
||||
aux.omega0.h2 = 0*C.x
|
||||
@ -87,18 +101,21 @@ class superelliptic_drw_cech:
|
||||
aux_divided_by_p = superelliptic_cech(C, aux.omega0.omega.cartier(), aux.f.f.pth_root())
|
||||
return aux_divided_by_p
|
||||
|
||||
def coordinates(self, basis = 0, prec = 50):
|
||||
def coordinates(self, basis = 0, prec = 50, info = 0):
|
||||
if info: print("Computing coordinates of " + str(self))
|
||||
C = self.curve
|
||||
g = C.genus()
|
||||
coord_mod_p = self.r().coordinates()
|
||||
if info: print("Computed coordinates mod p.")
|
||||
coord_lifted = [lift(a) for a in coord_mod_p]
|
||||
if basis == 0:
|
||||
basis = C.crystalline_cohomology_basis()
|
||||
aux = self
|
||||
for i, a in enumerate(basis):
|
||||
aux -= coord_lifted[i]*a
|
||||
aux_divided_by_p = aux.div_by_p()
|
||||
aux_divided_by_p = aux.div_by_p(info = info)
|
||||
coord_aux_divided_by_p = aux_divided_by_p.coordinates()
|
||||
if info: print("Computed coordinates mod p of (self - lift)/p.")
|
||||
coord_aux_divided_by_p = [ZZ(a) for a in coord_aux_divided_by_p]
|
||||
coordinates = [ (coord_lifted[i] + p*coord_aux_divided_by_p[i])%p^2 for i in range(2*g)]
|
||||
return coordinates
|
||||
|
@ -1,6 +1,6 @@
|
||||
load('init.sage')
|
||||
#print("Expansion at infty test:")
|
||||
#load('superelliptic/tests/expansion_at_infty.sage')
|
||||
#load('init.sage')
|
||||
print("Expansion at infty test:")
|
||||
load('superelliptic/tests/expansion_at_infty.sage')
|
||||
#print("superelliptic form coordinates test:")
|
||||
#load('superelliptic/tests/form_coordinates_test.sage')
|
||||
#print("p-th root test:")
|
||||
|
Loading…
Reference in New Issue
Block a user