{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "class superelliptic:\n", " \n", " def __init__(self, f, m):\n", " Rx = f.parent()\n", " x = Rx.gen()\n", " F = Rx.base() \n", " Rx. = PolynomialRing(F)\n", " Rxy. = PolynomialRing(F, 2)\n", " Fxy = FractionField(Rxy)\n", " self.polynomial = Rx(f)\n", " self.exponent = m\n", " self.base_ring = F\n", " self.characteristic = F.characteristic()\n", " \n", " r = Rx(f).degree()\n", " delta = GCD(r, m)\n", " \n", " def __repr__(self):\n", " f = self.polynomial\n", " m = self.exponent\n", " F = self.base_ring\n", " return 'Superelliptic curve with the equation y^' + str(m) + ' = ' + str(f)+' over ' + str(F)\n", "\n", " \n", " def basis_holomorphic_differentials_degree(self):\n", " f = self.polynomial\n", " m = self.exponent\n", " r = f.degree()\n", " delta = GCD(r, m)\n", " F = self.base_ring\n", " Rx. = PolynomialRing(F)\n", " Rxy. = PolynomialRing(F, 2)\n", " Fxy = FractionField(Rxy)\n", " #########basis of holomorphic differentials and de Rham\n", "\n", " basis_holo = []\n", " degrees0 = {}\n", " k = 0\n", "\n", " for j in range(1, m):\n", " for i in range(1, r):\n", " if (r*j - m*i >= delta):\n", " basis_holo += [superelliptic_form(self, Fxy(x^(i-1)/y^j))]\n", " degrees0[k] = (i-1, j)\n", " k = k+1\n", "\n", " return(basis_holo, degrees0)\n", "\n", " def holomorphic_differentials_basis(self):\n", " basis_holo, degrees0 = self.basis_holomorphic_differentials_degree()\n", " return basis_holo\n", " \n", " def degrees_holomorphic_differentials(self):\n", " basis_holo, degrees0 = self.basis_holomorphic_differentials_degree()\n", " return degrees0\n", "\n", " def basis_de_rham_degrees(self):\n", " f = self.polynomial\n", " m = self.exponent\n", " r = f.degree()\n", " delta = GCD(r, m)\n", " F = self.base_ring\n", " Rx. = PolynomialRing(F)\n", " Rxy. = PolynomialRing(F, 2)\n", " Fxy = FractionField(Rxy)\n", " basis_holo = self.holomorphic_differentials_basis()\n", " basis = []\n", " for k in range(0, len(basis_holo)):\n", " basis += [superelliptic_cech(self, basis_holo[k], superelliptic_function(self, 0))]\n", "\n", " ## non-holomorphic elts of H^1_dR\n", " t = len(basis)\n", " degrees0 = {}\n", " degrees1 = {}\n", " for j in range(1, m):\n", " for i in range(1, r):\n", " if (r*(m-j) - m*i >= delta): \n", " s = Rx(m-j)*Rx(x)*Rx(f.derivative()) - Rx(m)*Rx(i)*f\n", " psi = Rx(cut(s, i))\n", " basis += [superelliptic_cech(self, superelliptic_form(self, Fxy(psi/y^j)), superelliptic_function(self, Fxy(m*y^(m-j)/x^i)))]\n", " degrees0[t] = (psi.degree(), j)\n", " degrees1[t] = (-i, m-j)\n", " t += 1\n", " return basis, degrees0, degrees1\n", "\n", " def de_rham_basis(self):\n", " basis, degrees0, degrees1 = self.basis_de_rham_degrees()\n", " return basis\n", "\n", " def degrees_de_rham0(self):\n", " basis, degrees0, degrees1 = self.basis_de_rham_degrees()\n", " return degrees0\n", "\n", " def degrees_de_rham1(self):\n", " basis, degrees0, degrees1 = self.basis_de_rham_degrees()\n", " return degrees1 \n", " \n", " def is_smooth(self):\n", " f = self.polynomial\n", " if f.discriminant() == 0:\n", " return 0\n", " return 1\n", " \n", " def genus(self):\n", " r = self.polynomial.degree()\n", " m = self.exponent\n", " delta = GCD(r, m)\n", " return 1/2*((r-1)*(m-1) - delta + 1)\n", " \n", " def verschiebung_matrix(self):\n", " basis = self.de_rham_basis()\n", " g = self.genus()\n", " p = self.characteristic\n", " F = self.base_ring\n", " M = matrix(F, 2*g, 2*g)\n", " for i in range(0, len(basis)):\n", " w = basis[i]\n", " v = w.verschiebung().coordinates()\n", " M[i, :] = v\n", " return M\n", " \n", " def frobenius_matrix(self):\n", " basis = self.de_rham_basis()\n", " g = self.genus()\n", " p = self.characteristic\n", " F = self.base_ring\n", " M = matrix(F, 2*g, 2*g)\n", " \n", " for i in range(0, len(basis)):\n", " w = basis[i]\n", " v = w.frobenius().coordinates()\n", " M[i, :] = v\n", " return M\n", "\n", " def cartier_matrix(self):\n", " basis = self.holomorphic_differentials_basis()\n", " g = self.genus()\n", " p = self.characteristic\n", " F = self.base_ring\n", " M = matrix(F, g, g)\n", " for i in range(0, len(basis)):\n", " w = basis[i]\n", " v = w.cartier().coordinates()\n", " M[i, :] = v\n", " return M \n", "\n", "# def p_rank(self):\n", "# return self.cartier_matrix().rank()\n", " \n", " def a_number(self):\n", " g = C.genus()\n", " return g - self.cartier_matrix().rank()\n", " \n", " def final_type(self, test = 0):\n", " Fr = self.frobenius_matrix()\n", " V = self.verschiebung_matrix()\n", " p = self.characteristic\n", " return flag(Fr, V, p, test)\n", " \n", "def reduction(C, g):\n", " p = C.characteristic\n", " F = C.base_ring\n", " Rxy. = PolynomialRing(F, 2)\n", " Fxy = FractionField(Rxy)\n", " f = C.polynomial\n", " r = f.degree()\n", " m = C.exponent\n", " g = Fxy(g)\n", " g1 = g.numerator()\n", " g2 = g.denominator()\n", " \n", " Rx. = PolynomialRing(F)\n", " Fx = FractionField(Rx)\n", " FxRy. = PolynomialRing(Fx) \n", " (A, B, C) = xgcd(FxRy(g2), FxRy(y^m - f))\n", " g = FxRy(g1*B/A)\n", " \n", " while(g.degree(Rxy(y)) >= m):\n", " d = g.degree(Rxy(y))\n", " G = coff(g, d)\n", " i = floor(d/m)\n", " g = g - G*y^d + f^i * y^(d%m) *G\n", " \n", " return(FxRy(g))\n", "\n", "def reduction_form(C, g):\n", " F = C.base_ring\n", " Rxy. = PolynomialRing(F, 2)\n", " Fxy = FractionField(Rxy)\n", " f = C.polynomial\n", " r = f.degree()\n", " m = C.exponent\n", " g = reduction(C, g)\n", "\n", " g1 = Rxy(0)\n", " Rx. = PolynomialRing(F)\n", " Fx = FractionField(Rx)\n", " FxRy. = PolynomialRing(Fx)\n", " \n", " g = FxRy(g)\n", " for j in range(0, m):\n", " if j==0:\n", " G = coff(g, 0)\n", " g1 += FxRy(G)\n", " else:\n", " G = coff(g, j)\n", " g1 += Fxy(y^(j-m)*f*G)\n", " return(g1)\n", " \n", "class superelliptic_function:\n", " def __init__(self, C, g):\n", " F = C.base_ring\n", " Rxy. = PolynomialRing(F, 2)\n", " Fxy = FractionField(Rxy)\n", " f = C.polynomial\n", " r = f.degree()\n", " m = C.exponent\n", " \n", " self.curve = C\n", " g = reduction(C, g)\n", " self.function = g\n", " \n", " def __repr__(self):\n", " return str(self.function)\n", " \n", " def jth_component(self, j):\n", " g = self.function\n", " C = self.curve\n", " F = C.base_ring\n", " Rx. = PolynomialRing(F)\n", " Fx. = FractionField(Rx)\n", " FxRy. = PolynomialRing(Fx)\n", " g = FxRy(g)\n", " return coff(g, j)\n", " \n", " def __add__(self, other):\n", " C = self.curve\n", " g1 = self.function\n", " g2 = other.function\n", " g = reduction(C, g1 + g2)\n", " return superelliptic_function(C, g)\n", " \n", " def __sub__(self, other):\n", " C = self.curve\n", " g1 = self.function\n", " g2 = other.function\n", " g = reduction(C, g1 - g2)\n", " return superelliptic_function(C, g)\n", " \n", " def __mul__(self, other):\n", " C = self.curve\n", " g1 = self.function\n", " g2 = other.function\n", " g = reduction(C, g1 * g2)\n", " return superelliptic_function(C, g)\n", " \n", " def __truediv__(self, other):\n", " C = self.curve\n", " g1 = self.function\n", " g2 = other.function\n", " g = reduction(C, g1 / g2)\n", " return superelliptic_function(C, g)\n", "\n", " def diffn(self):\n", " C = self.curve\n", " f = C.polynomial\n", " m = C.exponent\n", " F = C.base_ring\n", " g = self.function\n", " Rxy. = PolynomialRing(F, 2)\n", " Fxy = FractionField(Rxy)\n", " g = Fxy(g)\n", " A = g.derivative(x)\n", " B = g.derivative(y)*f.derivative(x)/(m*y^(m-1))\n", " return superelliptic_form(C, A+B)\n", "\n", " \n", " def expansion_at_infty(self, i = 0, prec=10):\n", " C = self.curve\n", " f = C.polynomial\n", " m = C.exponent\n", " F = C.base_ring\n", " Rx. = PolynomialRing(F)\n", " f = Rx(f)\n", " Rt. = LaurentSeriesRing(F, default_prec=prec)\n", " RptW. = PolynomialRing(Rt)\n", " RptWQ = FractionField(RptW)\n", " Rxy. = PolynomialRing(F)\n", " RxyQ = FractionField(Rxy)\n", " fct = self.function\n", " fct = RxyQ(fct)\n", " r = f.degree()\n", " delta, a, b = xgcd(m, r)\n", " b = -b\n", " M = m/delta\n", " R = r/delta\n", " while a<0:\n", " a += R\n", " b += M\n", " \n", " g = (x^r*f(x = 1/x))\n", " gW = RptWQ(g(x = t^M * W^b)) - W^(delta)\n", " ww = naive_hensel(gW, F, start = root_of_unity(F, delta), prec = prec)\n", " xx = Rt(1/(t^M*ww^b))\n", " yy = 1/(t^R*ww^a)\n", " return Rt(fct(x = Rt(xx), y = Rt(yy)))\n", " \n", "def naive_hensel(fct, F, start = 1, prec=10):\n", " Rt. = LaurentSeriesRing(F, default_prec=prec)\n", " RtQ = FractionField(Rt)\n", " RptW. = PolynomialRing(RtQ)\n", " fct = RptW(fct)\n", " alpha = (fct.derivative())(W = start)\n", " w0 = Rt(start)\n", " i = 1\n", " while(i < prec):\n", " w0 = w0 - fct(W = w0)/alpha + O(t^(prec))\n", " i += 1\n", " return w0\n", "\n", "class superelliptic_form:\n", " def __init__(self, C, g):\n", " F = C.base_ring\n", " Rxy. = PolynomialRing(F, 2)\n", " Fxy = FractionField(Rxy)\n", " g = Fxy(reduction_form(C, g))\n", " self.form = g\n", " self.curve = C \n", " \n", " def __add__(self, other):\n", " C = self.curve\n", " g1 = self.form\n", " g2 = other.form\n", " g = reduction(C, g1 + g2)\n", " return superelliptic_form(C, g)\n", " \n", " def __sub__(self, other):\n", " C = self.curve\n", " g1 = self.form\n", " g2 = other.form\n", " g = reduction(C, g1 - g2)\n", " return superelliptic_form(C, g)\n", " \n", " def __repr__(self):\n", " g = self.form\n", " if len(str(g)) == 1:\n", " return str(g) + ' dx'\n", " return '('+str(g) + ') dx'\n", "\n", " def __rmul__(self, constant):\n", " C = self.curve\n", " omega = self.form\n", " return superelliptic_form(C, constant*omega) \n", " \n", " def cartier(self):\n", " C = self.curve\n", " m = C.exponent\n", " p = C.characteristic\n", " f = C.polynomial\n", " F = C.base_ring\n", " Rx. = PolynomialRing(F)\n", " Fx = FractionField(Rx)\n", " FxRy. = PolynomialRing(Fx)\n", " Fxy = FractionField(FxRy)\n", " result = superelliptic_form(C, FxRy(0))\n", " mult_order = Integers(m)(p).multiplicative_order()\n", " M = Integer((p^(mult_order)-1)/m)\n", " \n", " for j in range(1, m):\n", " fct_j = self.jth_component(j)\n", " h = Rx(fct_j*f^(M*j))\n", " j1 = (p^(mult_order-1)*j)%m\n", " B = floor(p^(mult_order-1)*j/m)\n", " result += superelliptic_form(C, polynomial_part(p, h)/(f^B*y^(j1)))\n", " return result \n", " \n", " def coordinates(self):\n", " C = self.curve\n", " F = C.base_ring\n", " m = C.exponent\n", " Rx. = PolynomialRing(F)\n", " Fx = FractionField(Rx)\n", " FxRy. = PolynomialRing(Fx)\n", " g = C.genus()\n", " degrees_holo = C.degrees_holomorphic_differentials()\n", " degrees_holo_inv = {b:a for a, b in degrees_holo.items()}\n", " basis = C.holomorphic_differentials_basis()\n", " \n", " for j in range(1, m):\n", " omega_j = Fx(self.jth_component(j))\n", " if omega_j != Fx(0):\n", " d = degree_of_rational_fctn(omega_j, F)\n", " index = degrees_holo_inv[(d, j)]\n", " a = coeff_of_rational_fctn(omega_j, F)\n", " a1 = coeff_of_rational_fctn(basis[index].jth_component(j), F)\n", " elt = self - (a/a1)*basis[index]\n", " return elt.coordinates() + a/a1*vector([F(i == index) for i in range(0, g)])\n", " \n", " return vector(g*[0])\n", " \n", " def jth_component(self, j):\n", " g = self.form\n", " C = self.curve\n", " F = C.base_ring\n", " Rx. = PolynomialRing(F)\n", " Fx = FractionField(Rx)\n", " FxRy. = PolynomialRing(Fx)\n", " Fxy = FractionField(FxRy)\n", " Ryinv. = PolynomialRing(Fx)\n", " g = Fxy(g)\n", " g = g(y = 1/y_inv)\n", " g = Ryinv(g)\n", " return coff(g, j)\n", " \n", " def is_regular_on_U0(self):\n", " C = self.curve\n", " F = C.base_ring\n", " m = C.exponent\n", " Rx. = PolynomialRing(F)\n", " for j in range(1, m):\n", " if self.jth_component(j) not in Rx:\n", " return 0\n", " return 1\n", " \n", " def is_regular_on_Uinfty(self):\n", " C = self.curve\n", " F = C.base_ring\n", " m = C.exponent\n", " f = C.polynomial\n", " r = f.degree()\n", " delta = GCD(m, r)\n", " M = m/delta\n", " R = r/delta\n", " \n", " for j in range(1, m):\n", " A = self.jth_component(j)\n", " d = degree_of_rational_fctn(A, F)\n", " if(-d*M + j*R -(M+1)<0):\n", " return 0\n", " return 1\n", "\n", " def expansion_at_infty(self, i = 0, prec=10):\n", " g = self.form\n", " C = self.curve\n", " g = superelliptic_function(C, g)\n", " g = g.expansion_at_infty(i = i, prec=prec)\n", " x_series = superelliptic_function(C, x).expansion_at_infty(i = i, prec=prec)\n", " dx_series = x_series.derivative()\n", " return g*dx_series\n", " \n", "class superelliptic_cech:\n", " def __init__(self, C, omega, fct):\n", " self.omega0 = omega\n", " self.omega8 = omega - fct.diffn()\n", " self.f = fct\n", " self.curve = C\n", " \n", " def __add__(self, other):\n", " C = self.curve\n", " return superelliptic_cech(C, self.omega0 + other.omega0, self.f + other.f)\n", " \n", " def __sub__(self, other):\n", " C = self.curve\n", " return superelliptic_cech(C, self.omega0 - other.omega0, self.f - other.f)\n", "\n", " def __rmul__(self, constant):\n", " C = self.curve\n", " w1 = self.omega0.form\n", " f1 = self.f.function\n", " w2 = superelliptic_form(C, constant*w1)\n", " f2 = superelliptic_function(C, constant*f1)\n", " return superelliptic_cech(C, w2, f2) \n", " \n", " def __repr__(self):\n", " return \"(\" + str(self.omega0) + \", \" + str(self.f) + \", \" + str(self.omega8) + \")\" \n", " \n", " def verschiebung(self):\n", " C = self.curve\n", " omega = self.omega0\n", " F = C.base_ring\n", " Rx. = PolynomialRing(F)\n", " return superelliptic_cech(C, omega.cartier(), superelliptic_function(C, Rx(0)))\n", " \n", " def frobenius(self):\n", " C = self.curve\n", " fct = self.f.function\n", " p = C.characteristic\n", " Rx. = PolynomialRing(F)\n", " return superelliptic_cech(C, superelliptic_form(C, Rx(0)), superelliptic_function(C, fct^p))\n", "\n", " def coordinates(self):\n", " C = self.curve\n", " F = C.base_ring\n", " m = C.exponent\n", " Rx. = PolynomialRing(F)\n", " Fx = FractionField(Rx)\n", " FxRy. = PolynomialRing(Fx)\n", " g = C.genus()\n", " degrees_holo = C.degrees_holomorphic_differentials()\n", " degrees_holo_inv = {b:a for a, b in degrees_holo.items()}\n", " degrees0 = C.degrees_de_rham0()\n", " degrees0_inv = {b:a for a, b in degrees0.items()}\n", " degrees1 = C.degrees_de_rham1()\n", " degrees1_inv = {b:a for a, b in degrees1.items()}\n", " basis = C.de_rham_basis()\n", " \n", " omega = self.omega0\n", " fct = self.f\n", " \n", " if fct.function == Rx(0) and omega.form != Rx(0):\n", " for j in range(1, m):\n", " omega_j = Fx(omega.jth_component(j))\n", " if omega_j != Fx(0):\n", " d = degree_of_rational_fctn(omega_j, F)\n", " index = degrees_holo_inv[(d, j)]\n", " a = coeff_of_rational_fctn(omega_j, F)\n", " a1 = coeff_of_rational_fctn(basis[index].omega0.jth_component(j), F)\n", " elt = self - (a/a1)*basis[index]\n", " return elt.coordinates() + a/a1*vector([F(i == index) for i in range(0, 2*g)])\n", " \n", " for j in range(1, m):\n", " fct_j = Fx(fct.jth_component(j))\n", " if (fct_j != Rx(0)):\n", " d = degree_of_rational_fctn(fct_j, p)\n", " \n", " if (d, j) in degrees1.values():\n", " index = degrees1_inv[(d, j)]\n", " a = coeff_of_rational_fctn(fct_j, F)\n", " elt = self - (a/m)*basis[index]\n", " return elt.coordinates() + a/m*vector([F(i == index) for i in range(0, 2*g)])\n", " \n", " if d<0:\n", " a = coeff_of_rational_fctn(fct_j, F)\n", " h = superelliptic_function(C, FxRy(a*y^j*x^d))\n", " elt = superelliptic_cech(C, self.omega0, self.f - h)\n", " return elt.coordinates()\n", " \n", " if (fct_j != Rx(0)):\n", " G = superelliptic_function(C, y^j*x^d)\n", " a = coeff_of_rational_fctn(fct_j, F)\n", " elt =self - a*superelliptic_cech(C, diffn(G), G)\n", " return elt.coordinates()\n", "\n", " return vector(2*g*[0])\n", " \n", " def is_cocycle(self):\n", " w0 = self.omega0\n", " w8 = self.omega8\n", " fct = self.f\n", " if not w0.is_regular_on_U0() and not w8.is_regular_on_Uinfty():\n", " return('w0 & w8')\n", " if not w0.is_regular_on_U0():\n", " return('w0')\n", " if not w8.is_regular_on_Uinfty():\n", " return('w8')\n", " if w0.is_regular_on_U0() and w8.is_regular_on_Uinfty():\n", " return 1\n", " return 0\n", " \n", "def degree_of_rational_fctn(f, F):\n", " Rx. = PolynomialRing(F)\n", " Fx = FractionField(Rx)\n", " f = Fx(f)\n", " f1 = f.numerator()\n", " f2 = f.denominator()\n", " d1 = f1.degree()\n", " d2 = f2.degree()\n", " return(d1 - d2)\n", "\n", "def coeff_of_rational_fctn(f, F):\n", " Rx. = PolynomialRing(F)\n", " Fx = FractionField(Rx)\n", " f = Fx(f)\n", " if f == Rx(0):\n", " return 0\n", " f1 = f.numerator()\n", " f2 = f.denominator()\n", " d1 = f1.degree()\n", " d2 = f2.degree()\n", " a1 = f1.coefficients(sparse = false)[d1]\n", " a2 = f2.coefficients(sparse = false)[d2]\n", " return(a1/a2)\n", "\n", "def coff(f, d):\n", " lista = f.coefficients(sparse = false)\n", " if len(lista) <= d:\n", " return 0\n", " return lista[d]\n", "\n", "def cut(f, i):\n", " R = f.parent()\n", " coeff = f.coefficients(sparse = false)\n", " return sum(R(x^(j-i-1)) * coeff[j] for j in range(i+1, f.degree() + 1))\n", "\n", "def polynomial_part(p, h):\n", " F = GF(p)\n", " Rx. = PolynomialRing(F)\n", " h = Rx(h)\n", " result = Rx(0)\n", " for i in range(0, h.degree()+1):\n", " if (i%p) == p-1:\n", " power = Integer((i-(p-1))/p)\n", " result += Integer(h[i]) * x^(power) \n", " return result\n", "\n", "#Find delta-th root of unity in field F\n", "def root_of_unity(F, delta):\n", " Rx. = PolynomialRing(F)\n", " cyclotomic = x^(delta) - 1\n", " for root, a in cyclotomic.roots():\n", " powers = [root^d for d in delta.divisors() if d!= delta]\n", " if 1 not in powers:\n", " return root\n", " \n", "def preimage(U, V, M): #preimage of subspace U under M\n", " basis_preimage = M.right_kernel().basis()\n", " imageU = U.intersection(M.transpose().image())\n", " basis = imageU.basis()\n", " for v in basis:\n", " w = M.solve_right(v)\n", " basis_preimage = basis_preimage + [w]\n", " return V.subspace(basis_preimage)\n", "\n", "def image(U, V, M):\n", " basis = U.basis()\n", " basis_image = []\n", " for v in basis:\n", " basis_image += [M*v]\n", " return V.subspace(basis_image)\n", "\n", "def flag(F, V, p, test = 0):\n", " dim = F.dimensions()[0]\n", " space = VectorSpace(GF(p), dim)\n", " flag_subspaces = (dim+1)*[0]\n", " flag_used = (dim+1)*[0]\n", " final_type = (dim+1)*['?']\n", " \n", " flag_subspaces[dim] = space\n", " flag_used[dim] = 1\n", " \n", " \n", " while 1 in flag_used:\n", " index = flag_used.index(1)\n", " flag_used[index] = 0\n", " U = flag_subspaces[index]\n", " U_im = image(U, space, V)\n", " d_im = U_im.dimension()\n", " final_type[index] = d_im\n", " U_pre = preimage(U, space, F)\n", " d_pre = U_pre.dimension()\n", " \n", " if flag_subspaces[d_im] == 0:\n", " flag_subspaces[d_im] = U_im\n", " flag_used[d_im] = 1\n", " \n", " if flag_subspaces[d_pre] == 0:\n", " flag_subspaces[d_pre] = U_pre\n", " flag_used[d_pre] = 1\n", " \n", " if test == 1:\n", " print('(', final_type, ')')\n", " \n", " for i in range(0, dim+1):\n", " if final_type[i] == '?' and final_type[dim - i] != '?':\n", " i1 = dim - i\n", " final_type[i] = final_type[i1] - i1 + dim/2\n", " \n", " final_type[0] = 0\n", " \n", " for i in range(1, dim+1):\n", " if final_type[i] == '?':\n", " prev = final_type[i-1]\n", " if prev != '?' and prev in final_type[i+1:]:\n", " final_type[i] = prev\n", " \n", " for i in range(1, dim+1):\n", " if final_type[i] == '?':\n", " final_type[i] = min(final_type[i-1] + 1, dim/2)\n", " \n", " if is_final(final_type, dim/2):\n", " return final_type[1:dim/2 + 1]\n", " print('error:', final_type[1:dim/2 + 1])\n", " \n", "def is_final(final_type, dim):\n", " n = len(final_type)\n", " if final_type[0] != 0:\n", " return 0\n", " \n", " if final_type[n-1] != dim:\n", " return 0\n", " \n", " for i in range(1, n):\n", " if final_type[i] != final_type[i - 1] and final_type[i] != final_type[i - 1] + 1:\n", " return 0\n", " return 1" ] }, { "cell_type": "code", "execution_count": 0, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ ] }, { "cell_type": "code", "execution_count": 56, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "Rx. = PolynomialRing(GF(5))\n", "f = x^7 + x + 1\n", "C = superelliptic(f, 2)" ] }, { "cell_type": "code", "execution_count": 58, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "omega = C.de_rham_basis()[3]" ] }, { "cell_type": "code", "execution_count": 51, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "3*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)" ] }, "execution_count": 51, "metadata": { }, "output_type": "execute_result" } ], "source": [ "omega.omega8().exp" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "F = QQ\n", "Rt. = LaurentSeriesRing(F, default_prec=20)\n", "RtQ = FractionField(Rt)\n", "RptW. = PolynomialRing(RtQ)\n", "fct = W^2 - (1+t)" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "A = naive_hensel(fct, F, start = 1, prec=10)" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "collapsed": false, "scrolled": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "WARNING: Some output was deleted.\n" ] } ], "source": [ "A^2 - (1+t)" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "FF = GF(5^6)" ] }, { "cell_type": "code", "execution_count": 56, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[(4, 1),\n", " (1, 1),\n", " (3*z6^5 + 4*z6^4 + 3*z6^2 + 2*z6 + 2, 1),\n", " (3*z6^5 + 4*z6^4 + 3*z6^2 + 2*z6 + 1, 1),\n", " (2*z6^5 + z6^4 + 2*z6^2 + 3*z6 + 4, 1),\n", " (2*z6^5 + z6^4 + 2*z6^2 + 3*z6 + 3, 1)]" ] }, "execution_count": 56, "metadata": { }, "output_type": "execute_result" } ], "source": [ "Rx. = PolynomialRing(FF)\n", "(x^6 - 1).roots()" ] }, { "cell_type": "code", "execution_count": 57, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "3*z2 + 3" ] }, "execution_count": 57, "metadata": { }, "output_type": "execute_result" } ], "source": [ "root_of_unity(GF(5^2), 3)" ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "x^2 + x + 1" ] }, "execution_count": 52, "metadata": { }, "output_type": "execute_result" } ], "source": [ "Rx. = PolynomialRing(GF(5^3))\n", "Rx(x^2 + x + 1).factor()" ] }, { "cell_type": "code", "execution_count": 53, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "a = GF(5^3).random_element()" ] }, { "cell_type": "code", "execution_count": 0, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "a" ] } ], "metadata": { "kernelspec": { "display_name": "SageMath 9.5", "language": "sagemath", "metadata": { "cocalc": { "description": "Open-source mathematical software system", "priority": 1, "url": "https://www.sagemath.org/" } }, "name": "sage-9.5", "resource_dir": "/ext/jupyter/kernels/sage-9.5" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.9" } }, "nbformat": 4, "nbformat_minor": 4 }