31 KiB
31 KiB
class superelliptic:
def __init__(self, f, m):
Rx = f.parent()
x = Rx.gen()
F = Rx.base()
Rx.<x> = PolynomialRing(F)
Rxy.<x, y> = PolynomialRing(F, 2)
Fxy = FractionField(Rxy)
self.polynomial = Rx(f)
self.exponent = m
self.base_ring = F
self.characteristic = F.characteristic()
r = Rx(f).degree()
delta = GCD(r, m)
def __repr__(self):
f = self.polynomial
m = self.exponent
F = self.base_ring
return 'Superelliptic curve with the equation y^' + str(m) + ' = ' + str(f)+' over ' + str(F)
def basis_holomorphic_differentials_degree(self):
f = self.polynomial
m = self.exponent
r = f.degree()
delta = GCD(r, m)
F = self.base_ring
Rx.<x> = PolynomialRing(F)
Rxy.<x, y> = PolynomialRing(F, 2)
Fxy = FractionField(Rxy)
#########basis of holomorphic differentials and de Rham
basis_holo = []
degrees0 = {}
k = 0
for j in range(1, m):
for i in range(1, r):
if (r*j - m*i >= delta):
basis_holo += [superelliptic_form(self, Fxy(x^(i-1)/y^j))]
degrees0[k] = (i-1, j)
k = k+1
return(basis_holo, degrees0)
def holomorphic_differentials_basis(self):
basis_holo, degrees0 = self.basis_holomorphic_differentials_degree()
return basis_holo
def degrees_holomorphic_differentials(self):
basis_holo, degrees0 = self.basis_holomorphic_differentials_degree()
return degrees0
def basis_de_rham_degrees(self):
f = self.polynomial
m = self.exponent
r = f.degree()
delta = GCD(r, m)
F = self.base_ring
Rx.<x> = PolynomialRing(F)
Rxy.<x, y> = PolynomialRing(F, 2)
Fxy = FractionField(Rxy)
basis_holo = self.holomorphic_differentials_basis()
basis = []
for k in range(0, len(basis_holo)):
basis += [superelliptic_cech(self, basis_holo[k], superelliptic_function(self, 0))]
## non-holomorphic elts of H^1_dR
t = len(basis)
degrees0 = {}
degrees1 = {}
for j in range(1, m):
for i in range(1, r):
if (r*(m-j) - m*i >= delta):
s = Rx(m-j)*Rx(x)*Rx(f.derivative()) - Rx(m)*Rx(i)*f
psi = Rx(cut(s, i))
basis += [superelliptic_cech(self, superelliptic_form(self, Fxy(psi/y^j)), superelliptic_function(self, Fxy(m*y^(m-j)/x^i)))]
degrees0[t] = (psi.degree(), j)
degrees1[t] = (-i, m-j)
t += 1
return basis, degrees0, degrees1
def de_rham_basis(self):
basis, degrees0, degrees1 = self.basis_de_rham_degrees()
return basis
def degrees_de_rham0(self):
basis, degrees0, degrees1 = self.basis_de_rham_degrees()
return degrees0
def degrees_de_rham1(self):
basis, degrees0, degrees1 = self.basis_de_rham_degrees()
return degrees1
def is_smooth(self):
f = self.polynomial
if f.discriminant() == 0:
return 0
return 1
def genus(self):
r = self.polynomial.degree()
m = self.exponent
delta = GCD(r, m)
return 1/2*((r-1)*(m-1) - delta + 1)
def verschiebung_matrix(self):
basis = self.de_rham_basis()
g = self.genus()
p = self.characteristic
F = self.base_ring
M = matrix(F, 2*g, 2*g)
for i in range(0, len(basis)):
w = basis[i]
v = w.verschiebung().coordinates()
M[i, :] = v
return M
def frobenius_matrix(self):
basis = self.de_rham_basis()
g = self.genus()
p = self.characteristic
F = self.base_ring
M = matrix(F, 2*g, 2*g)
for i in range(0, len(basis)):
w = basis[i]
v = w.frobenius().coordinates()
M[i, :] = v
return M
def cartier_matrix(self):
basis = self.holomorphic_differentials_basis()
g = self.genus()
p = self.characteristic
F = self.base_ring
M = matrix(F, g, g)
for i in range(0, len(basis)):
w = basis[i]
v = w.cartier().coordinates()
M[i, :] = v
return M
# def p_rank(self):
# return self.cartier_matrix().rank()
def a_number(self):
g = C.genus()
return g - self.cartier_matrix().rank()
def final_type(self, test = 0):
Fr = self.frobenius_matrix()
V = self.verschiebung_matrix()
p = self.characteristic
return flag(Fr, V, p, test)
def reduction(C, g):
p = C.characteristic
F = C.base_ring
Rxy.<x, y> = PolynomialRing(F, 2)
Fxy = FractionField(Rxy)
f = C.polynomial
r = f.degree()
m = C.exponent
g = Fxy(g)
g1 = g.numerator()
g2 = g.denominator()
Rx.<x> = PolynomialRing(F)
Fx = FractionField(Rx)
FxRy.<y> = PolynomialRing(Fx)
(A, B, C) = xgcd(FxRy(g2), FxRy(y^m - f))
g = FxRy(g1*B/A)
while(g.degree(Rxy(y)) >= m):
d = g.degree(Rxy(y))
G = coff(g, d)
i = floor(d/m)
g = g - G*y^d + f^i * y^(d%m) *G
return(FxRy(g))
def reduction_form(C, g):
F = C.base_ring
Rxy.<x, y> = PolynomialRing(F, 2)
Fxy = FractionField(Rxy)
f = C.polynomial
r = f.degree()
m = C.exponent
g = reduction(C, g)
g1 = Rxy(0)
Rx.<x> = PolynomialRing(F)
Fx = FractionField(Rx)
FxRy.<y> = PolynomialRing(Fx)
g = FxRy(g)
for j in range(0, m):
if j==0:
G = coff(g, 0)
g1 += FxRy(G)
else:
G = coff(g, j)
g1 += Fxy(y^(j-m)*f*G)
return(g1)
class superelliptic_function:
def __init__(self, C, g):
F = C.base_ring
Rxy.<x, y> = PolynomialRing(F, 2)
Fxy = FractionField(Rxy)
f = C.polynomial
r = f.degree()
m = C.exponent
self.curve = C
g = reduction(C, g)
self.function = g
def __repr__(self):
return str(self.function)
def jth_component(self, j):
g = self.function
C = self.curve
F = C.base_ring
Rx.<x> = PolynomialRing(F)
Fx.<x> = FractionField(Rx)
FxRy.<y> = PolynomialRing(Fx)
g = FxRy(g)
return coff(g, j)
def __add__(self, other):
C = self.curve
g1 = self.function
g2 = other.function
g = reduction(C, g1 + g2)
return superelliptic_function(C, g)
def __sub__(self, other):
C = self.curve
g1 = self.function
g2 = other.function
g = reduction(C, g1 - g2)
return superelliptic_function(C, g)
def __mul__(self, other):
C = self.curve
g1 = self.function
g2 = other.function
g = reduction(C, g1 * g2)
return superelliptic_function(C, g)
def __truediv__(self, other):
C = self.curve
g1 = self.function
g2 = other.function
g = reduction(C, g1 / g2)
return superelliptic_function(C, g)
def diffn(self):
C = self.curve
f = C.polynomial
m = C.exponent
F = C.base_ring
g = self.function
Rxy.<x, y> = PolynomialRing(F, 2)
Fxy = FractionField(Rxy)
g = Fxy(g)
A = g.derivative(x)
B = g.derivative(y)*f.derivative(x)/(m*y^(m-1))
return superelliptic_form(C, A+B)
def expansion_at_infty(self, i = 0, prec=10):
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)
b = -b
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), prec = prec)
xx = Rt(1/(t^M*ww^b))
yy = 1/(t^R*ww^a)
return Rt(fct(x = Rt(xx), y = Rt(yy)))
def naive_hensel(fct, F, start = 1, prec=10):
Rt.<t> = LaurentSeriesRing(F, default_prec=prec)
RtQ = FractionField(Rt)
RptW.<W> = PolynomialRing(RtQ)
fct = RptW(fct)
alpha = (fct.derivative())(W = start)
w0 = Rt(start)
i = 1
while(i < prec):
w0 = w0 - fct(W = w0)/alpha + O(t^(prec))
i += 1
return w0
class superelliptic_form:
def __init__(self, C, g):
F = C.base_ring
Rxy.<x, y> = PolynomialRing(F, 2)
Fxy = FractionField(Rxy)
g = Fxy(reduction_form(C, g))
self.form = g
self.curve = C
def __add__(self, other):
C = self.curve
g1 = self.form
g2 = other.form
g = reduction(C, g1 + g2)
return superelliptic_form(C, g)
def __sub__(self, other):
C = self.curve
g1 = self.form
g2 = other.form
g = reduction(C, g1 - g2)
return superelliptic_form(C, g)
def __repr__(self):
g = self.form
if len(str(g)) == 1:
return str(g) + ' dx'
return '('+str(g) + ') dx'
def __rmul__(self, constant):
C = self.curve
omega = self.form
return superelliptic_form(C, constant*omega)
def cartier(self):
C = self.curve
m = C.exponent
p = C.characteristic
f = C.polynomial
F = C.base_ring
Rx.<x> = PolynomialRing(F)
Fx = FractionField(Rx)
FxRy.<y> = PolynomialRing(Fx)
Fxy = FractionField(FxRy)
result = superelliptic_form(C, FxRy(0))
mult_order = Integers(m)(p).multiplicative_order()
M = Integer((p^(mult_order)-1)/m)
for j in range(1, m):
fct_j = self.jth_component(j)
h = Rx(fct_j*f^(M*j))
j1 = (p^(mult_order-1)*j)%m
B = floor(p^(mult_order-1)*j/m)
result += superelliptic_form(C, polynomial_part(p, h)/(f^B*y^(j1)))
return result
def coordinates(self):
C = self.curve
F = C.base_ring
m = C.exponent
Rx.<x> = PolynomialRing(F)
Fx = FractionField(Rx)
FxRy.<y> = PolynomialRing(Fx)
g = C.genus()
degrees_holo = C.degrees_holomorphic_differentials()
degrees_holo_inv = {b:a for a, b in degrees_holo.items()}
basis = C.holomorphic_differentials_basis()
for j in range(1, m):
omega_j = Fx(self.jth_component(j))
if omega_j != Fx(0):
d = degree_of_rational_fctn(omega_j, F)
index = degrees_holo_inv[(d, j)]
a = coeff_of_rational_fctn(omega_j, F)
a1 = coeff_of_rational_fctn(basis[index].jth_component(j), F)
elt = self - (a/a1)*basis[index]
return elt.coordinates() + a/a1*vector([F(i == index) for i in range(0, g)])
return vector(g*[0])
def jth_component(self, j):
g = self.form
C = self.curve
F = C.base_ring
Rx.<x> = PolynomialRing(F)
Fx = FractionField(Rx)
FxRy.<y> = PolynomialRing(Fx)
Fxy = FractionField(FxRy)
Ryinv.<y_inv> = PolynomialRing(Fx)
g = Fxy(g)
g = g(y = 1/y_inv)
g = Ryinv(g)
return coff(g, j)
def is_regular_on_U0(self):
C = self.curve
F = C.base_ring
m = C.exponent
Rx.<x> = PolynomialRing(F)
for j in range(1, m):
if self.jth_component(j) not in Rx:
return 0
return 1
def is_regular_on_Uinfty(self):
C = self.curve
F = C.base_ring
m = C.exponent
f = C.polynomial
r = f.degree()
delta = GCD(m, r)
M = m/delta
R = r/delta
for j in range(1, m):
A = self.jth_component(j)
d = degree_of_rational_fctn(A, F)
if(-d*M + j*R -(M+1)<0):
return 0
return 1
def expansion_at_infty(self, i = 0, prec=10):
g = self.form
C = self.curve
g = superelliptic_function(C, g)
g = g.expansion_at_infty(i = i, prec=prec)
x_series = superelliptic_function(C, x).expansion_at_infty(i = i, prec=prec)
dx_series = x_series.derivative()
return g*dx_series
class superelliptic_cech:
def __init__(self, C, omega, fct):
self.omega0 = omega
self.omega8 = omega - fct.diffn()
self.f = fct
self.curve = C
def __add__(self, other):
C = self.curve
return superelliptic_cech(C, self.omega0 + other.omega0, self.f + other.f)
def __sub__(self, other):
C = self.curve
return superelliptic_cech(C, self.omega0 - other.omega0, self.f - other.f)
def __rmul__(self, constant):
C = self.curve
w1 = self.omega0.form
f1 = self.f.function
w2 = superelliptic_form(C, constant*w1)
f2 = superelliptic_function(C, constant*f1)
return superelliptic_cech(C, w2, f2)
def __repr__(self):
return "(" + str(self.omega0) + ", " + str(self.f) + ", " + str(self.omega8) + ")"
def verschiebung(self):
C = self.curve
omega = self.omega0
F = C.base_ring
Rx.<x> = PolynomialRing(F)
return superelliptic_cech(C, omega.cartier(), superelliptic_function(C, Rx(0)))
def frobenius(self):
C = self.curve
fct = self.f.function
p = C.characteristic
Rx.<x> = PolynomialRing(F)
return superelliptic_cech(C, superelliptic_form(C, Rx(0)), superelliptic_function(C, fct^p))
def coordinates(self):
C = self.curve
F = C.base_ring
m = C.exponent
Rx.<x> = PolynomialRing(F)
Fx = FractionField(Rx)
FxRy.<y> = PolynomialRing(Fx)
g = C.genus()
degrees_holo = C.degrees_holomorphic_differentials()
degrees_holo_inv = {b:a for a, b in degrees_holo.items()}
degrees0 = C.degrees_de_rham0()
degrees0_inv = {b:a for a, b in degrees0.items()}
degrees1 = C.degrees_de_rham1()
degrees1_inv = {b:a for a, b in degrees1.items()}
basis = C.de_rham_basis()
omega = self.omega0
fct = self.f
if fct.function == Rx(0) and omega.form != Rx(0):
for j in range(1, m):
omega_j = Fx(omega.jth_component(j))
if omega_j != Fx(0):
d = degree_of_rational_fctn(omega_j, F)
index = degrees_holo_inv[(d, j)]
a = coeff_of_rational_fctn(omega_j, F)
a1 = coeff_of_rational_fctn(basis[index].omega0.jth_component(j), F)
elt = self - (a/a1)*basis[index]
return elt.coordinates() + a/a1*vector([F(i == index) for i in range(0, 2*g)])
for j in range(1, m):
fct_j = Fx(fct.jth_component(j))
if (fct_j != Rx(0)):
d = degree_of_rational_fctn(fct_j, p)
if (d, j) in degrees1.values():
index = degrees1_inv[(d, j)]
a = coeff_of_rational_fctn(fct_j, F)
elt = self - (a/m)*basis[index]
return elt.coordinates() + a/m*vector([F(i == index) for i in range(0, 2*g)])
if d<0:
a = coeff_of_rational_fctn(fct_j, F)
h = superelliptic_function(C, FxRy(a*y^j*x^d))
elt = superelliptic_cech(C, self.omega0, self.f - h)
return elt.coordinates()
if (fct_j != Rx(0)):
G = superelliptic_function(C, y^j*x^d)
a = coeff_of_rational_fctn(fct_j, F)
elt =self - a*superelliptic_cech(C, diffn(G), G)
return elt.coordinates()
return vector(2*g*[0])
def is_cocycle(self):
w0 = self.omega0
w8 = self.omega8
fct = self.f
if not w0.is_regular_on_U0() and not w8.is_regular_on_Uinfty():
return('w0 & w8')
if not w0.is_regular_on_U0():
return('w0')
if not w8.is_regular_on_Uinfty():
return('w8')
if w0.is_regular_on_U0() and w8.is_regular_on_Uinfty():
return 1
return 0
def degree_of_rational_fctn(f, F):
Rx.<x> = PolynomialRing(F)
Fx = FractionField(Rx)
f = Fx(f)
f1 = f.numerator()
f2 = f.denominator()
d1 = f1.degree()
d2 = f2.degree()
return(d1 - d2)
def coeff_of_rational_fctn(f, F):
Rx.<x> = PolynomialRing(F)
Fx = FractionField(Rx)
f = Fx(f)
if f == Rx(0):
return 0
f1 = f.numerator()
f2 = f.denominator()
d1 = f1.degree()
d2 = f2.degree()
a1 = f1.coefficients(sparse = false)[d1]
a2 = f2.coefficients(sparse = false)[d2]
return(a1/a2)
def coff(f, d):
lista = f.coefficients(sparse = false)
if len(lista) <= d:
return 0
return lista[d]
def cut(f, i):
R = f.parent()
coeff = f.coefficients(sparse = false)
return sum(R(x^(j-i-1)) * coeff[j] for j in range(i+1, f.degree() + 1))
def polynomial_part(p, h):
F = GF(p)
Rx.<x> = PolynomialRing(F)
h = Rx(h)
result = Rx(0)
for i in range(0, h.degree()+1):
if (i%p) == p-1:
power = Integer((i-(p-1))/p)
result += Integer(h[i]) * x^(power)
return result
#Find delta-th root of unity in field F
def root_of_unity(F, delta):
Rx.<x> = PolynomialRing(F)
cyclotomic = x^(delta) - 1
for root, a in cyclotomic.roots():
powers = [root^d for d in delta.divisors() if d!= delta]
if 1 not in powers:
return root
def preimage(U, V, M): #preimage of subspace U under M
basis_preimage = M.right_kernel().basis()
imageU = U.intersection(M.transpose().image())
basis = imageU.basis()
for v in basis:
w = M.solve_right(v)
basis_preimage = basis_preimage + [w]
return V.subspace(basis_preimage)
def image(U, V, M):
basis = U.basis()
basis_image = []
for v in basis:
basis_image += [M*v]
return V.subspace(basis_image)
def flag(F, V, p, test = 0):
dim = F.dimensions()[0]
space = VectorSpace(GF(p), dim)
flag_subspaces = (dim+1)*[0]
flag_used = (dim+1)*[0]
final_type = (dim+1)*['?']
flag_subspaces[dim] = space
flag_used[dim] = 1
while 1 in flag_used:
index = flag_used.index(1)
flag_used[index] = 0
U = flag_subspaces[index]
U_im = image(U, space, V)
d_im = U_im.dimension()
final_type[index] = d_im
U_pre = preimage(U, space, F)
d_pre = U_pre.dimension()
if flag_subspaces[d_im] == 0:
flag_subspaces[d_im] = U_im
flag_used[d_im] = 1
if flag_subspaces[d_pre] == 0:
flag_subspaces[d_pre] = U_pre
flag_used[d_pre] = 1
if test == 1:
print('(', final_type, ')')
for i in range(0, dim+1):
if final_type[i] == '?' and final_type[dim - i] != '?':
i1 = dim - i
final_type[i] = final_type[i1] - i1 + dim/2
final_type[0] = 0
for i in range(1, dim+1):
if final_type[i] == '?':
prev = final_type[i-1]
if prev != '?' and prev in final_type[i+1:]:
final_type[i] = prev
for i in range(1, dim+1):
if final_type[i] == '?':
final_type[i] = min(final_type[i-1] + 1, dim/2)
if is_final(final_type, dim/2):
return final_type[1:dim/2 + 1]
print('error:', final_type[1:dim/2 + 1])
def is_final(final_type, dim):
n = len(final_type)
if final_type[0] != 0:
return 0
if final_type[n-1] != dim:
return 0
for i in range(1, n):
if final_type[i] != final_type[i - 1] and final_type[i] != final_type[i - 1] + 1:
return 0
return 1omega.omega8().exp3*t^2 + 3*t^14 + t^16 + 3*t^26 + 3*t^28 + 3*t^30 + 3*t^38 + t^40 + 3*t^50 + 3*t^62 + t^72 + t^74 + 2*t^76 + 4*t^84 + 2*t^86 + 4*t^88 + 4*t^90 + 2*t^96 + 4*t^98 + t^100 + O(t^114)
F = QQ
Rt.<t> = LaurentSeriesRing(F, default_prec=20)
RtQ = FractionField(Rt)
RptW.<W> = PolynomialRing(RtQ)
fct = W^2 - (1+t)A = naive_hensel(fct, F, start = 1, prec=10)A^2 - (1+t)WARNING: Some output was deleted.
FF = GF(5^6)Rx.<x> = PolynomialRing(FF)
(x^6 - 1).roots()[(4, 1), (1, 1), (3*z6^5 + 4*z6^4 + 3*z6^2 + 2*z6 + 2, 1), (3*z6^5 + 4*z6^4 + 3*z6^2 + 2*z6 + 1, 1), (2*z6^5 + z6^4 + 2*z6^2 + 3*z6 + 4, 1), (2*z6^5 + z6^4 + 2*z6^2 + 3*z6 + 3, 1)]
root_of_unity(GF(5^2), 3)3*z2 + 3
Rx.<x> = PolynomialRing(GF(5^3))
Rx(x^2 + x + 1).factor()x^2 + x + 1
a = GF(5^3).random_element()a