DeRhamComputation/superelliptic.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 55,
   "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.<x> = PolynomialRing(F)\n",
    "        Rxy.<x, y> = 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.<x> = PolynomialRing(F)\n",
    "        Rxy.<x, y> = 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.<x> = PolynomialRing(F)\n",
    "        Rxy.<x, y> = 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.<x, y> = 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.<x> = PolynomialRing(F)\n",
    "    Fx = FractionField(Rx)\n",
    "    FxRy.<y> = 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.<x, y> = 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.<x> = PolynomialRing(F)\n",
    "    Fx = FractionField(Rx)\n",
    "    FxRy.<y> = 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.<x, y> = 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.<x> = PolynomialRing(F)\n",
    "        Fx.<x> = FractionField(Rx)\n",
    "        FxRy.<y> = 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.<x, y> = 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.<x> = PolynomialRing(F)\n",
    "        f = Rx(f)\n",
    "        Rt.<t> = LaurentSeriesRing(F, default_prec=prec)\n",
    "        RptW.<W> = PolynomialRing(Rt)\n",
    "        RptWQ = FractionField(RptW)\n",
    "        Rxy.<x, y> = 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.<t> = LaurentSeriesRing(F, default_prec=prec)\n",
    "    RtQ = FractionField(Rt)\n",
    "    RptW.<W> = PolynomialRing(RtQ)\n",
    "    fct = RptW(fct)\n",
    "    alpha = (fct.derivative())(W = start)\n",
    "    w0 = Rt(1)\n",
    "    i = 1\n",
    "    while(i < prec):\n",
    "        a = 0\n",
    "        while(Rt(fct(W = w0)).valuation()) <= i:\n",
    "            w0 = w0 - fct(W = w0)/alpha\n",
    "        i += 1\n",
    "    return w0\n",
    "\n",
    "class superelliptic_form:\n",
    "    def __init__(self, C, g):\n",
    "        F = C.base_ring\n",
    "        Rxy.<x, y> = 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.<x> = PolynomialRing(F)\n",
    "        Fx = FractionField(Rx)\n",
    "        FxRy.<y> = 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.<x> = PolynomialRing(F)\n",
    "        Fx = FractionField(Rx)\n",
    "        FxRy.<y> = 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.<x> = PolynomialRing(F)\n",
    "        Fx = FractionField(Rx)\n",
    "        FxRy.<y> = PolynomialRing(Fx)\n",
    "        Fxy = FractionField(FxRy)\n",
    "        Ryinv.<y_inv> = 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.<x> = 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.<x> = 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.<x> = 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.<x> = PolynomialRing(F)\n",
    "        Fx = FractionField(Rx)\n",
    "        FxRy.<y> = 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.<x> = 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.<x> = 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.<x> = 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.<x> = 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.<x> = 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.<t> = LaurentSeriesRing(F, default_prec=20)\n",
    "RtQ = FractionField(Rt)\n",
    "RptW.<W> = 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.<x> = 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.<x> = 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
}