{ "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", " 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)^i, 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", " RptWQ = FractionField(RptW)\n", " fct = RptWQ(fct)\n", " fct = RptW(numerator(fct))\n", " #return(fct)\n", " #while fct not in RptW:\n", " # print(fct)\n", " # fct *= W\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": 2, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "class as_cover:\n", " def __init__(self, C, list_of_fcts, prec = 10):\n", " self.quotient = C\n", " self.functions = list_of_fcts\n", " self.height = len(list_of_fcts)\n", " p = C.characteristic\n", " self.characteristic = p\n", " self.prec = prec\n", " f = C.polynomial\n", " m = C.exponent\n", " r = f.degree()\n", " delta = GCD(m, r)\n", " self.nb_of_pts_at_infty = delta\n", " Rxy. = PolynomialRing(GF(p), 2)\n", " Rt. = LaurentSeriesRing(GF(p), default_prec=prec)\n", "\n", " all_x_series = []\n", " all_y_series = []\n", " all_z_series = []\n", " all_dx_series = []\n", " all_jumps = []\n", "\n", " for i in range(delta):\n", " x_series = superelliptic_function(C, x).expansion_at_infty(i = i, prec=prec)\n", " y_series = superelliptic_function(C, y).expansion_at_infty(i = i, prec=prec)\n", " z_series = []\n", " jumps = []\n", " n = len(list_of_fcts)\n", " list_of_power_series = [g.expansion_at_infty(i = i, prec=prec) for g in list_of_fcts]\n", " for i in range(n):\n", " power_series = list_of_power_series[i]\n", " jump, correction, t_old, z = artin_schreier_transform(power_series, prec = prec)\n", " x_series = x_series(t = t_old)\n", " y_series = y_series(t = t_old)\n", " z_series = [zi(t = t_old) for zi in z_series]\n", " z_series += [z]\n", " jumps += [jump]\n", " list_of_power_series = [g(t = t_old) for g in list_of_power_series]\n", " \n", " all_jumps += [jumps]\n", " all_x_series += [x_series]\n", " all_y_series += [y_series]\n", " all_z_series += [z_series]\n", " all_dx_series += [x_series.derivative()]\n", " self.jumps = all_jumps\n", " self.x = all_x_series\n", " self.y = all_y_series\n", " self.z = all_z_series\n", " self.dx = all_dx_series\n", " \n", " def __repr__(self):\n", " n = self.height\n", " p = self.characteristic\n", " if n==1:\n", " return \"(Z/p)-cover of \" + str(self.quotient)+\" with the equation:\\n z^\" + str(p) + \" - z = \" + str(self.functions[0])\n", " \n", " result = \"(Z/p)^\"+str(self.height)+ \"-cover of \" + str(self.quotient)+\" with the equations:\\n\"\n", " for i in range(n):\n", " result += 'z' + str(i) + \"^\" + str(p) + \" - z\" + str(i) + \" = \" + str(self.functions[i]) + \"\\n\"\n", " return result\n", " \n", " def genus(self):\n", " jumps = self.jumps\n", " gY = self.quotient.genus()\n", " n = self.height\n", " delta = self.nb_of_pts_at_infty\n", " return p*gY + (p^n - 1)*(delta - 1) + sum(p^(n-j-1)*(jumps[i][j]-1)*(p-1)/2 for j in range(n) for i in range(delta))\n", " \n", " def exponent_of_different(self, i = 0):\n", " jumps = self.jumps\n", " n = self.height\n", " delta = self.nb_of_pts_at_infty\n", " return sum(p^(n-j-1)*(jumps[i][j]+1)*(p-1) for j in range(n))\n", "\n", " def holomorphic_differentials_basis(self):\n", " from itertools import product\n", " x_series = self.x\n", " y_series = self.y\n", " z_series = self.z\n", " dx_series = self.dx\n", " delta = self.nb_of_pts_at_infty\n", " p = self.characteristic\n", " n = self.height\n", " prec = self.prec\n", " C = self.quotient\n", " m = C.exponent\n", " r = C.polynomial.degree()\n", " variable_names = 'x, y'\n", " for i in range(n):\n", " variable_names += ', z' + str(i)\n", " Rxyz = PolynomialRing(GF(p), n+2, variable_names)\n", " x, y = Rxyz.gens()[:2]\n", " z = Rxyz.gens()[2:]\n", " RxyzQ = FractionField(Rxyz)\n", " Rt. = LaurentSeriesRing(GF(p), default_prec=prec)\n", " #Tworzymy zbiór S form z^i x^j y^k dx/y o waluacji >= waluacja z^(p-1)*dx/y\n", " S = []\n", " RQxyz = FractionField(Rxyz)\n", " pr = [list(GF(p)) for _ in range(n)]\n", " for i in range(0, 3*r):\n", " for j in range(0, m):\n", " for k in product(*pr):\n", " eta = as_form(self, x^i * prod(z[i1]^(k[i1]) for i1 in range(n))/y^j)\n", " eta_exp = eta.expansion_at_infty()\n", " S += [(eta, eta_exp)]\n", "\n", " forms = holomorphic_combinations(S)\n", " \n", " for i in range(1, delta):\n", " forms = [(omega, omega.expansion_at_infty(i = i)) for omega in forms]\n", " forms = holomorphic_combinations(forms)\n", " \n", " if len(forms) < self.genus():\n", " print(\"I haven't found all forms.\")\n", " return forms\n", "\n", "#given a set S of (form, corresponding Laurent series at some pt), find their combinations holomorphic at that pt\n", "def holomorphic_combinations(S):\n", " C_AS = S[0][0].curve\n", " p = C_AS.characteristic\n", " F = GF(p)\n", " prec = C_AS.prec\n", " Rt. = LaurentSeriesRing(F, default_prec=prec)\n", " RtQ = FractionField(Rt)\n", " minimal_valuation = min([g[1].valuation() for g in S])\n", " if minimal_valuation >= 0:\n", " return [s[0] for s in S]\n", " list_of_lists = [] #to będzie lista złożona z list współczynników część nieholomorficznych rozwinięcia form z S\n", " for eta, eta_exp in S:\n", " a = -minimal_valuation + eta_exp.valuation()\n", " list_coeffs = a*[0] + eta_exp.list() + (-minimal_valuation)*[0]\n", " list_coeffs = list_coeffs[:-minimal_valuation]\n", " list_of_lists += [list_coeffs]\n", " M = matrix(GF(p), list_of_lists)\n", " V = M.kernel() #chcemy wyzerować części nieholomorficzne, biorąc kombinacje form z S\n", "\n", "\n", " # Sprawdzamy, jakim formom odpowiadają elementy V.\n", " forms = []\n", " for vec in V.basis():\n", " forma_holo = as_form(C_AS, 0)\n", " forma_holo_power_series = Rt(0)\n", " for vec_wspolrzedna, elt_S in zip(vec, S):\n", " eta = elt_S[0]\n", " #eta_exp = elt_S[1]\n", " forma_holo += vec_wspolrzedna*eta\n", " #forma_holo_power_series += vec_wspolrzedna*eta_exp\n", " forms += [forma_holo]\n", " return forms\n", "\n", "class as_function:\n", " def __init__(self, C, g):\n", " self.curve = C\n", " n = C.height\n", " variable_names = 'x, y'\n", " for i in range(n):\n", " variable_names += ', z' + str(i)\n", " Rxyz = PolynomialRing(GF(p), n+2, variable_names)\n", " x, y = Rxyz.gens()[:2]\n", " z = Rxyz.gens()[2:]\n", " RxyzQ = FractionField(Rxyz)\n", " self.function = RxyzQ(g)\n", " \n", " \n", "class as_form:\n", " def __init__(self, C, g):\n", " self.curve = C\n", " n = C.height\n", " variable_names = 'x, y'\n", " for i in range(n):\n", " variable_names += ', z' + str(i)\n", " Rxyz = PolynomialRing(GF(p), n+2, variable_names)\n", " x, y = Rxyz.gens()[:2]\n", " z = Rxyz.gens()[2:]\n", " RxyzQ = FractionField(Rxyz)\n", " self.form = RxyzQ(g)\n", " \n", " def __repr__(self):\n", " return \"(\" + str(self.form)+\") * dx\"\n", " \n", " def expansion_at_infty(self, i = 0):\n", " C = self.curve\n", " delta = C.nb_of_pts_at_infty\n", " x_series = C.x[i]\n", " y_series = C.y[i]\n", " z_series = C.z[i]\n", " dx_series = C.dx[i]\n", " n = C.height\n", " variable_names = 'x, y'\n", " for j in range(n):\n", " variable_names += ', z' + str(j)\n", " Rxyz = PolynomialRing(GF(p), n+2, variable_names)\n", " x, y = Rxyz.gens()[:2]\n", " z = Rxyz.gens()[2:]\n", " RxyzQ = FractionField(Rxyz)\n", " prec = C.prec\n", " Rt. = LaurentSeriesRing(GF(p), default_prec=prec)\n", " g = self.form\n", " sub_list = {x : x_series, y : y_series} | {z[j] : z_series[j] for j in range(n)}\n", " return g.substitute(sub_list)*dx_series\n", " \n", " def __add__(self, other):\n", " C = self.curve\n", " g1 = self.form\n", " g2 = other.form\n", " return as_form(C, g1 + g2)\n", " \n", " def __sub__(self, other):\n", " C = self.curve\n", " g1 = self.form\n", " g2 = other.form\n", " return as_form(C, g1 - g2)\n", " \n", " def __rmul__(self, constant):\n", " C = self.curve\n", " omega = self.form\n", " return as_form(C, constant*omega)\n", "\n", " def group_action(self, ZN_tuple):\n", " C = self.curve\n", " n = C.height\n", " variable_names = 'x, y'\n", " for j in range(n):\n", " variable_names += ', z' + str(j)\n", " Rxyz = PolynomialRing(GF(p), n+2, variable_names)\n", " x, y = Rxyz.gens()[:2]\n", " z = Rxyz.gens()[2:]\n", " RxyzQ = FractionField(Rxyz)\n", " sub_list = {x : x, y : y} | {z[j] : z[j]+ZN_tuple[j] for j in range(n)}\n", " g = self.form\n", " return as_form(C, g.substitute(sub_list))\n", " \n", " def coordinates(self):\n", " C = self.curve\n", " n = C.height\n", " gC = C.genus()\n", " holo = C.holomorphic_differentials_basis()\n", " nb_of_coeffs = 2*gC\n", " holo_exp = [omega.expansion_at_infty() for omega in holo]\n", " list_of_coeffs = []\n", " for omega in holo_exp:\n", " a = omega.valuation()\n", " added_list = list(omega)[:nb_of_coeffs]\n", " added_list = a*[0] + added_list\n", " added_list = added_list[:nb_of_coeffs]\n", " list_of_coeffs += [added_list]\n", " M = matrix(GF(p), list_of_coeffs)\n", " M = M.transpose()\n", " omega = self.expansion_at_infty()\n", " a = omega.valuation()\n", " v = list(omega)[:nb_of_coeffs]\n", " v = a*[0] + v\n", " v = v[:nb_of_coeffs]\n", " v = vector(v)\n", " v1 = M.solve_right(v)\n", " return v1\n", "\n", "def val_magical(C_AS):\n", " n = C_AS.height\n", " variable_names = 'x, y'\n", " for i in range(n):\n", " variable_names += ', z' + str(i)\n", " Rxyz = PolynomialRing(GF(p), n+2, variable_names)\n", " x, y = Rxyz.gens()[:2]\n", " z = Rxyz.gens()[2:]\n", " RxyzQ = FractionField(Rxyz)\n", " C = C_AS.quotient\n", " forms = C.holomorphic_differentials_basis()\n", " z_mag = prod(z[i]^(p-1) for i in range(n))\n", " forms_list = [z_mag*RxyzQ(omega.form) for omega in forms]\n", " forms_list = [as_form(C_AS, omega) for omega in forms_list]\n", " forms_list = [omega.expansion_at_infty() for omega in forms_list]\n", " forms_list = [omega.valuation() for omega in forms_list]\n", " return min(forms_list)\n", "\n", "\n", "\n", "# Given power_series, find its reverse (g with g \\circ power_series = id) with given precision\n", "\n", "def new_reverse(power_series, prec = 10):\n", " F = power_series.parent().base()\n", " Rt. = LaurentSeriesRing(F, default_prec=prec)\n", " RtQ = FractionField(Rt)\n", " power_series = RtQ(power_series)\n", " a = power_series.list()[0]\n", " g = 1/a*t\n", " n = 2\n", " while(n <= prec):\n", " aux = power_series(t = g) - t\n", " if aux.valuation() > n:\n", " b = 0\n", " else:\n", " b = aux.list()[0]\n", " g = g - b/a*t^n\n", " n += 1\n", " return g\n", "\n", "# Given a power_series, find correction such that power_series - (correction)^p +correction has valuation\n", "# -jump non divisible by p. Also, express t (the variable) in terms of the uniformizer at infty on the curve\n", "# z^p - z = power_series, where z = 1/t_new^(jump) and express z in terms of the new uniformizer.\n", "\n", "def artin_schreier_transform(power_series, prec = 10):\n", " correction = 0\n", " F = power_series.parent().base()\n", " Rt. = LaurentSeriesRing(F, default_prec=prec)\n", " RtQ = FractionField(Rt)\n", " power_series = RtQ(power_series)\n", " if power_series.valuation() == +Infinity:\n", " return(0,0,t,0)\n", " while(power_series.valuation() % p == 0 and power_series.valuation() < 0):\n", " M = -power_series.valuation()/p\n", " coeff = power_series.list()[0] #wspolczynnik a_(-p) w f_AS\n", " correction += coeff*t^(-M)\n", " power_series = power_series - coeff*(t^(-p*M) - t^(-M))\n", " jump = max(-(power_series.valuation()), 0)\n", " try:\n", " T = ((power_series)^(-1)).nth_root(jump) #T is defined by power_series = 1/T^m\n", " except:\n", " print(\"no \", str(jump), \"-th root; divide by\", power_series.list()[0])\n", " return (jump, power_series.list()[0])\n", " T_rev = new_reverse(T, prec = prec)\n", " t_old = T_rev(t^p/(1 - t^((p-1)*jump)).nth_root(jump))\n", " z = 1/t^(jump) + Rt(correction)(t = t_old)\n", " return(jump, correction, t_old, z)\n", "\n", "\n", "def are_forms_linearly_dependent(set_of_forms):\n", " from sage.rings.polynomial.toy_variety import is_linearly_dependent\n", " C = set_of_forms[0].curve\n", " n = C.height\n", " variable_names = 'x, y'\n", " for i in range(n):\n", " variable_names += ', z' + str(i)\n", " Rxyz = PolynomialRing(GF(p), n+2, variable_names)\n", " denominators = prod(denominator(omega.form) for omega in set_of_forms)\n", " return is_linearly_dependent([Rxyz(denominators*omega.form) for omega in set_of_forms])\n", "\n", "def group_action_matrices(C_AS):\n", " holo = C_AS.holomorphic_differentials_basis()\n", " n = C_AS.height\n", " A = [[] for i in range(n)]\n", " for omega in holo:\n", " for i in range(n):\n", " ei = n*[0]\n", " ei[i] = 1\n", " omega1 = omega.group_action(ei)\n", " v1 = omega1.coordinates()\n", " A[i] += [v1]\n", " for i in range(n):\n", " A[i] = matrix(GF(p), A[i])\n", " A[i] = A[i].transpose()\n", " return A" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "# Testy" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "325\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "325\n" ] } ], "source": [ "p = 5\n", "m = 2\n", "Rx. = PolynomialRing(GF(p))\n", "f = x^3 + x^2 + 1\n", "C_super = superelliptic(f, m)\n", "Rxy. = PolynomialRing(GF(p), 2)\n", "fArS1 = superelliptic_function(C_super, y*x)\n", "fArS2 = superelliptic_function(C_super, y*x^2)\n", "fArS3 = superelliptic_function(C_super, y)\n", "AS1 = as_cover(C_super, [fArS1, fArS2, fArS3], prec=500)\n", "print(AS1.genus())\n", "AS2 = as_cover(C_super, [fArS2, fArS3, fArS1], prec=500)\n", "print(AS2.genus())" ] }, { "cell_type": "code", "execution_count": 0, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "p = 5\n", "m = 2\n", "Rx. = PolynomialRing(GF(p))\n", "f = x^3 + x^2 + 1\n", "C_super = superelliptic(f, m)\n", "Rxy. = PolynomialRing(GF(p), 2)\n", "fArS1 = superelliptic_function(C_super, y*x)\n", "fArS2 = superelliptic_function(C_super, y*x^2)\n", "fArS3 = superelliptic_function(C_super, y)\n", "AS1 = as_cover(C_super, [fArS1, fArS2, fArS3], prec=1000)\n", "print(AS1.exponent_of_different())\n", "omega = as_form(AS1, 1/y)\n", "print(omega.expansion_at_infty())" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "# Brudnopis" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3\n" ] } ], "source": [ "p = 11\n", "m = 2\n", "Rx. = PolynomialRing(GF(p))\n", "f = x^7 + x^2 + 1\n", "C_super = superelliptic(f, m)\n", "print(C_super.genus())" ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "33\n" ] }, { "data": { "text/plain": [ "[(x^2/y) * dx, (x^2*z0/y) * dx, ((x^2*z0^2 - x^3)/y) * dx]" ] }, "execution_count": 40, "metadata": { }, "output_type": "execute_result" } ], "source": [ "Rxy. = PolynomialRing(GF(p))\n", "fArS1 = superelliptic_function(C_super, y*x^2)\n", "AS = as_cover(C_super, [fArS1], prec=300)\n", "print(AS.genus())\n", "omega = C_super.holomorphic_differentials_basis()[2]\n", "magical_for_a_form(omega, AS)" ] }, { "cell_type": "code", "execution_count": 47, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "33" ] }, "execution_count": 47, "metadata": { }, "output_type": "execute_result" } ], "source": [ "AS.genus()" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "0 0 2 [1, 34] 198\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "0 0 6 [1, 34] 198\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "0 0 7 [1, 34] 198\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "0 0 8 [1, 34] 198\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "0 0 10 [1, 34] 198\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "0 1 0 [1, 12] 88\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "0 1 6 [1, 34] 198\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "0 1 7 [1, 34] 198\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "0 1 8 [1, 34] 198\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "0 1 10 [1, 34] 198\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "0 2 2 [1, 34] 198\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "0 2 6 [1, 34] 198\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "0 2 7 [1, 34] 198\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "0 3 2 [1, 34] 198\n" ] }, { "ename": "KeyboardInterrupt", "evalue": "", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", "Input \u001b[0;32mIn [22]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m b \u001b[38;5;129;01min\u001b[39;00m GF(p):\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m c \u001b[38;5;129;01min\u001b[39;00m GF(p):\n\u001b[0;32m---> 12\u001b[0m f1 \u001b[38;5;241m=\u001b[39m \u001b[43msuperelliptic_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43mC_super\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mx\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mInteger\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 13\u001b[0m f2 \u001b[38;5;241m=\u001b[39m superelliptic_function(C_super, a\u001b[38;5;241m*\u001b[39my\u001b[38;5;241m+\u001b[39mb\u001b[38;5;241m*\u001b[39mx\u001b[38;5;241m+\u001b[39mc\u001b[38;5;241m*\u001b[39mx\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mInteger(\u001b[38;5;241m2\u001b[39m))\n\u001b[1;32m 14\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n", "Input \u001b[0;32mIn [2]\u001b[0m, in \u001b[0;36msuperelliptic_function.__init__\u001b[0;34m(self, C, g)\u001b[0m\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28;01mclass\u001b[39;00m \u001b[38;5;21;01msuperelliptic_function\u001b[39;00m:\n\u001b[0;32m--> 210\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, C, g):\n\u001b[1;32m 211\u001b[0m F \u001b[38;5;241m=\u001b[39m C\u001b[38;5;241m.\u001b[39mbase_ring\n\u001b[1;32m 212\u001b[0m Rxy \u001b[38;5;241m=\u001b[39m PolynomialRing(F, Integer(\u001b[38;5;241m2\u001b[39m), names\u001b[38;5;241m=\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mx\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124my\u001b[39m\u001b[38;5;124m'\u001b[39m,)); (x, y,) \u001b[38;5;241m=\u001b[39m Rxy\u001b[38;5;241m.\u001b[39m_first_ngens(\u001b[38;5;241m2\u001b[39m)\n", "File \u001b[0;32msrc/cysignals/signals.pyx:310\u001b[0m, in \u001b[0;36mcysignals.signals.python_check_interrupt\u001b[0;34m()\u001b[0m\n", "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ], "source": [ "p = 11\n", "m = 2\n", "Rx. = PolynomialRing(GF(p))\n", "f = x^7 + x^2 + 1\n", "C_super = superelliptic(f, m)\n", "print(C_super.genus())\n", "Rxy. = PolynomialRing(GF(p))\n", "\n", "for a in GF(p):\n", " for b in GF(p):\n", " for c in GF(p):\n", " if (b != GF(p)(0) or a!=GF(p)(0)):\n", " f1 = superelliptic_function(C_super, y*x^2)\n", " f2 = superelliptic_function(C_super, a*y+b*x+c*x^2)\n", " try:\n", " AS = as_cover(C_super, [f1, f2], prec=500)\n", " if AS.jumps[1] >0 and AS.jumps[1] < 67:\n", " print(a, b, c, AS.jumps, AS.genus())\n", " except:\n", " pass" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "Rt. = LaurentSeriesRing(GF(p))" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n" ] } ], "source": [ "p = 5\n", "m = 1\n", "Rx. = PolynomialRing(GF(p))\n", "f = x\n", "C_super = superelliptic(f, m)\n", "print(C_super.genus())" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "Rxy. = PolynomialRing(GF(p), 2)\n", "f1 = superelliptic_function(C_super, x^3)\n", "AS = as_cover(C_super, [f1], prec=200)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[[3]]" ] }, "execution_count": 6, "metadata": { }, "output_type": "execute_result" } ], "source": [ "AS.jumps" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[(1) * dx, (z0) * dx, (z0^2) * dx, (x) * dx]" ] }, "execution_count": 7, "metadata": { }, "output_type": "execute_result" } ], "source": [ "AS.holomorphic_differentials_basis()" ] }, { "cell_type": "code", "execution_count": 243, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "9" ] }, "execution_count": 243, "metadata": { }, "output_type": "execute_result" } ], "source": [ "len(AS.holomorphic_differentials_basis())" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[1, 4], [1, 4]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "[(1) * dx, (-z0^2 + z1) * dx, (z0) * dx, (1/y) * dx, (z1/y) * dx, (z1^2/y) * dx, (z0/y) * dx, (z0*z1/y) * dx, ((-x*z0^2 + z0*z1^2)/y) * dx, (z0^2/y) * dx, (z0^2*z1/y) * dx, (x/y) * dx, ((-x*z0^2 + x*z1)/y) * dx, (x*z0/y) * dx]\n" ] } ], "source": [ "p = 3\n", "m = 2\n", "Rx. = PolynomialRing(GF(p))\n", "f = x^m + 1\n", "C_super = superelliptic(f, m)\n", "\n", "Rxy. = PolynomialRing(GF(p), 2)\n", "f1 = superelliptic_function(C_super, x)\n", "f2 = superelliptic_function(C_super, x^2)\n", "AS = as_cover(C_super, [f1, f2], prec=300)\n", "print(AS.jumps)\n", "print(AS.holomorphic_differentials_basis())" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "14" ] }, "execution_count": 25, "metadata": { }, "output_type": "execute_result" } ], "source": [ "AS.genus()" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 16, "metadata": { }, "output_type": "execute_result" } ], "source": [ "AS.genus()" ] }, { "cell_type": "code", "execution_count": 249, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[(1/y) * dx,\n", " (z0/y) * dx,\n", " ((-x^2 + z0^2)/y) * dx,\n", " ((2*x^3 + 2*x^2*z0 + z0^3)/y) * dx,\n", " ((2*x^4 - 2*x^3*z0 - x^2*z0^2 + z0^4)/y) * dx,\n", " (x/y) * dx,\n", " ((-x^2 + x*z0)/y) * dx,\n", " ((x^3 - 2*x^2*z0 + x*z0^2)/y) * dx,\n", " ((-x^4 - 2*x^3*z0 + 2*x^2*z0^2 + x*z0^3)/y) * dx]" ] }, "execution_count": 249, "metadata": { }, "output_type": "execute_result" } ], "source": [ "AS.holomorphic_differentials_basis()" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "0 0 1 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "0 0 2 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "0 1 0 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "0 1 1 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "0 1 2 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "0 2 0 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "0 2 1 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "0 2 2 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "1 0 0 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "1 0 1 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "1 0 2 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "1 1 0 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "1 1 1 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "1 1 2 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "1 2 0 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "1 2 1 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "1 2 2 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "2 0 0 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "2 0 1 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "2 0 2 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "2 1 0 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "2 1 1 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "2 1 2 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "2 2 0 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "2 2 1 [[1, 4], [1, 4]]\n", "0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "no 4 -th root; divide by 2\n", "2 2 2 [[1, 4], [1, 4]]\n" ] } ], "source": [ "p = 3\n", "m = 2\n", "Rx. = PolynomialRing(GF(p))\n", "for a in GF(p):\n", " for b in GF(p):\n", " for c in GF(p):\n", " if (a, b, c) != (0, 0, 0):\n", " f = x^2 + 1\n", " C_super = superelliptic(f, m)\n", " print(C_super.genus())\n", "\n", " Rxy. = PolynomialRing(GF(p), 2)\n", " f1 = superelliptic_function(C_super, x)\n", " f2 = superelliptic_function(C_super, )\n", " try:\n", " AS = as_cover(C_super, [f1, f2], prec=500)\n", " except:\n", " pass\n", " print(a, b, c, AS.jumps)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1 2 1 0 0 0 0 0 0 0 0 0 0 0]\n", "[0 1 0 0 0 0 0 0 0 0 0 0 0 0]\n", "[0 1 1 0 0 0 0 0 0 0 0 0 0 0]\n", "[0 0 0 1 0 0 1 0 0 1 0 0 0 0]\n", "[0 0 0 0 1 0 0 1 0 0 1 0 0 0]\n", "[0 0 0 0 0 1 0 0 1 0 0 0 0 0]\n", "[0 0 0 0 0 0 1 0 0 2 0 0 0 0]\n", "[0 0 0 0 0 0 0 1 0 0 2 0 0 0]\n", "[0 0 0 0 0 0 0 0 1 0 0 0 0 0]\n", "[0 0 0 0 0 0 0 0 0 1 0 0 0 0]\n", "[0 0 0 0 0 0 0 0 0 0 1 0 0 0]\n", "[0 0 0 0 0 0 0 0 2 0 0 1 2 1]\n", "[0 0 0 0 0 0 0 0 0 0 0 0 1 0]\n", "[0 0 0 0 0 0 0 0 1 0 0 0 1 1] [1 1 0 0 0 0 0 0 0 0 0 0 0 0]\n", "[0 1 0 0 0 0 0 0 0 0 0 0 0 0]\n", "[0 0 1 0 0 0 0 0 0 0 0 0 0 0]\n", "[0 0 0 1 1 1 0 0 0 0 0 0 0 0]\n", "[0 0 0 0 1 2 0 0 0 0 0 0 0 0]\n", "[0 0 0 0 0 1 0 0 0 0 0 0 0 0]\n", "[0 0 0 0 0 0 1 1 1 0 0 0 0 0]\n", "[0 0 0 0 0 0 0 1 2 0 0 0 0 0]\n", "[0 0 0 0 0 0 0 0 1 0 0 0 0 0]\n", "[0 0 0 0 0 0 0 0 0 1 1 0 0 0]\n", "[0 0 0 0 0 0 0 0 0 0 1 0 0 0]\n", "[0 0 0 0 0 0 0 0 0 0 0 1 1 0]\n", "[0 0 0 0 0 0 0 0 0 0 0 0 1 0]\n", "[0 0 0 0 0 0 0 0 0 0 0 0 0 1]\n" ] } ], "source": [ "A, B = group_action_matrices(AS)\n", "print(A, B)" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "collapsed": false, "scrolled": true }, "outputs": [ { "data": { "text/html": [ "\\(\\displaystyle \\begin{array}{l}\n", "\\verb\"[1\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb|[-----+-----+-----+-----+---]|\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|1\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb|[-----+-----+-----+-----+---]|\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|1\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb|[-----+-----+-----+-----+---]|\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|1\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb|[-----+-----+-----+-----+---]|\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|1\"\\verb\" \"\\verb\"1]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"1]\"\n", "\\end{array}\\)" ], "text/latex": [ "$\\displaystyle \\begin{array}{l}\n", "\\verb\"[1\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb|[-----+-----+-----+-----+---]|\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|1\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb|[-----+-----+-----+-----+---]|\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|1\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb|[-----+-----+-----+-----+---]|\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|1\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0]\"\\\\\n", "\\verb|[-----+-----+-----+-----+---]|\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|1\"\\verb\" \"\\verb\"1]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"1]\"\n", "\\end{array}$" ], "text/plain": [ "'[1 1 0|0 0 0|0 0 0|0 0 0|0 0]\\n[0 1 1|0 0 0|0 0 0|0 0 0|0 0]\\n[0 0 1|0 0 0|0 0 0|0 0 0|0 0]\\n[-----+-----+-----+-----+---]\\n[0 0 0|1 1 0|0 0 0|0 0 0|0 0]\\n[0 0 0|0 1 1|0 0 0|0 0 0|0 0]\\n[0 0 0|0 0 1|0 0 0|0 0 0|0 0]\\n[-----+-----+-----+-----+---]\\n[0 0 0|0 0 0|1 1 0|0 0 0|0 0]\\n[0 0 0|0 0 0|0 1 1|0 0 0|0 0]\\n[0 0 0|0 0 0|0 0 1|0 0 0|0 0]\\n[-----+-----+-----+-----+---]\\n[0 0 0|0 0 0|0 0 0|1 1 0|0 0]\\n[0 0 0|0 0 0|0 0 0|0 1 1|0 0]\\n[0 0 0|0 0 0|0 0 0|0 0 1|0 0]\\n[-----+-----+-----+-----+---]\\n[0 0 0|0 0 0|0 0 0|0 0 0|1 1]\\n[0 0 0|0 0 0|0 0 0|0 0 0|0 1]'" ] }, "execution_count": 27, "metadata": { }, "output_type": "execute_result" } ], "source": [ "pretty_print(A.jordan_form().str())" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "\\(\\displaystyle \\begin{array}{l}\n", "\\verb\"[1\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0|0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0|0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0|0]\"\\\\\n", "\\verb|[-----+-----+---+---+---+-+-]|\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|1\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0|0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0|0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0|0]\"\\\\\n", "\\verb|[-----+-----+---+---+---+-+-]|\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|1\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0|0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0|0]\"\\\\\n", "\\verb|[-----+-----+---+---+---+-+-]|\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|1\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0|0|0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0|0|0]\"\\\\\n", "\\verb|[-----+-----+---+---+---+-+-]|\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|1\"\\verb\" \"\\verb\"1|0|0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"1|0|0]\"\\\\\n", "\\verb|[-----+-----+---+---+---+-+-]|\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|1|0]\"\\\\\n", "\\verb|[-----+-----+---+---+---+-+-]|\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0|1]\"\n", "\\end{array}\\)" ], "text/latex": [ "$\\displaystyle \\begin{array}{l}\n", "\\verb\"[1\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0|0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0|0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0|0]\"\\\\\n", "\\verb|[-----+-----+---+---+---+-+-]|\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|1\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0|0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"1\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0|0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0|0]\"\\\\\n", "\\verb|[-----+-----+---+---+---+-+-]|\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|1\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0|0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0|0]\"\\\\\n", "\\verb|[-----+-----+---+---+---+-+-]|\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|1\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0|0|0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"1|0\"\\verb\" \"\\verb\"0|0|0]\"\\\\\n", "\\verb|[-----+-----+---+---+---+-+-]|\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|1\"\\verb\" \"\\verb\"1|0|0]\"\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"1|0|0]\"\\\\\n", "\\verb|[-----+-----+---+---+---+-+-]|\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|1|0]\"\\\\\n", "\\verb|[-----+-----+---+---+---+-+-]|\\\\\n", "\\verb\"[0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0\"\\verb\" \"\\verb\"0|0|1]\"\n", "\\end{array}$" ], "text/plain": [ "'[1 1 0|0 0 0|0 0|0 0|0 0|0|0]\\n[0 1 1|0 0 0|0 0|0 0|0 0|0|0]\\n[0 0 1|0 0 0|0 0|0 0|0 0|0|0]\\n[-----+-----+---+---+---+-+-]\\n[0 0 0|1 1 0|0 0|0 0|0 0|0|0]\\n[0 0 0|0 1 1|0 0|0 0|0 0|0|0]\\n[0 0 0|0 0 1|0 0|0 0|0 0|0|0]\\n[-----+-----+---+---+---+-+-]\\n[0 0 0|0 0 0|1 1|0 0|0 0|0|0]\\n[0 0 0|0 0 0|0 1|0 0|0 0|0|0]\\n[-----+-----+---+---+---+-+-]\\n[0 0 0|0 0 0|0 0|1 1|0 0|0|0]\\n[0 0 0|0 0 0|0 0|0 1|0 0|0|0]\\n[-----+-----+---+---+---+-+-]\\n[0 0 0|0 0 0|0 0|0 0|1 1|0|0]\\n[0 0 0|0 0 0|0 0|0 0|0 1|0|0]\\n[-----+-----+---+---+---+-+-]\\n[0 0 0|0 0 0|0 0|0 0|0 0|1|0]\\n[-----+-----+---+---+---+-+-]\\n[0 0 0|0 0 0|0 0|0 0|0 0|0|1]'" ] }, "execution_count": 28, "metadata": { }, "output_type": "execute_result" } ], "source": [ "pretty_print(B.jordan_form().str())" ] }, { "cell_type": "code", "execution_count": 0, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ ] } ], "metadata": { "kernelspec": { "display_name": "SageMath 9.7", "language": "sagemath", "metadata": { "cocalc": { "description": "Open-source mathematical software system", "priority": 10, "url": "https://www.sagemath.org/" } }, "name": "sage-9.7", "resource_dir": "/ext/jupyter/kernels/sage-9.7" }, "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.10.5" } }, "nbformat": 4, "nbformat_minor": 4 }